Получить Visual Studio для запуска шаблона T4 на каждой сборке

Как получить шаблон T4 для генерации выходных данных при каждой сборке? Как и сейчас, он восстанавливается только когда я изменяю шаблон.

Я нашел другие вопросы, похожие на это:

Преобразование T4 и порядок сборки в Visual Studio (без ответа)

Как получить файлы t4 для сборки в visual studio? (ответы недостаточно подробны [хотя все еще достаточно сложны] и даже не имеют полного смысла)

Должен быть более простой способ сделать это!

Я использовал ответ Джоэл Фана, чтобы придумать это. Мне это нравится больше, потому что вам не нужно помнить об изменении события перед сборкой каждый раз, когда вы добавляете новый файл .tt в проект.

• добавить TextTransform.exe к вашему %PATH%
• создал пакетный файл с именем transform_all.bat (см. ниже)
• создать событие перед сборкой " 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

Я согласен с GarethJ - в VS2010 гораздо проще восстанавливать шаблоны tt при каждой сборке. Блог Олега Сыча описывает, как это сделать. Коротко:

1. Установите Visual Studio SDK
2. Установите Visual Studio 2010 SDK для моделирования и визуализации
3. Открыть в текстовом редакторе файл проекта и добавить в конец файла, но перед </Project>

Вот и все. Откройте свой проект. При каждой сборке все * .tt шаблоны будут перерабатываться

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

Существует отличный пакет NuGet, который делает именно это:

PM> Install-Package Clarius.TransformOnBuild

Подробности о пакете можно найти здесь

Я использовал ответ MarkGr и разработал это решение. Сначала создайте пакетный файл с именем RunTemplate.bat в отдельной папке инструментов над основной папкой решения. Пакетный файл просто имеет строку:

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

Этот пакетный файл принимает 2 параметра ... % 1 - это путь к файлу .tt без расширения .tt. % 2 - это путь к любым библиотекам DLL, указанным в шаблоне директивами Assembly .

Далее перейдите в Project Properties проекта, содержащего шаблон T4. Зайдите в Build Events и добавьте следующую командную строку Pre-build event :

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

заменив MyTemplate именем вашего файла .tt (т.е. MyTemplate.tt) без расширения .tt. Это приведет к расширению шаблона для создания MyTemplate.cs перед сборкой проекта. Тогда фактическая сборка скомпилирует MyTemplate.cs

Недавно нашел этот замечательный плагин VS, Chirpy .

Он не только генерирует ваш T4 при сборке, но и позволяет на основе T4 подходить к минимизации JavaScript, CSS и даже позволяет использовать синтаксис LESS для вашего CSS!

Вероятно, самый простой способ - установить расширение Visual Studio под названием AutoT4 .

Он запускает все шаблоны T4 при сборке автоматически.

Предварительная сборка может быть сведена к одной строке:

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

Это преобразует все .ttфайлы в проекте и выводит их в вывод сборки.

Если вы не хотите выводить сборку, вам нужно обойти «интересное поведение» :

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

Конечно, вы можете вытащить это в командный файл, в который вы передаете путь к каталогу проекта, если хотите.

NB Путь может потребовать некоторых настроек. Путь выше - то, где VS 2008 установил это на моей машине; но вы можете обнаружить, что номер версии между TextTemplatingи TextTransform.exeотличается.

Проверьте C: \ Program Files (x86) \ Common Files \ Microsoft Shared \ TextTemplate, где есть преобразование командной строки exe. В качестве альтернативы напишите задачу MSBuild с пользовательским хостом и выполните преобразование самостоятельно.

Расширяя ответы Сета Рено и Джоэл Фана , я придумал это. С этим решением не нужно помнить, что нужно изменять событие перед сборкой каждый раз, когда вы добавляете новый файл .tt в проект.

Процедура внедрения

• Создайте командный файл с именем transform_all.bat (см. Ниже)
• Создайте событие перед сборкой transform_all.bat "$(ProjectDir)" $(ProjectExt)для каждого проекта с .tt, который вы хотите построить

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

НОТЫ

1. При преобразовании текста предполагается, что код в шаблоне T4 соответствует языку вашего типа проекта. Если этот случай не относится к вам, вам придется заменить $(ProjectExt)аргумент расширением файлов, которые вы хотите сгенерировать кодом.

2. .TTфайлы должны находиться в каталоге проекта, иначе они не будут создаваться. Вы можете создавать файлы TT вне каталога проекта, указав в качестве первого аргумента другой путь ( т. Е. Замените "$(ProjectDir)"путь, содержащий файлы TT).

3. Не забудьте также указать правильный путь к transform_all.batпакетному файлу.
   Например, я поместил его в каталог решений, чтобы событие перед сборкой было следующим"$(SolutionDir)transform_all.bat" "$(ProjectDir)" $(ProjectExt)

Если вы используете Visual Studio 2010, вы можете использовать Visual Studio SDK для моделирования и визуализации: http://code.msdn.microsoft.com/vsvmsdk

Он содержит задачи msbuild для выполнения шаблонов T4 во время сборки.

Загляните в блог Олега для более подробного объяснения: http://www.olegsych.com/2010/04/understanding-t4-msbuild-integration

Эй, мой скрипт также может анализировать расширение вывода

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%

Просто создайте transform_all.bat $(SolutionDir)событие перед сборкой, и все файлы * .tt в вашем решении будут автоматически преобразованы.

Dynamo.AutoTT будет делать то, что вам нужно. Вы можете настроить его для просмотра файлов через регулярные выражения или генерировать при сборке. Это также позволяет вам указать, какие шаблоны T4 вы хотите запускать.

Вы можете скачать его здесь: https://github.com/MartinF/Dynamo.AutoTT

Просто создайте его, скопируйте файлы DLL и AddIn в

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

и понеслось.

Если вы хотите запустить его в VS2012, вам необходимо изменить файл Dynamo.AutoTT.AddIn и установить для версии значение 11.0 в файле AddIn;

Благодаря GitHub.com/Mono/T4 на данный момент вы можете сделать это для сборок .NET Core и Visual Studio, добавив это в свой .csprojфайл:

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

Если вы преобразуете свои шаблоны в разные языки программирования, вы должны добавить что-то вроде <Compile Remove="**\*.vb" />и <Compile Include="**\*.vb" />для того, чтобы эти файлы были скомпилированы, даже если у вас еще нет сгенерированных файлов.

Removeи Includeтрюк нужен только для первого поколения, или вы можете сделать XML-короче так:

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

и просто запустите сборку дважды (в первый раз). Если вы уже сгенерировали файлы, зафиксированные в репозитории, проблем с перекомпиляцией в обоих примерах не возникнет.

В Visual Studio вы можете захотеть увидеть что-то вроде этого:

вместо этого:

Так что добавьте что-то подобное в ваш файл проекта:

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

Полный пример здесь: GitHub.com/Konard/T4GenericsExample (включает в себя создание нескольких файлов из одного шаблона).

Вот мое решение - похоже на принятый ответ. У нас была проблема с нашим контролем версий. Целевые файлы .cs доступны только для чтения, а T4 не работает. Вот код, который запускает T4 во временной папке, сравнивает целевые файлы и копирует его только в случае таких же изменений. Это не решает проблему с файлами read.only, но, по крайней мере, это происходит не очень часто:

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

Вы можете попытаться добавить свою команду извлечения в строке (:: Вы можете попробовать ....)

В вашем проекте установите это как предварительное действие:

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

Вам просто нужно добавить эту команду в событие предварительной сборки проекта:

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

Проверка конфигурации = отладка гарантирует, что вы не будете заново генерировать код в режиме выпуска, когда вы, например, делаете сборку на сервере сборки TFS.

В Visual Studio 2013 щелкните правой кнопкой мыши шаблон T4 и установите для свойства transform on build значение true.

Вот как я это сделал. Link . Основываясь на отличном блоге (blogs.clariusconsulting.net/kzu/how-to-transform-t4-templates-on-build-without-install-a-visual-studio-sdk/ не может публиковать более 2 ссылки :() Я придумал этот файл .targets для использования с файлами projs для Visual Studio.

Это полезно, когда вы используете другие dll-ы внутри вашего .tt и хотите, чтобы результат менялся по мере изменения dll-ов.

Как это устроено:

1. Создайте tt, добавьте путь сборки name = "$ (SolutionDir) \ в \ other \ project \ output \ foo.dll и настройте преобразование и результат в соответствии с ожиданиями.

2. Удалить ссылки на сборки из .tt

3. Внутри файла proj используйте этот код для настройки преобразования при сборке:

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

   • Первая часть Находит TextTransform.exe

   • $(IncludeForTransform)будет равен, c:\path\to\dll\foo.dll' -r c:\path\to\dll\bar.dllпотому что это способ добавить ссылки для TextTransform в командной строке

      <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" />это создает список всех файлов tt внутри проекта и подкаталогов

   • <Exec Command="... создает строку для каждого из найденных .tt файлов, которая выглядит "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. Осталось только добавить пути к dll внутри:

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

   Здесь <InProject>False</InProject>скрываются эти элементы из окна просмотра решений

Так что теперь вы сможете генерировать свой код при сборке и при изменении dll-ов.

Вы можете удалить пользовательский инструмент (из свойств внутри Visual Studio), чтобы VS не пытался каждый раз трансформироваться и терпеть неудачу. Потому что мы удалили ссылки на сборки в шаге 2

T4Executer делает это для VS2019. Вы можете указать шаблоны, которые будут игнорироваться при сборке, и есть опция выполнения после сборки.

Вы просто устанавливаете пакет NuGet: Clarius.TransformOnBuild

Затем, каждый раз, когда вы нажимаете Rebuild project (или Solution), ваши .tt- файлы будут запускаться

В Visual Studio 2017 (возможно, и в следующих версиях) вы должны добавить это в событие Pre-build:

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

ps Измените путь к вашему шаблону, если он находится не в корневом каталоге проекта.

Какой-то парень создал пакет nuget для этого.

Примечание: я получаю ошибки компиляции как из TextTemplate.exe, так и из этого пакета (потому что этот пакет вызывает TextTemplate.exe), но не из Visual Studio. Итак, по-видимому, поведение не то же самое; Берегись.

РЕДАКТИРОВАТЬ: Это оказалось моей проблемой.

Вот событие перед сборкой, использующее только Microsoft Tooling и стандартные пути. Это проверено в vs2019 / netcore3.1.

Замените «AppDbContext.tt» на путь к файлу, относящемуся к проекту:

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

У Microsoft также есть руководство, чтобы сделать макросы типа «$ (SolutionDirectory)» доступными в шаблоне, используя T4ParameterValues в файле проекта.