visual-studio - para - visual studio code tutorial español pdf

Obtenga Visual Studio para ejecutar una Plantilla T4 en cada compilación

Question

¿Cómo obtengo una plantilla T4 para generar su resultado en cada compilación? Tal como está ahora, solo se regenera cuando realizo un cambio en la plantilla.

He encontrado otras preguntas similares a esto:

Transformación T4 y orden de compilación en Visual Studio (sin respuesta)

¿Cómo conseguir archivos t4 para construir en Visual Studio? (las respuestas no son lo suficientemente detalladas [mientras siguen siendo bastante complicadas] y ni siquiera tienen sentido)

¡Tiene que haber una manera más simple de hacer esto!

Answer 1

Ampliando JoelFan''s respuestas de Seth Reno y JoelFan''s , se me ocurrió esto. Con esta solución, no necesita recordar modificar el evento de preconstrucción cada vez que agrega un nuevo archivo .tt al proyecto.

Procedimiento de implementación

• Cree un archivo de proceso por lotes denominado transform_all.bat (consulte a continuación)
• Cree un evento de precompilación transform_all.bat "$(ProjectDir)" $(ProjectExt) para cada proyecto con un .tt que desee construir

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. La transformación de texto asume que el código en la plantilla T4 es el mismo que el tipo de proyecto. Si este caso no se aplica a usted, entonces deberá reemplazar el argumento $(ProjectExt) con la extensión de los archivos que desea que genere el código.

2. .TT archivos .TT deben estar en el directorio del proyecto, de lo contrario no se compilarán. Puede construir archivos TT fuera del directorio del proyecto especificando una ruta diferente como primer argumento ( es decir, reemplace "$(ProjectDir)" con la ruta que contiene los archivos TT).

3. Recuerde también establecer la ruta correcta al archivo por lotes transform_all.bat .
   Por ejemplo, lo puse en mi directorio de soluciones para que el evento de preconstrucción fuera el siguiente "$(SolutionDir)transform_all.bat" "$(ProjectDir)" $(ProjectExt)

Answer 2

Aquí está mi solución, similar a la respuesta aceptada. Tuvimos un problema con nuestro control de fuente. Los archivos .cs de destino son de solo lectura y la T4 estaba fallando. Aquí está el código, que ejecuta T4 en la carpeta temp, compara los archivos de destino y lo copia solo en caso de un cambio similar. No soluciona el problema con los archivos read.only, pero al menos no ocurre muy a menudo:

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

Puede intentar agregar su comando de salida en una línea (:: Puede intentar ...)

En su proyecto, establezca esto como una acción previa a la compilación:

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

Answer 3

Así es como lo vi. Link . Básicamente construyendo sobre un gran blog (blogs.clariusconsulting.net/kzu/how-to-transform-t4-templates-on-build-without-installing-a-visual-studio-sdk/ no puede publicar más de 2 links :() Se me ocurrió este archivo .targets para usar con los archivos visuales de Visual Studio.

Es útil cuando está usando otros dll-s dentro de su .tt y desea que el resultado cambie a medida que los dll-s cambian.

Cómo funciona:

1. Cree el tt, agregue el nombre del ensamblado = "$ (SolutionDir) path / to / other / project / output / foo.dll y configure la transformación y el resultado para que sean los esperados.

2. Elimine las referencias de ensamblaje de .tt

3. Dentro del archivo proj use este código para configurar la transformación en la compilación:

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

   • La primera parte localiza TextTransform.exe

   • $(IncludeForTransform) será igual a c:/path/to/dll/foo.dll'' -rc:/path/to/dll/bar.dll porque esa es la forma de agregar referencias para TextTransform en la línea 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" /> esto crea una lista de todos los archivos tt dentro del proyecto y subdirectorios

   • <Exec Command="... produce una línea para cada uno de los archivos .tt encontrados que se parece a "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. Lo único que queda por hacer es agregar los caminos a los 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>

   Aquí <InProject>False</InProject> oculta estos elementos de la Vista de solución

Entonces ahora debería poder generar su código en compilación y en el cambio de dll-s.

Puede eliminar la herramienta personalizada (de las propiedades dentro de Visual Studio) para que el VS no intente transformarse y falle miserablemente cada vez. Porque eliminamos las referencias de ensamblado en el paso 2

Answer 4

Dynamo.AutoTT hará lo que necesites. Puede configurarlo para ver archivos a través de una expresión regular o generar en la compilación. También le permite especificar qué plantillas T4 desea que active.

Puede descargarlo desde aquí: https://github.com/MartinF/Dynamo.AutoTT

Simplemente compila, copia los archivos dll y AddIn en

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

y lejos tu vas.

Si desea ponerlo en funcionamiento en VS2012, deberá modificar el archivo Dynamo.AutoTT.AddIn y establecer la Versión a 11.0 dentro del archivo AddIn;

Answer 5

Echa un vistazo a C: / Archivos de programa (x86) / Archivos comunes / Microsoft Shared / TextTemplating hay un exe de transformación de línea de comandos allí. Alternativamente, escriba una tarea de MSBuild con un host personalizado y haga la transformación usted mismo.

Answer 6

En Visual Studio 2013, haga clic con el botón derecho en la plantilla T4 y establezca la transformación en la propiedad de construcción en verdadero.

Answer 7

Estoy de acuerdo con GarethJ: en VS2010 es mucho más fácil regenerar las plantillas tt en cada compilación. El blog de Oleg Sych describe cómo hacerlo. En breve:

1. Instalar Visual Studio SDK
2. Instalar el SDK de modelado y visualización de Visual Studio 2010
3. Abrir en el archivo de proyecto del editor de texto y agregarlo al final del archivo, pero antes de </Project>

Eso es. Abra su proyecto En cada construcción, todas las plantillas * .tt serán reprocesadas

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

Answer 8

Hay un gran paquete NuGet que hace exactamente esto:

PM> Install-Package Clarius.TransformOnBuild

Los detalles sobre el paquete se pueden encontrar aquí

Answer 9

La preconstrucción se puede reducir a una sola línea:

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

Esto transforma todos los archivos .tt en el proyecto y los lista para el resultado de compilación.

Si no quieres el resultado de compilación, entonces tienes que evitar algún "comportamiento interesante" :

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

Por supuesto, puede extraer esto en un archivo por lotes al que pase la ruta del directorio del proyecto si lo desea.

NB : la ruta puede requerir algunos ajustes. El camino anterior es donde VS 2008 lo instaló en mi máquina; pero puede encontrar que el número de versión entre TextTemplating y TextTransform.exe es diferente.

Answer 10

Otro buen artículo sobre esto: Generación de código en un proceso de compilación

Enlace de descarga 2012 de modelado y visualización de SDK:

https://www.microsoft.com/en-us/download/details.aspx?id=30680

Answer 11

Oye, mi script también puede analizar la extensión de salida

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%

Solo crea el evento de transform_all.bat $(SolutionDir) previa transform_all.bat $(SolutionDir) , y todos los archivos * .tt de tu solución se transformarán automáticamente.

Answer 12

Por favor, vea la respuesta de mhutch https://.com/a/1395377/9587

En mi humilde opinión, este es el mejor servidor de compilación y la opción amigable con el entorno de desarrollo.

Answer 13

Probablemente la forma más simple es instalar una extensión de Visual Studio llamada AutoT4 .

Ejecuta todas las plantillas T4 en compilación automágicamente.

Answer 14

Recientemente encontré este excelente plugin de VS, Chirpy .

No solo genera tu T4 en una compilación, sino que permite un enfoque basado en T4 para la minimización de javascript, CSS e incluso te permite usar la sintaxis LESS para tu CSS.

Answer 15

Si está usando Visual Studio 2010, puede usar Visual Studio Modeling and Visualization SDK: http://code.msdn.microsoft.com/vsvmsdk

Esto contiene tareas msbuild para ejecutar plantillas T4 en tiempo de compilación.

Eche un vistazo al blog de Oleg para obtener más información: http://www.olegsych.com/2010/04/understanding-t4-msbuild-integration

Answer 16

Solo necesita agregar este comando al evento de preconstrucción del proyecto:

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

La comprobación de configuración = depuración, asegura que no se regenera el código en el modo de lanzamiento, cuando se hace la compilación en el servidor de compilación TFS, por ejemplo.

Answer 17

Usé la respuesta de JoelFan para llegar con esto. Me gusta más porque no tiene que acordarse de modificar el evento de precompilación cada vez que agrega un nuevo archivo .tt al proyecto.

• agregue TextTransform.exe a su %PATH%
• creó un archivo por lotes llamado transform_all.bat (ver a continuación)
• crea un evento de preconstrucción " 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

Answer 18

Utilicé la respuesta de MarkGr y desarrollé esta solución. Primero, cree un archivo por lotes llamado RunTemplate.bat en una carpeta de herramientas separada encima de la carpeta principal de la solución. El archivo por lotes solo tiene la línea:

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

Este archivo por lotes toma 2 parámetros ... % 1 es la ruta al archivo .tt sin la extensión .tt. % 2 es la ruta a las DLL a las que hacen referencia las directivas de la Asamblea en la plantilla.

A continuación, vaya a las Propiedades del proyecto del proyecto que contiene la plantilla T4. Vaya a Build Events y agregue la siguiente línea de comando de evento de precompilación :

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

reemplazando MyTemplate con nombre de archivo de su archivo .tt (es decir, MyTemplate.tt) sin la extensión .tt. Esto tendrá el resultado de expandir la plantilla para producir MyTemplate.cs antes de construir el proyecto. Entonces la compilación real compilará MyTemplate.cs

Answer 19

Algún tipo construyó un paquete nuget para esto.

Nota al margen: obtengo errores de compilación tanto de TextTemplate.exe como de ese paquete (porque ese paquete llama a TextTemplate.exe) pero no de Visual Studio. Entonces, aparentemente, el comportamiento no es el mismo; aviso.

EDITAR: This terminó siendo mi problema.