App.Config Transformation para proyectos que no son proyectos web en Visual Studio?

Para la aplicación basada en Web de Visual Studio 2010, tenemos características de Transformación de configuración mediante las cuales podemos mantener múltiples archivos de configuración para diferentes entornos. Pero la misma característica no está disponible para los archivos App.Config para Windows Services / WinForms o Console Application.

Hay una solución disponible como se sugiere aquí: aplicar magia XDT a App.Config .

Sin embargo, no es sencillo y requiere una serie de pasos. ¿Hay una manera más fácil de lograr lo mismo para los archivos app.config?

Esto funciona ahora con el complemento de Visual Studio tratado en este artículo: SlowCheetah - Web.config Transformation Syntax ahora generalizada para cualquier archivo de configuración XML .

Puede hacer clic con el botón derecho en su web.config y hacer clic en "Agregar transformaciones de configuración". Cuando haga esto, obtendrá un web.debug.config y un web.release.config. Puede hacer un web.whatever.config si lo desea, siempre que el nombre se alinee con un perfil de configuración. Estos archivos son solo los cambios que desea realizar, no una copia completa de su web.config.

Puede pensar que desea utilizar XSLT para transformar un web.config, pero si bien se sienten intuitivamente correctos, en realidad es muy detallado.

Aquí hay dos transformaciones, una usando XSLT y la misma usando la sintaxis / espacio de nombres de Transformación de documentos XML. Al igual que con todas las cosas, en XSLT hay varias formas de hacer esto, pero se entiende la idea general. XSLT es un lenguaje de transformación de árbol generalizado, mientras que este despliegue está optimizado para un subconjunto específico de escenarios comunes. Pero, lo bueno es que cada transformación XDT es un complemento .NET, por lo que puede hacer el suyo.

<?xml version="1.0" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="@*|node()">
  <xsl:copy>           
    <xsl:apply-templates select="@*|node()"/>
  </xsl:copy>
</xsl:template>
<xsl:template match="/configuration/appSettings">
  <xsl:copy>
    <xsl:apply-templates select="node()|@*"/>
    <xsl:element name="add">
      <xsl:attribute name="key">NewSetting</xsl:attribute>
      <xsl:attribute name="value">New Setting Value</xsl:attribute>
    </xsl:element>
  </xsl:copy>
</xsl:template>
</xsl:stylesheet>

O lo mismo a través de la transformación de implementación:

<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
   <appSettings>
      <add name="NewSetting" value="New Setting Value" xdt:Transform="Insert"/>
   </appSettings>
</configuration>

Probé varias soluciones y aquí está la más simple que encontré personalmente.
Dan señaló en los comentarios que la publicación original pertenece a Oleg Sych . ¡ Gracias, Oleg!

Aquí están las instrucciones:

1. Agregue un archivo XML para cada configuración al proyecto.

Por lo general, tendrá Debugy Releaseconfiguraciones para nombrar sus archivos App.Debug.configy App.Release.config. En mi proyecto, creé una configuración para cada tipo de entorno, por lo que es posible que desee experimentar con eso.

2. Descargue el proyecto y abra el archivo .csproj para editarlo

Visual Studio le permite editar archivos .csproj directamente en el editor; solo necesita descargar el proyecto primero. Luego haga clic derecho sobre él y seleccione Editar <ProjectName> .csproj .

3. Enlace los archivos de la aplicación. * .Config a la aplicación principal.config

Encuentre la sección del archivo del proyecto que contiene todos App.config y App.*.configreferencias. Notarás que sus acciones de construcción están configuradas para None:

<None Include="App.config" />
<None Include="App.Debug.config" />
<None Include="App.Release.config" />

Primero, establezca la acción de construcción para todos ellos Content.
A continuación, haga todo los archivos específicos de la configuración dependan del principal App.configpara que Visual Studio los agrupe como lo hace con los archivos de diseñador y de código subyacente.

Reemplace XML arriba con el siguiente:

<Content Include="App.config" />
<Content Include="App.Debug.config" >
  <DependentUpon>App.config</DependentUpon>
</Content>
<Content Include="App.Release.config" >
  <DependentUpon>App.config</DependentUpon>
</Content>

4. Activa transformaciones mágicas (solo es necesario para las versiones de Visual Studio anteriores a VS2017 )

Al final del archivo después

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

y antes de la final

</Project>

inserte el siguiente XML:

  <UsingTask TaskName="TransformXml" AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.Tasks.dll" />
  <Target Name="CoreCompile" Condition="exists('app.$(Configuration).config')">
    <!-- Generate transformed app config in the intermediate directory -->
    <TransformXml Source="app.config" Destination="$(IntermediateOutputPath)$(TargetFileName).config" Transform="app.$(Configuration).config" />
    <!-- Force build process to use the transformed configuration file from now on. -->
    <ItemGroup>
      <AppConfigWithTargetPath Remove="app.config" />
      <AppConfigWithTargetPath Include="$(IntermediateOutputPath)$(TargetFileName).config">
        <TargetPath>$(TargetFileName).config</TargetPath>
      </AppConfigWithTargetPath>
    </ItemGroup>
  </Target>

¡Ahora puedes recargar el proyecto, construirlo y disfrutar de las App.configtransformaciones!

FYI

Asegúrese de que sus App.*.configarchivos tengan la configuración correcta como esta:

<?xml version="1.0" encoding="utf-8"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
     <!--magic transformations here-->
</configuration>

Otra solución que he encontrado es NO usar las transformaciones, sino solo tener un archivo de configuración separado, por ejemplo, app.Release.config. Luego agregue esta línea a su archivo csproj.

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <AppConfig>App.Release.config</AppConfig>
  </PropertyGroup>

Esto no solo generará el archivo myprogram.exe.config correcto, sino que si está utilizando el Proyecto de instalación y distribución en Visual Studio para generar MSI, obligará al proyecto de implementación a usar el archivo de configuración correcto al empaquetar.

En mi experiencia, las cosas que necesito hacer específicas para el entorno son cosas como cadenas de conexión, configuraciones de aplicaciones y, a menudo, configuraciones smpt. El sistema de configuración permite especificar estas cosas en archivos separados. Entonces puede usar esto en su app.config / web.config:

 <appSettings configSource="appsettings.config" />
 <connectionStrings configSource="connection.config" />
 <system.net>
    <mailSettings>
       <smtp configSource="smtp.config"/>
    </mailSettings>
 </system.net>

Lo que normalmente hago es colocar estas secciones específicas de la configuración en archivos separados, en una subcarpeta llamada ConfigFiles (ya sea en la raíz de la solución o en el nivel del proyecto, depende). Defino un archivo por configuración, por ejemplo smtp.config.Debug y smtp.config.Release.

Luego puede definir un evento de precompilación de esta manera:

copy $(ProjectDir)ConfigFiles\smtp.config.$(ConfigurationName) $(TargetDir)smtp.config

En el desarrollo de equipos, puede modificar esto aún más incluyendo% COMPUTERNAME% y / o% USERNAME% en la convención.

Por supuesto, esto implica que los archivos de destino (x.config) NO deben colocarse en el control de origen (ya que se generan). Sin embargo, aún debe agregarlos al archivo del proyecto y establecer su propiedad de tipo de salida para 'copiar siempre' o 'copiar si es más reciente'.

Simple, extensible, y funciona para todo tipo de proyectos de Visual Studio (consola, winforms, wpf, web).

Inspirado por Oleg y otros en esta pregunta, tomé la solución https://stackoverflow.com/a/5109530/2286801 un paso más para habilitar lo siguiente.

• Funciona con ClickOnce
• Funciona con proyectos de instalación e implementación en VS 2010
• Funciona con VS2010, 2013, 2015 (no probó 2012, aunque debería funcionar también).
• Trabaja con Team Build. (Debe instalar A) Visual Studio o B) Microsoft.Web.Publishing.targets y Microsoft.Web.Publishing.Tasks.dll)

Esta solución funciona realizando la transformación app.config antes de que se haga referencia a app.config por primera vez en el proceso de MSBuild. Utiliza un archivo de objetivos externos para facilitar la gestión en múltiples proyectos.

Instrucciones:

Pasos similares a la otra solución. He citado lo que sigue siendo igual y lo he incluido para completar y comparar más fácilmente.

0. Agregue un nuevo archivo a su proyecto llamado AppConfigTransformation.targets

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!-- Transform the app config per project configuration.-->
  <PropertyGroup>
    <!-- This ensures compatibility across multiple versions of Visual Studio when using a solution file.
         However, when using MSBuild directly you may need to override this property to 11.0 or 12.0 
         accordingly as part of the MSBuild script, ie /p:VisualStudioVersion=11.0;
         See http://blogs.msdn.com/b/webdev/archive/2012/08/22/visual-studio-project-compatability-and-visualstudioversion.aspx -->
    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
  </PropertyGroup>

  <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.targets" />

  <Target Name="SetTransformAppConfigDestination" BeforeTargets="PrepareForBuild" 
          Condition="exists('app.$(Configuration).config')">
    <PropertyGroup>
      <!-- Force build process to use the transformed configuration file from now on. -->
      <AppConfig>$(IntermediateOutputPath)$(TargetFileName).config</AppConfig>
    </PropertyGroup>
    <Message Text="AppConfig transformation destination: = $(AppConfig)" />
  </Target>

  <!-- Transform the app.config after the prepare for build completes. -->
  <Target Name="TransformAppConfig" AfterTargets="PrepareForBuild" Condition="exists('app.$(Configuration).config')">
    <!-- Generate transformed app config in the intermediate directory -->
    <TransformXml Source="app.config" Destination="$(AppConfig)" Transform="app.$(Configuration).config" />
  </Target>

</Project>

1. Agregue un archivo XML para cada configuración al proyecto.

Por lo general, tendrá configuraciones de depuración y lanzamiento, por lo tanto, nombre sus archivos App.Debug.config y App.Release.config. En mi proyecto, creé una configuración para cada tipo de entorno, por lo que es posible que desee experimentar con eso.

2. Descargue el proyecto y abra el archivo .csproj para editarlo

Visual Studio le permite editar .csproj directamente en el editor, solo necesita descargar el proyecto primero. Luego haga clic derecho sobre él y seleccione Editar .csproj.

3. Enlace los archivos de la aplicación. * .Config a la aplicación principal.config

Busque la sección del archivo del proyecto que contiene todas las referencias de App.config y App. *. Config y reemplace de la siguiente manera. Notarás que usamos None en lugar de Content.

<ItemGroup>
  <None Include="app.config"/>
  <None Include="app.Production.config">
    <DependentUpon>app.config</DependentUpon>
  </None>
  <None Include="app.QA.config">
    <DependentUpon>app.config</DependentUpon>
  </None>
  <None Include="app.Development.config">
    <DependentUpon>app.config</DependentUpon>
  </None>
</ItemGroup>

4. Activa transformaciones mágicas

Al final del archivo después

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

y antes de la final

</Project>

inserte el siguiente XML:

<Import Project="AppConfigTransformation.targets" />

¡Hecho!

Puede usar un archivo de configuración separado por configuración, por ejemplo, app.Debug.config, app.Release.config y luego usar la variable de configuración en su archivo de proyecto:

<PropertyGroup>
    <AppConfig>App.$(Configuration).config</AppConfig>
</PropertyGroup>

Esto creará el archivo ProjectName.exe.config correcto según la configuración que esté creando.

Escribí una buena extensión para automatizar la transformación de app.config como la integrada en Transformación de configuración de proyecto de aplicación web

La mayor ventaja de esta extensión es que no necesita instalarla en todas las máquinas de compilación

Instale la "Herramienta de transformación de configuración" en Visual Studio desde Marketplace y reinicie VS. También podrá ver la transformación de vista previa del menú para app.config.

https://marketplace.visualstudio.com/items?itemName=GolanAvraham.ConfigurationTransform

Así que terminé adoptando un enfoque ligeramente diferente. Seguí los pasos de Dan hasta el paso 3, pero agregué otro archivo: App.Base.Config. Este archivo contiene los ajustes de configuración que desea en cada App.Config generado. Luego uso BeforeBuild (con la adición de Yuri a TransformXml) para transformar la configuración actual con la configuración Base en App.config. El proceso de compilación luego usa el App.config transformado de manera normal. Sin embargo, una molestia es que desea excluir el siempre cambiante App.config del control de origen después, pero los otros archivos de configuración ahora dependen de él.

  <UsingTask TaskName="TransformXml" AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.Tasks.dll" />
  <Target Name="BeforeBuild" Condition="exists('app.$(Configuration).config')">
    <TransformXml Source="App.Base.config" Transform="App.$(Configuration).config" Destination="App.config" />
  </Target>

Solo una pequeña mejora a la solución que parece estar publicada en todas partes ahora:

<UsingTask TaskName="TransformXml" AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.Tasks.dll" />

• es decir, a menos que esté planeando quedarse con su versión VS actual para siempre

He creado otra alternativa a la publicada por Vishal Joshi donde el requisito de cambiar la acción de compilación a Contenido se elimina y también implementé el soporte básico para la implementación de ClickOnce. Digo básico, porque no lo probé a fondo, pero debería funcionar en el escenario típico de implementación de ClickOnce.

La solución consiste en un único proyecto de MSBuild que una vez importado a un proyecto de aplicación de Windows existente (* .csproj) extiende el proceso de compilación para contemplar la transformación app.config.

Puede leer una explicación más detallada en Visual Studio App.config XML Transformation y el archivo del proyecto MSBuild se puede descargar desde GitHub .

Si utiliza un TFS en línea (versión en la nube) y desea transformar la App.Config en un proyecto, puede hacer lo siguiente sin instalar ninguna herramienta adicional. Desde VS => Descargue el proyecto => Editar archivo de proyecto => Vaya al final del archivo y agregue lo siguiente:

<UsingTask TaskName="TransformXml" AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.Tasks.dll" />
<Target Name="AfterBuild" Condition="Exists('App.$(Configuration).config')">
<TransformXml Source="App.config" Transform="App.$(Configuration).config" Destination="$(OutDir)\$(AssemblyName).dll.config" />

AssemblyFile and Destination funciona para uso local y servidor TFS en línea (Cloud).

La solución propuesta no funcionará cuando se haga referencia a una biblioteca de clases con un archivo de configuración de otro proyecto (en mi caso, fue la biblioteca de proyectos de Azure Worker). No copiará el archivo transformado correcto deobj carpeta a otra bin\##configuration-name##. Para que funcione con cambios mínimos, debe cambiar el AfterCompileobjetivo a BeforeCompile:

<Target Name="BeforeCompile" Condition="exists('app.$(Configuration).config')">