Lassen Sie Visual Studio bei jedem Build eine T4-Vorlage ausführen

Wie bekomme ich eine T4-Vorlage, um ihre Ausgabe bei jedem Build zu generieren? So wie es jetzt ist, wird es nur neu generiert, wenn ich eine Änderung an der Vorlage vornehme.

Ich habe ähnliche Fragen gefunden:

T4-Transformation und Build-Reihenfolge in Visual Studio (unbeantwortet)

Wie bekomme ich t4-Dateien zum Erstellen in Visual Studio? (Die Antworten sind nicht detailliert genug [obwohl sie immer noch sehr kompliziert sind] und machen nicht einmal Sinn)

Es muss einen einfacheren Weg geben, dies zu tun!

Ich habe JoelFans Antwort benutzt, um darauf zu kommen. Mir gefällt es besser, weil Sie nicht daran denken müssen, das Pre-Build-Ereignis jedes Mal zu ändern, wenn Sie dem Projekt eine neue .tt-Datei hinzufügen.

• Fügen Sie TextTransform.exe zu Ihrem hinzu %PATH%
• hat eine Batch-Datei mit dem Namen transform_all.bat erstellt (siehe unten)
• Erstellen Sie ein Pre-Build-Ereignis " 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

Ich stimme GarethJ zu - in VS2010 ist es viel einfacher, tt-Vorlagen für jeden Build neu zu generieren. Oleg Sychs Blog beschreibt, wie es geht. Zusamenfassend:

1. Installieren Sie das Visual Studio SDK
2. Installieren Sie das Visual Studio 2010 Modeling and Visualization SDK
3. Öffnen Sie die Textdatei des Texteditors und fügen Sie sie am Ende der Datei hinzu, jedoch vorher </Project>

Das ist es. Öffnen Sie Ihr Projekt. Bei jedem Build werden alle * .tt-Vorlagen erneut verarbeitet

<!-- 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" />

Es gibt ein großartiges NuGet-Paket, das genau dies tut:

PM> Install-Package Clarius.TransformOnBuild

Details zum Paket finden Sie hier

Ich habe die Antwort von MarkGr verwendet und diese Lösung entwickelt. Erstellen Sie zunächst eine Batchdatei mit dem Namen RunTemplate.bat in einem separaten Tools- Ordner über dem Hauptlösungsordner . Die Batch-Datei hat nur die Zeile:

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

Diese Batch-Datei akzeptiert 2 Parameter ... % 1 ist der Pfad zur .tt-Datei ohne die Erweiterung .tt. % 2 ist der Pfad zu allen DLLs, auf die in Assembly- Anweisungen in der Vorlage verwiesen wird .

Wechseln Sie anschließend in die Projekteigenschaften des Projekts, das die T4-Vorlage enthält. Gehen Sie zu Build Events und fügen Sie die folgende Pre-Build Event-Befehlszeile hinzu :

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

Ersetzen von MyTemplate durch den Dateinamen Ihrer .tt-Datei (dh MyTemplate.tt) ohne die Erweiterung .tt. Dies hat zur Folge, dass die Vorlage erweitert wird, um MyTemplate.cs zu erstellen, bevor das Projekt erstellt wird. Dann kompiliert der eigentliche Build MyTemplate.cs

Habe kürzlich dieses großartige VS-Plugin gefunden, Chirpy .

Es generiert nicht nur Ihr T4 in einem Build, sondern ermöglicht auch einen T4-basierten Ansatz zur Minimierung von Javascript, CSS und sogar die Verwendung von WENIGER Syntax für Ihr CSS!

Am einfachsten ist es wahrscheinlich, eine Visual Studio-Erweiterung namens AutoT4 zu installieren .

Alle T4-Vorlagen werden automatisch erstellt.

Der Pre-Build kann auf eine einzelne Zeile reduziert werden:

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

Dadurch werden alle .ttDateien im Projekt transformiert und in der Build-Ausgabe aufgelistet.

Wenn Sie die Build-Ausgabe nicht möchten, müssen Sie ein "interessantes Verhalten" umgehen :

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

Natürlich können Sie dies in eine Batch-Datei ziehen, an die Sie den Projektverzeichnispfad übergeben, wenn Sie dies wünschen.

Hinweis: Der Pfad muss möglicherweise angepasst werden. Im obigen Pfad hat VS 2008 es auf meinem Computer installiert. Möglicherweise stellen Sie jedoch fest, dass die Versionsnummer zwischen TextTemplatingund TextTransform.exeunterschiedlich ist.

Schauen Sie sich C: \ Programme (x86) \ Gemeinsame Dateien \ Microsoft Shared \ TextTemplating an. Dort befindet sich eine Befehlszeilentransformations-Exe. Alternativ können Sie eine MSBuild-Aufgabe mit einem benutzerdefinierten Host schreiben und die Transformation selbst durchführen.

Ich habe die Antworten von Seth Reno und JoelFan erweitert und mir das ausgedacht . Bei dieser Lösung müssen Sie nicht daran denken, das Pre-Build-Ereignis jedes Mal zu ändern, wenn Sie dem Projekt eine neue .tt-Datei hinzufügen.

Implementierungsverfahren

• Erstellen Sie eine Batchdatei mit dem Namen transform_all.bat (siehe unten).
• Erstellen Sie transform_all.bat "$(ProjectDir)" $(ProjectExt)für jedes Projekt ein Pre-Build-Ereignis mit einer .tt, die Sie erstellen möchten

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

ANMERKUNGEN

1. Bei der Textumwandlung wird davon ausgegangen, dass der Code in der T4-Vorlage dieselbe Sprache wie Ihr Projekttyp hat. Wenn dieser Fall für Sie nicht zutrifft, müssen Sie das $(ProjectExt)Argument durch die Erweiterung der Dateien ersetzen, die der Code generieren soll.

2. .TTDateien müssen sich im Projektverzeichnis befinden, sonst werden sie nicht erstellt. Sie können TT-Dateien außerhalb des Projektverzeichnisses erstellen, indem Sie als erstes Argument einen anderen Pfad angeben ( dh durch "$(ProjectDir)"den Pfad ersetzen, der die TT-Dateien enthält).

3. Denken Sie auch daran, den richtigen Pfad zur transform_all.batBatch-Datei festzulegen.
   Zum Beispiel habe ich es in mein Lösungsverzeichnis gestellt, sodass das Pre-Build-Ereignis wie folgt war"$(SolutionDir)transform_all.bat" "$(ProjectDir)" $(ProjectExt)

Wenn Sie Visual Studio 2010 verwenden, können Sie das Visual Studio-Modellierungs- und Visualisierungs-SDK verwenden: http://code.msdn.microsoft.com/vsvmsdk

Dies enthält msbuild-Aufgaben zum Ausführen von T4-Vorlagen zur Erstellungszeit.

Weitere Erklärungen finden Sie in Olegs Blog: http://www.olegsych.com/2010/04/understanding-t4-msbuild-integration

Hey, mein Skript kann auch die Ausgabeerweiterung analysieren

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%

Erstellen Sie einfach ein transform_all.bat $(SolutionDir)Pre-Build-Ereignis, und alle * .tt-Dateien in Ihrer Lösung werden automatisch transformiert.

Dynamo.AutoTT macht das, was Sie brauchen. Sie können es so konfigurieren, dass Dateien über einen regulären Ausdruck überwacht oder beim Erstellen generiert werden. Außerdem können Sie angeben, welche T4-Vorlagen ausgelöst werden sollen.

Sie können es hier herunterladen: https://github.com/MartinF/Dynamo.AutoTT

Erstellen Sie es einfach, kopieren Sie die DLL- und AddIn-Dateien in

C: \ Benutzer \ Dokumente \ Visual Studio 2012 \ Addins \

und los gehts.

Wenn Sie es in VS2012 zum Laufen bringen möchten, müssen Sie die Datei Dynamo.AutoTT.AddIn ändern und die Version in der AddIn-Datei auf 11.0 setzen.

Dank GitHub.com/Mono/T4 können Sie dies derzeit sowohl für .NET Core- als auch für Visual Studio-Builds tun, indem Sie Folgendes zu Ihrer .csprojDatei hinzufügen :

  <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>

Wenn Sie Ihre Vorlagen in verschiedene Programmiersprachen umwandeln, sollten Sie so etwas wie <Compile Remove="**\*.vb" />und hinzufügen <Compile Include="**\*.vb" />, um diese Dateien zu kompilieren, auch wenn Sie noch keine Dateien generiert haben.

Removeund IncludeTrick nur für die erste Generierung benötigt, oder Sie können das XML-kürzer wie folgt machen:

  <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>

und führen Sie build einfach zweimal aus (zum ersten Mal). Wenn Sie bereits Dateien generiert haben, die für das Repository festgeschrieben wurden, treten bei Neuerstellungen mit beiden Beispielen keine Probleme auf.

In Visual Studio möchten Sie möglicherweise Folgendes sehen:

an Stelle von:

Fügen Sie Ihrer Projektdatei also Folgendes hinzu:

  <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>

Vollständiges Beispiel hier: GitHub.com/Konard/T4GenericsExample (beinhaltet die Generierung mehrerer Dateien aus einer einzigen Vorlage).

Hier ist meine Lösung - ähnlich der akzeptierten Antwort. Wir hatten ein Problem mit unserer Quellcodeverwaltung. Die CS-Zieldateien sind schreibgeschützt und der T4 ist ausgefallen. Hier ist der Code, der T4 im temporären Ordner ausführt, Zieldateien vergleicht und nur bei derselben Änderung kopiert. Es behebt das Problem mit read.only-Dateien nicht, tritt jedoch zumindest nicht sehr häufig auf:

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

Sie können versuchen, Ihren Check-out-Befehl in eine Zeile einzufügen (:: Sie können versuchen ....)

Stellen Sie dies in Ihrem Projekt als vorgefertigte Aktion ein:

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

Sie müssen diesen Befehl nur zum Pre-Build-Ereignis des Projekts hinzufügen:

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

Durch die Überprüfung von configuration = debug wird sichergestellt, dass Sie den Code nicht im Freigabemodus neu generieren, wenn Sie beispielsweise den Build auf dem TFS-Buildserver ausführen.

Klicken Sie in Visual Studio 2013 mit der rechten Maustaste auf die T4-Vorlage und setzen Sie die Eigenschaft "Transformation on Build" auf "true".

Hier ist, wie ich es angepackt habe. Link . Aufbauend auf einem großartigen Blog (blogs.clariusconsulting.net/kzu/how-to-transform-t4-templates-on-build-without-installing-a-visual-studio-sdk/ kann nicht mehr als 2 posten links :() Ich habe mir diese .targets- Datei für die Verwendung mit Visual Studio-Projektdateien ausgedacht.

Dies ist nützlich, wenn Sie andere DLLs in Ihrer .tt verwenden und möchten, dass sich das Ergebnis ändert, wenn sich die DLLs ändern.

Wie es funktioniert:

1. Erstellen Sie das tt, fügen Sie den Assemblynamen = "$ (SolutionDir) path \ to \ other \ project \ output \ foo.dll hinzu und richten Sie die Transformation und das Ergebnis wie erwartet ein

2. Entfernen Sie die Assemblyreferenzen aus .tt

3. Verwenden Sie diesen Code in der proj-Datei, um die Transformation beim Erstellen einzurichten:

   <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>

   • Erster Teil Findet TextTransform.exe

   • $(IncludeForTransform)wird gleich sein, c:\path\to\dll\foo.dll' -r c:\path\to\dll\bar.dllda auf diese Weise Referenzen für die TextTransform in der Befehlszeile hinzugefügt werden

      <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" />Dadurch wird eine Liste aller tt-Dateien im Projekt und in den Unterverzeichnissen erstellt

   • <Exec Command="... Erzeugt eine Zeile für jede der gefundenen .tt-Dateien, die aussieht "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. Sie müssen nur noch die Pfade zu den DLLs in folgenden Bereichen hinzufügen:

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

   Hier werden <InProject>False</InProject>diese Elemente in der Lösungsansicht ausgeblendet

Jetzt sollten Sie in der Lage sein, Ihren Code beim Erstellen und Ändern von DLLs zu generieren.

Sie können das benutzerdefinierte Tool (aus den Eigenschaften in Visual Studio) entfernen, damit der VS nicht jedes Mal versucht, eine Transformation durchzuführen und kläglich fehlzuschlagen. Weil wir die Assemblyreferenzen in Schritt 2 entfernt haben

T4Executer erledigt dies für VS2019. Sie können Vorlagen angeben, die beim Erstellen ignoriert werden sollen, und es gibt eine Option zum Ausführen nach dem Erstellen.

Sie installieren einfach das NuGet-Paket: Clarius.TransformOnBuild

Jedes Mal, wenn Sie auf Projekt (oder Lösung) neu erstellen klicken , werden Ihre .tt- Dateien ausgeführt

In Visual Studio 2017 (wahrscheinlich auch in den nächsten Versionen) sollten Sie dies im Pre-Build-Ereignis hinzufügen:

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

ps Ändern Sie den Pfad zu Ihrer Vorlage, wenn sie sich nicht im Stammprojektverzeichnis befindet.

Ein Typ hat dafür ein Nuget-Paket gebaut .

Randnotiz: Ich erhalte Kompilierungsfehler sowohl von TextTemplate.exe als auch von diesem Paket (da dieses Paket TextTemplate.exe aufruft), jedoch nicht von Visual Studio. Anscheinend ist das Verhalten also nicht dasselbe. Kopf hoch.

EDIT: Dies war mein Problem.

Hier ist ein Pre-Build-Ereignis, das nur Microsoft Tooling und Standardpfade verwendet. Es wurde in vs2019 / netcore3.1 getestet.

Ersetzen Sie "AppDbContext.tt" durch Ihren projektbezogenen Dateipfad:

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

Microsoft hat auch eine Anleitung, um Makros wie "$ (SolutionDirectory)" in der Vorlage verfügbar zu machen, indem Sie T4ParameterValues in Ihrer Projektdatei verwenden.