Uzyskaj program Visual Studio, aby uruchamiać szablon T4 w każdej kompilacji

Jak uzyskać szablon T4 do generowania wyników w każdej kompilacji? Tak jak teraz, regeneruje go tylko wtedy, gdy wprowadzam zmianę w szablonie.

Znalazłem inne pytania podobne do tego:

Transformacja T4 i kolejność kompilacji w programie Visual Studio (bez odpowiedzi)

Jak zdobyć pliki T4 do kompilacji w Visual Studio? (odpowiedzi nie są wystarczająco szczegółowe [a jednocześnie są bardzo skomplikowane] i nie mają nawet całkowitego sensu)

Musi być na to prostszy sposób!

Użyłem odpowiedzi JoelFana, aby wymyślić to. Podoba mi się to bardziej, ponieważ nie musisz pamiętać o modyfikowaniu zdarzenia pre-build za każdym razem, gdy dodajesz nowy plik .tt do projektu.

• dodaj TextTransform.exe do pliku %PATH%
• utworzył plik wsadowy o nazwie transform_all.bat (patrz poniżej)
• utwórz wydarzenie przed kompilacją „ transform_all ..\..”

transform_all.bat

@echo off
SETLOCAL ENABLEDELAYEDEXPANSION

:: set the working dir (default to current dir)
set wdir=%cd%
if not (%1)==() set wdir=%1

:: set the file extension (default to vb)
set extension=vb
if not (%2)==() set extension=%2

echo executing transform_all from %wdir%
:: create a list of all the T4 templates in the working dir
dir %wdir%\*.tt /b /s > t4list.txt

echo the following T4 templates will be transformed:
type t4list.txt

:: transform all the templates
for /f %%d in (t4list.txt) do (
set file_name=%%d
set file_name=!file_name:~0,-3!.%extension%
echo:  \--^> !file_name!    
TextTransform.exe -out !file_name! %%d
)

echo transformation complete

Zgadzam się z GarethJ - w VS2010 o wiele łatwiej jest zregenerować szablony tt na każdej kompilacji. Blog Olega Sycha opisuje, jak to zrobić. W skrócie:

1. Zainstaluj Visual Studio SDK
2. Zainstaluj pakiet SDK modelowania i wizualizacji programu Visual Studio 2010
3. Otwórz w pliku projektu edytora tekstu i dodaj na końcu pliku, ale przed </Project>

Otóż ​​to. Otwórz swój projekt. Przy każdej kompilacji wszystkie szablony * .tt zostaną ponownie przetworzone

<!-- This line could already present in file. If it is so just skip it  -->
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- process *.tt templates on each build  -->
<PropertyGroup>
    <TransformOnBuild>true</TransformOnBuild>
</PropertyGroup>
<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TextTemplating\v10.0\Microsoft.TextTemplating.targets" />

Istnieje świetny pakiet NuGet, który robi to:

PM> Install-Package Clarius.TransformOnBuild

Szczegóły dotyczące pakietu można znaleźć tutaj

Skorzystałem z odpowiedzi MarkGr i opracowałem to rozwiązanie. Najpierw utwórz plik wsadowy o nazwie RunTemplate.bat w oddzielnym folderze narzędzi powyżej głównego folderu rozwiązania. Plik wsadowy ma tylko wiersz:

"%CommonProgramFiles%\Microsoft Shared\TextTemplating\1.2\texttransform.exe" -out %1.cs -P %2 -P "%ProgramFiles%\Reference Assemblies\Microsoft\Framework\v3.5" %1.tt

Ten plik wsadowy przyjmuje 2 parametry ... % 1 to ścieżka do pliku .tt bez rozszerzenia .tt. % 2 jest ścieżką do żadnej biblioteki DLL określonych przez Assembly dyrektyw w szablonie.

Następnie przejdź do właściwości projektu zawierającego szablon T4. Przejdź do zdarzeń kompilacji i dodaj następujący wiersz poleceń zdarzenia przed kompilacją :

$(SolutionDir)..\..\tools\RunTemplate.bat $(ProjectDir)MyTemplate $(OutDir)

zastąpienie MyTemplate nazwą pliku twojego pliku .tt (np. MyTemplate.tt) bez rozszerzenia .tt. Spowoduje to rozszerzenie szablonu w celu utworzenia MyTemplate.cs przed zbudowaniem projektu. Następnie właściwa kompilacja skompiluje MyTemplate.cs

Niedawno znalazłem tę świetną wtyczkę VS, Chirpy .

Nie tylko generuje T4 w kompilacji, ale umożliwia oparte na T4 podejście do minifikacji javascript, CSS, a nawet pozwala na użycie MNIEJSZEJ składni dla twojego CSS!

Prawdopodobnie najprostszym sposobem jest zainstalowanie rozszerzenia Visual Studio o nazwie AutoT4 .

Automatycznie uruchamia wszystkie szablony T4 podczas kompilacji.

Wstępną kompilację można zredukować do jednej linii:

forfiles /p "$(ProjectDir)." /m "*.tt" /s /c "cmd /c echo Transforming @path && \"%CommonProgramFiles(x86)%\Microsoft Shared\TextTemplating\1.2\TextTransform.exe\" @file"

To przekształca wszystkie .ttpliki w projekcie i wyświetla je w danych wyjściowych kompilacji.

Jeśli nie chcesz, aby wyniki kompilacji były wyświetlane, musisz obejść kilka „interesujących zachowań” :

forfiles /p "$(ProjectDir)." /m "*.tt" /s /c "cmd /c @\"%CommonProgramFiles(x86)%\Microsoft Shared\TextTemplating\1.2\TextTransform.exe\" @file"

Oczywiście możesz wyciągnąć to do pliku wsadowego, do którego możesz przekazać ścieżkę katalogu projektu, jeśli chcesz.

Uwaga : ścieżka może wymagać pewnych poprawek. Powyższa ścieżka to miejsce, w którym VS 2008 zainstalował go na moim komputerze; ale może się okazać, że numer wersji między TextTemplatingi TextTransform.exejest inny.

Wyewidencjonuj C: \ Program Files (x86) \ Common Files \ Microsoft Shared \ Text Przypominając, że jest tam plik z transformacją wiersza poleceń. Alternatywnie napisz zadanie programu MSBuild przy użyciu hosta niestandardowego i samodzielnie przeprowadź transformację.

Rozwijając odpowiedzi Setha Reno i JoelFana , wymyśliłem to. Dzięki temu rozwiązaniu nie musisz pamiętać o modyfikowaniu zdarzenia pre-build za każdym razem, gdy dodajesz nowy plik .tt do projektu.

Procedura wdrożeniowa

• Utwórz plik wsadowy o nazwie transform_all.bat (patrz poniżej)
• Utwórz zdarzenie przed kompilacją transform_all.bat "$(ProjectDir)" $(ProjectExt)dla każdego projektu z plikiem .tt, który chcesz skompilować

transform_all.bat

@echo off
SETLOCAL ENABLEDELAYEDEXPANSION

:: set the correct path to the the app
if not defined ProgramFiles(x86). (
  echo 32-bit OS detected
  set ttPath=%CommonProgramFiles%\Microsoft Shared\TextTemplating\1.2\
) else (
  echo 64-bit OS detected
  set ttPath=%CommonProgramFiles(x86)%\Microsoft Shared\TextTemplating\1.2\
)

:: set the working dir (default to current dir)
if not (%1)==() pushd %~dp1

:: set the file extension (default to vb)
set ext=%2
if /i %ext:~1%==vbproj (
  set ext=vb
) else if /i %ext:~1%==csproj (
  set ext=cs
) else if /i [%ext%]==[] (
  set ext=vb
)

:: create a list of all the T4 templates in the working dir
echo Running TextTransform from %cd%
dir *.tt /b /s | findstr /vi obj > t4list.txt

:: transform all the templates
set blank=.
for /f "delims=" %%d in (t4list.txt) do (
  set file_name=%%d
  set file_name=!file_name:~0,-3!.%ext%
  echo:  \--^> !!file_name:%cd%=%blank%!
  "%ttPath%TextTransform.exe" -out "!file_name!" "%%d"
)

:: delete T4 list and return to previous directory
del t4list.txt
popd

echo T4 transformation complete

UWAGI

1. Transformacja tekstu zakłada, że ​​kod w szablonie T4 jest tym samym językiem, co typ projektu. Jeśli ten przypadek nie dotyczy Ciebie, będziesz musiał zastąpić $(ProjectExt)argument rozszerzeniem plików, które chcesz wygenerować w kodzie.

2. .TTpliki muszą znajdować się w katalogu projektu, w przeciwnym razie nie będą budować. Możesz budować pliki TT poza katalogiem projektu, określając inną ścieżkę jako pierwszy argument ( tj. Zamień "$(ProjectDir)"na ścieżkę zawierającą pliki TT).

3. Pamiętaj również, aby ustawić poprawną ścieżkę do transform_all.batpliku wsadowego.
   Na przykład umieściłem go w katalogu mojego rozwiązania, aby zdarzenie przed kompilacją wyglądało następująco"$(SolutionDir)transform_all.bat" "$(ProjectDir)" $(ProjectExt)

Jeśli korzystasz z programu Visual Studio 2010, możesz użyć zestawu SDK do modelowania i wizualizacji programu Visual Studio: http://code.msdn.microsoft.com/vsvmsdk

Zawiera zadania msbuild do wykonywania szablonów T4 w czasie kompilacji.

Zajrzyj na blog Olega, aby uzyskać więcej informacji: http://www.olegsych.com/2010/04/understanding-t4-msbuild-integration

Hej, mój skrypt może również analizować rozszerzenie wyjścia

for /r %1 %%f in (*.tt) do (
 for /f "tokens=3,4 delims==, " %%a in (%%f) do (
  if %%~a==extension "%CommonProgramFiles%\Microsoft Shared\TextTemplating\1.2\texttransform.exe" -out %%~pnf.%%~b -P %%~pf -P "%ProgramFiles%\Reference Assemblies\Microsoft\Framework\v3.5" %%f
 )
)
echo Exit Code = %ERRORLEVEL%

Po prostu utwórz transform_all.bat $(SolutionDir)zdarzenie pre-build, a wszystkie pliki * .tt w Twoim rozwiązaniu zostaną automatycznie przekształcone.

Dynamo.AutoTT zrobi to, czego potrzebujesz. Możesz skonfigurować go do oglądania plików za pomocą wyrażenia regularnego lub generowania podczas kompilacji. Pozwala także określić, które szablony T4 mają być uruchamiane.

Możesz go pobrać stąd: https://github.com/MartinF/Dynamo.AutoTT

Po prostu zbuduj, skopiuj dll i pliki AddIn do

C: \ Users \ Documents \ Visual Studio 2012 \ Addins \

i odejdź.

Jeśli chcesz, aby wszystko działało w VS2012, musisz zmodyfikować plik Dynamo.AutoTT.AddIn i ustawić wersję na 11.0 w pliku AddIn;

Dzięki GitHub.com/Mono/T4 w tej chwili możesz to zrobić zarówno dla kompilacji .NET Core, jak i Visual Studio, dodając to do swojego .csprojpliku:

  <ItemGroup>
    <DotNetCliToolReference Include="dotnet-t4-project-tool" Version="2.0.5" />
    <TextTemplate Include="**\*.tt" />
  </ItemGroup>

  <Target Name="TextTemplateTransform" BeforeTargets="BeforeBuild">
    <ItemGroup>
      <Compile Remove="**\*.cs" />
    </ItemGroup>
    <Exec WorkingDirectory="$(ProjectDir)" Command="dotnet t4 %(TextTemplate.Identity)" />
    <ItemGroup>
      <Compile Include="**\*.cs" />
    </ItemGroup>
  </Target>

Jeśli przekształcasz swoje szablony na różne języki programowania, powinieneś dodać coś takiego jak <Compile Remove="**\*.vb" />i <Compile Include="**\*.vb" />, aby skompilować te pliki, nawet jeśli nie masz jeszcze wygenerowanych plików.

Removei Includesztuczka potrzebna tylko przy pierwszym generowaniu, lub możesz skrócić XML w ten sposób:

  <ItemGroup>
    <DotNetCliToolReference Include="dotnet-t4-project-tool" Version="2.0.5" />
    <TextTemplate Include="**\*.tt" />
  </ItemGroup>

  <Target Name="TextTemplateTransform" BeforeTargets="BeforeBuild">
    <Exec WorkingDirectory="$(ProjectDir)" Command="dotnet t4 %(TextTemplate.Identity)" />
  </Target>

i po prostu dwukrotnie uruchom kompilację (po raz pierwszy). Jeśli wygenerowałeś już pliki zatwierdzone do repozytorium, nie będzie problemów z odbudową w obu przykładach.

W programie Visual Studio możesz chcieć zobaczyć coś takiego:

zamiast tego:

Więc dodaj coś takiego do pliku projektu:

  <ItemGroup>
    <Compile Update="UInt16Class.cs">
      <DependentUpon>UInt16Class.tt</DependentUpon>
    </Compile>
    <Compile Update="UInt32Class.cs">
      <DependentUpon>UInt32Class.tt</DependentUpon>
    </Compile>
    <Compile Update="UInt64Class.cs">
      <DependentUpon>UInt64Class.tt</DependentUpon>
    </Compile>
    <Compile Update="UInt8Class.cs">
      <DependentUpon>UInt8Class.tt</DependentUpon>
    </Compile>
  </ItemGroup>

Pełny przykład tutaj: GitHub.com/Konard/T4GenericsExample (obejmuje generowanie wielu plików z jednego szablonu).

Oto moje rozwiązanie - podobne do zaakceptowanej odpowiedzi. Wystąpił problem z naszą kontrolą źródła. Docelowe pliki .cs są tylko do odczytu, a T4 kończy się niepowodzeniem. Oto kod, który uruchamia T4 w folderze tymczasowym, porównuje pliki docelowe i kopiuje go tylko w przypadku takiej samej zmiany. Nie rozwiązuje problemu z plikami read.only, ale przynajmniej nie występuje zbyt często:

Transform.bat

ECHO Transforming T4 templates
SET CurrentDirBackup=%CD%
CD %1
ECHO %1
FOR /r %%f IN (*.tt) DO call :Transform %%f
CD %CurrentDirBackup%
ECHO T4 templates transformed
goto End

:Transform
set ttFile=%1
set csFile=%1

ECHO Transforming %ttFile%:
SET csFile=%ttFile:~0,-2%cs
For %%A in ("%ttFile%") do Set tempTT=%TEMP%\%%~nxA
For %%A in ("%csFile%") do Set tempCS=%TEMP%\%%~nxA

copy "%ttFile%" "%tempTT%
"%COMMONPROGRAMFILES(x86)%\microsoft shared\TextTemplating\11.0\TextTransform.exe"  "%tempTT%"

fc %tempCS% %csFile% > nul
if errorlevel 1 (
 :: You can try to insert you check-out command here.
 "%COMMONPROGRAMFILES(x86)%\microsoft shared\TextTemplating\11.0\TextTransform.exe"  "%ttFile%"
) ELSE (
 ECHO  no change in %csFile%
)

del %tempTT%
del %tempCS%
goto :eof

:End

Możesz spróbować dodać polecenie wypisania w wierszu (:: Możesz spróbować ....)

W swoim projekcie ustaw to jako działanie przed kompilacją:

Path-To-Transform.bat "$(ProjectDir)"

Wystarczy dodać to polecenie do zdarzenia poprzedzającego kompilację projektu:

if $(ConfigurationName) == Debug $(MSBuildToolsPath)\Msbuild.exe  /p:CustomBeforeMicrosoftCSharpTargets="$(ProgramFiles)\MSBuild\Microsoft\VisualStudio\v11.0\TextTemplating\Microsoft.TextTemplating.targets"  $(ProjectPath) /t:TransformAll 

Funkcja check on configuration = debug zapewnia, że ​​kod nie zostanie wygenerowany ponownie w trybie wydania, na przykład podczas tworzenia kompilacji na serwerze TFS.

W programie Visual Studio 2013 kliknij prawym przyciskiem myszy szablon T4 i ustaw właściwość transformacji przy kompilacji na true.

Oto jak to załatwiłem. Link . Zasadniczo budowanie na świetnym blogu (blogis.clariusconsulting.net/kzu/how-to-transform-t4-templates-on-build-without-installing-a-visual-studio-sdk/ nie można publikować więcej niż 2 links :() Wymyśliłem ten plik .targets do użytku z plikami projektowymi programu Visual Studio.

Jest to przydatne, gdy używasz innych bibliotek dll wewnątrz swojego .tt i chcesz, aby wynik zmieniał się wraz ze zmianą bibliotek dll.

Jak to działa:

1. Utwórz tt, dodaj nazwę zestawu = "$ (SolutionDir) ścieżka \ do \ other \ project \ output \ foo.dll i skonfiguruj transformację i wynik zgodnie z oczekiwaniami

2. Usuń odwołania do zestawów z .tt

3. Wewnątrz pliku proj użyj tego kodu, aby skonfigurować transformację podczas kompilacji:

   <PropertyGroup>
     <!-- Initial default value -->
     <_TransformExe>$(CommonProgramFiles)\Microsoft Shared\TextTemplating\10.0\TextTransform.exe</_TransformExe>
     <!-- If explicit VS version, override default -->
     <_TransformExe Condition="'$(VisualStudioVersion)' != ''">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\$(VisualStudioVersion)\TextTransform.exe</_TransformExe>
     <!-- Cascading probing if file not found -->
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\10.0\TextTransform.exe</_TransformExe>
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\11.0\TextTransform.exe</_TransformExe>
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\12.0\TextTransform.exe</_TransformExe>
     <!-- Future proof 'til VS2013+2 -->
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\13.0\TextTransform.exe</_TransformExe>
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\14.0\TextTransform.exe</_TransformExe>
     <_TransformExe Condition="!Exists('$(_TransformExe)')">$(CommonProgramFiles)\Microsoft Shared\TextTemplating\15.0\TextTransform.exe</_TransformExe>
   
     <IncludeForTransform>@(DllsToInclude, '&amp;quot; -r &amp;quot;')</IncludeForTransform>
   </PropertyGroup>

   • Pierwsza część lokalizuje TextTransform.exe

   • $(IncludeForTransform)będzie równa, c:\path\to\dll\foo.dll' -r c:\path\to\dll\bar.dllponieważ jest to sposób dodawania odwołań do TextTransform w wierszu poleceń

      <Target Name="TransformOnBuild" BeforeTargets="BeforeBuild">
        <!--<Message Text="$(IncludeForTransform)" />-->
        <Error Text="Failed to find TextTransform.exe tool at '$(_TransformExe)." Condition="!Exists('$(_TransformExe)')" />
        <ItemGroup>
          <_TextTransform Include="$(ProjectDir)**\*.tt" />
        </ItemGroup>
        <!-- Perform task batching for each file -->
        <Exec Command="&quot;$(_TransformExe)&quot; &quot;@(_TextTransform)&quot; -r &quot;$(IncludeForTransform)&quot;" Condition="'%(Identity)' != ''" />
      </Target>

   • <_TextTransform Include="$(ProjectDir)**\*.tt" />tworzy to listę wszystkich plików tt w projekcie i podkatalogach

   • <Exec Command="... tworzy wiersz dla każdego ze znalezionych plików .tt, który wygląda jak "C:\path\to\Transform.exe" "c:\path\to\my\proj\TransformFile.tt" -r"c:\path\to\foo.dll" -r "c:\path\to\bar.dll"

4. Pozostało tylko dodać ścieżki do bibliotek dll wewnątrz:

       <ItemGroup>
         <DllsToInclude Include="$(ProjectDir)path\to\foo.dll">
           <InProject>False</InProject>
         </DllsToInclude>
         <DllsToInclude Include="$(ProjectDir)path\to\bar.dll">
           <InProject>False</InProject>
         </DllsToInclude>
       </ItemGroup>

   Tutaj <InProject>False</InProject>ukrywa te elementy w widoku rozwiązania

Więc teraz powinieneś być w stanie wygenerować swój kod przy kompilacji i zmianie bibliotek dll.

Możesz usunąć narzędzie niestandardowe (z właściwości w programie Visual Studio), aby program VS nie próbował za każdym razem przekształcić i zakończyć się niepowodzeniem. Ponieważ usunęliśmy odwołania do zestawów w kroku 2

T4Executer robi to dla VS2019. Możesz określić szablony, które mają być ignorowane podczas kompilacji, i istnieje opcja wykonania po kompilacji.

Wystarczy zainstalować pakiet NuGet : Clarius.TransformOnBuild

Następnie za każdym razem, gdy klikniesz Odbuduj projekt (lub rozwiązanie), uruchomione zostaną pliki .tt

W programie Visual Studio 2017 (prawdopodobnie także w kolejnych wersjach) należy dodać to w zdarzeniu przed kompilacją:

"$(DevEnvDir)TextTransform.exe" -out "$(ProjectDir)YourTemplate.cs" "$(ProjectDir)YourTemplate.tt"

ps Zmień ścieżkę do szablonu, jeśli nie znajduje się w głównym katalogu projektu.

Jakiś facet zbudował w tym celu pakiet nuget .

Uwaga dodatkowa: otrzymuję błędy kompilacji zarówno z TextTemplate.exe, jak iz tego pakietu (ponieważ ten pakiet wywołuje TextTemplate.exe), ale nie z programu Visual Studio. Więc najwyraźniej zachowanie nie jest takie samo; Heads-up.

EDYCJA: To był mój problem.

Oto zdarzenie przed kompilacją przy użyciu tylko narzędzi firmy Microsoft i standardowych ścieżek. Jest testowany w vs2019 / netcore3.1.

Zastąp „AppDbContext.tt” ścieżką pliku względną projektu:

"$(MSBuildBinPath)\msbuild" $(SolutionPath) /t:$(ProjectName):Transform /p:TransformFile="AppDbContext.tt" /p:CustomAfterMicrosoftCommonTargets="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\TextTemplating\Microsoft.TextTemplating.targets"

Firma Microsoft ma również przewodnik dotyczący udostępniania makr, takich jak „$ (SolutionDirectory)”, w szablonie przy użyciu T4ParameterValues w pliku projektu.