Faça com que o Visual Studio execute um modelo T4 em cada compilação

Como obtenho um modelo T4 para gerar sua saída em cada build? Como é agora, ele só a regenera quando faço uma alteração no modelo.

Eu encontrei outras perguntas semelhantes a esta:

Transformação T4 e ordem de compilação no Visual Studio (sem resposta)

Como obter arquivos t4 para criar no visual studio? (as respostas não são detalhadas o suficiente [embora ainda sejam bastante complicadas] e nem fazem todo o sentido)

Tem que haver uma maneira mais simples de fazer isso!

Eu usei a resposta de JoelFan para chegar a isso. Eu gosto mais porque você não precisa se lembrar de modificar o evento de pré-construção toda vez que adicionar um novo arquivo .tt ao projeto.

• adicione TextTransform.exe ao seu %PATH%
• criou um arquivo em lote chamado transform_all.bat (veja abaixo)
• crie um evento de pré-construção " 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

Eu concordo com o GarethJ - no VS2010, é muito mais fácil regenerar os modelos tt em cada build. O blog de Oleg Sych descreve como fazê-lo. Em resumo:

1. Instale o Visual Studio SDK
2. Instale o SDK de modelagem e visualização do Visual Studio 2010
3. Abra no arquivo de projeto do editor de texto e inclua no final do arquivo, mas antes </Project>

É isso aí. Abra seu projeto. Em cada build, todos os modelos * .tt serão reprocessados

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

Existe um ótimo pacote NuGet que faz exatamente isso:

PM> Install-Package Clarius.TransformOnBuild

Detalhes sobre o pacote podem ser encontrados aqui

Usei a resposta do MarkGr e desenvolvi esta solução. Primeiro, crie um arquivo em lotes chamado RunTemplate.bat em uma pasta de ferramentas separada acima da pasta principal da solução. O arquivo em lotes tem apenas a linha:

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

Este arquivo em lotes usa 2 parâmetros ... % 1 é o caminho para o arquivo .tt sem a extensão .tt. % 2 é o caminho para as DLLs mencionadas pelas diretivas Assembly no modelo.

Em seguida, acesse as Propriedades do projeto que contém o modelo T4. Acesse Build Events e adicione a seguinte linha de comando do evento Pre-build :

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

substituindo MyTemplate pelo nome do arquivo .tt (ou seja, MyTemplate.tt) sem a extensão .tt. Isso resultará na expansão do modelo para produzir MyTemplate.cs antes da criação do projeto. Em seguida, a compilação real compilará o MyTemplate.cs

Recentemente, encontrei este ótimo plug-in do VS, Chirpy .

Ele não apenas gera seu T4 em uma compilação, mas permite uma abordagem baseada em T4 para minificação de javascript, CSS e ainda permite que você use menos sintaxe para seu CSS!

Provavelmente, a maneira mais simples é instalar uma extensão do Visual Studio chamada AutoT4 .

Ele executa todos os modelos T4 na construção automagicamente.

A pré-construção pode ser reduzida para uma única linha:

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

Isso transforma todos os .ttarquivos no projeto e os lista na saída da compilação.

Se você não quiser a saída da compilação, precisará contornar algum "comportamento interessante" :

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

Obviamente, você pode extrair isso para um arquivo em lotes para o qual passa o caminho do diretório do projeto, se desejar.

NB O caminho pode exigir alguns ajustes. O caminho acima é onde o VS 2008 o instalou na minha máquina; mas você pode achar que o número da versão entre TextTemplatinge TextTransform.exeé diferente.

Confira C: \ Arquivos de programas (x86) \ Arquivos comuns \ Microsoft Shared \ TextTemplating. Existe um exe de transformação de linha de comando. Como alternativa, escreva uma tarefa do MSBuild com um host personalizado e faça a transformação por conta própria.

Expandindo em Seth Reno e as respostas de JoelFan , eu vim com isso. Com esta solução, não é necessário lembrar-se de modificar o evento de pré-construção toda vez que você adicionar um novo arquivo .tt ao projeto.

Procedimento de Implementação

• Crie um arquivo em lote chamado transform_all.bat (veja abaixo)
• Crie um evento de pré-construção transform_all.bat "$(ProjectDir)" $(ProjectExt)para cada projeto com um .tt que você deseja criar

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

NOTAS

1. A transformação de texto assume que o código no modelo T4 é o mesmo idioma que o seu tipo de projeto. Se esse caso não se aplicar a você, será necessário substituir o $(ProjectExt)argumento pela extensão dos arquivos que você deseja que o código gere.

2. .TTos arquivos devem estar no diretório do projeto, caso contrário não serão construídos. Você pode construir arquivos TT fora do diretório do projeto, especificando um caminho diferente como o primeiro argumento ( ou seja, substituir"$(ProjectDir)" pelo caminho que contém os arquivos TT).

3. Lembre-se também de definir o caminho correto para o transform_all.batarquivo em lotes.
   Por exemplo, coloquei-o no diretório da solução para que o evento de pré-construção fosse o seguinte"$(SolutionDir)transform_all.bat" "$(ProjectDir)" $(ProjectExt)

Se você estiver usando o Visual Studio 2010, poderá usar o SDK de Modelagem e Visualização do Visual Studio: http://code.msdn.microsoft.com/vsvmsdk

Isso contém tarefas msbuild para executar modelos T4 no momento da construção.

Dê uma olhada no blog de Oleg para obter mais explicações: http://www.olegsych.com/2010/04/understanding-t4-msbuild-integration

Ei, meu script também pode analisar a extensão de saída

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%

Basta criar transform_all.bat $(SolutionDir)um evento de pré-construção, e todos os arquivos * .tt em sua solução serão transformados automaticamente.

O Dynamo.AutoTT fará o que você precisa. Você pode configurá-lo para assistir arquivos por meio de um regex ou gerar na compilação. Ele também permite especificar quais modelos T4 você deseja que ele ative.

Você pode fazer o download aqui : https://github.com/MartinF/Dynamo.AutoTT

Apenas construa, copie os arquivos dll e AddIn para

C: \ Usuários \ Documentos \ Visual Studio 2012 \ Addins \

e você vai embora.

Se você deseja colocá-lo no VS2012, precisará modificar o arquivo Dynamo.AutoTT.AddIn e definir a Versão como 11.0 dentro do arquivo AddIn;

Graças ao GitHub.com/Mono/T4 , no momento você pode fazer isso para compilações do .NET Core e do Visual Studio adicionando isso ao seu .csprojarquivo:

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

Se você transformar seus modelos em diferentes linguagens de programação, adicione algo como <Compile Remove="**\*.vb" />e<Compile Include="**\*.vb" /> para compilar esses arquivos, mesmo que você ainda não tenha gerado arquivos.

Removee Includetruque necessário apenas para a primeira geração, ou você pode tornar o XML mais curto assim:

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

e apenas execute o build duas vezes (pela primeira vez). Se você já gerou arquivos confirmados no repositório, não haverá problemas nas reconstruções com os dois exemplos.

No Visual Studio, você pode querer ver algo assim:

em vez disso:

Portanto, adicione algo assim ao seu arquivo de projeto:

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

Exemplo completo aqui: GitHub.com/Konard/T4GenericsExample (inclui a geração de vários arquivos a partir de um único modelo).

Aqui está a minha solução - semelhante à resposta aceita. Tivemos um problema com nosso controle de origem. Os arquivos .cs de destino são somente leitura e o T4 estava falhando. Aqui está o código, que executa o T4 na pasta temp, compara os arquivos de destino e os copia apenas no caso da mesma alteração. Não corrige o problema com os arquivos read.only, mas pelo menos não ocorre com muita frequência:

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

Você pode tentar adicionar seu comando de check-out em uma linha (:: Você pode tentar ....)

No seu projeto, defina isso como uma ação de pré-construção:

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

Você só precisa adicionar este comando ao evento de pré-construção do projeto:

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

A verificação em configuration = debug garante que você não gere novamente o código no modo de liberação, quando você faz a compilação no servidor de compilação do TFS, por exemplo.

No visual studio 2013, clique com o botão direito do mouse no modelo T4 e defina a propriedade transform on build para true.

Aqui está como eu lidei com isso. Link . Basicamente, construindo sobre um ótimo blog (blogs.clariusconsulting.net/kzu/how-to-transform-t4-templates-on-build-without-installing-a-visual-studio-sdk/ não pode postar mais que 2 links :() Eu criei este arquivo .targets para usar com os arquivos de projeção do visual studio.

É útil quando você está usando outras dll-s dentro do seu .tt e deseja que o resultado seja alterado à medida que as dll-s estão sendo alteradas.

Como funciona:

1. Crie o tt, adicione o nome do assembly = "$ (SolutionDir) path \ to \ other \ project \ output \ foo.dll e configure a transformação e o resultado conforme o esperado

2. Remova as referências de montagem de .tt

3. Dentro do arquivo proj, use este código para configurar a transformação na compilação:

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

   • Primeira parte localiza TextTransform.exe

   • $(IncludeForTransform)será igual a, c:\path\to\dll\foo.dll' -r c:\path\to\dll\bar.dllporque essa é a maneira de adicionar referências para o TextTransform na linha de comando

      <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" />isso cria uma lista de todos os arquivos tt dentro do projeto e subdiretórios

   • <Exec Command="... produz uma linha para cada um dos arquivos .tt encontrados que se parece com "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. A única coisa a fazer é adicionar os caminhos para as dlls dentro de:

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

   Aqui, <InProject>False</InProject>oculta esses itens da exibição da solução

Portanto, agora você deve poder gerar seu código na compilação e na alteração de dll-s.

Você pode remover a ferramenta personalizada (das propriedades dentro do Visual Studio) para que o VS não tente transformar e falhar miseravelmente todas as vezes. Como removemos as referências de montagem na etapa 2

O T4Executer faz isso para o VS2019. Você pode especificar modelos para ignorar na construção, e há uma opção executar após a construção.

Você acabou de instalar o Pacote NuGet : Clarius.TransformOnBuild

Então, toda vez que você clicar em Reconstruir projeto (ou Solução), seus arquivos .tt serão executados

No Visual Studio 2017 (provavelmente também nas próximas versões), você deve adicionar isso no evento Pre-build:

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

ps Altere o caminho para o seu modelo se ele não estiver localizado no diretório raiz do projeto.

Um cara construiu um pacote de pepitas para isso.

Nota: Recebo erros de compilação do TextTemplate.exe e desse pacote (porque esse pacote chama TextTemplate.exe), mas não do Visual Studio. Então, aparentemente, o comportamento não é o mesmo; Atenção.

EDIT: Este acabou sendo o meu problema.

Aqui está um evento de pré-construção usando apenas o Microsoft Tooling e caminhos padrão. Foi testado no vs2019 / netcore3.1.

Substitua "AppDbContext.tt" pelo caminho do arquivo relativo ao projeto:

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

A Microsoft também possui um guia para disponibilizar macros como "$ (SolutionDirectory)" no modelo usando T4ParameterValues no arquivo do projeto.