Transformação App.Config para projetos que não são projetos da Web no Visual Studio?

Para o aplicativo baseado na Web do Visual Studio 2010, temos os recursos de Transformação de configuração, pelos quais podemos manter vários arquivos de configuração para diferentes ambientes. Mas o mesmo recurso não está disponível para arquivos App.Config para Windows Services / WinForms ou Console Application.

Há uma solução alternativa disponível, conforme sugerido aqui: Aplicando a magia XDT ao App.Config .

No entanto, não é simples e requer várias etapas. Existe uma maneira mais fácil de obter o mesmo para arquivos app.config?

Isso funciona agora com o Visual Studio AddIn tratado neste artigo: SlowCheetah - Web.config Sintaxe de transformação agora generalizada para qualquer arquivo de configuração XML .

Você pode clicar com o botão direito do mouse em seu web.config e clicar em "Adicionar transformações de configuração". Ao fazer isso, você obtém um web.debug.config e um web.release.config. Você pode criar um web.whatever.config, se quiser, desde que o nome esteja alinhado com um perfil de configuração. Esses arquivos são apenas as alterações que você deseja fazer, não uma cópia completa do seu web.config.

Você pode pensar que gostaria de usar o XSLT para transformar um web.config, mas enquanto eles se sentem intuitivamente certos, é realmente muito detalhado.

Aqui estão duas transformações, uma usando XSLT e a mesma usando a sintaxe / namespace XML Document Transform. Como em todas as coisas, há várias maneiras no XSLT de fazer isso, mas você entende a ideia geral. XSLT é uma linguagem generalizada de transformação em árvore, enquanto essa implementação é otimizada para um subconjunto específico de cenários comuns. Mas, a parte interessante é que cada transformação XDT é um plug-in .NET, para que você possa criar o seu próprio.

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

Ou a mesma coisa através da transformação de implantação:

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

Tentei várias soluções e aqui está a mais simples que encontrei pessoalmente.
Dan apontou nos comentários que o post original pertence a Oleg Sych - obrigado, Oleg!

Aqui estão as instruções:

1. Adicione um arquivo XML para cada configuração ao projeto.

Normalmente você terá Debuge Releaseconfigurações para nomear seus arquivos App.Debug.confige App.Release.config. No meu projeto, criei uma configuração para cada tipo de ambiente, então você pode experimentar isso.

2. Descarregue o projeto e abra o arquivo .csproj para edição

O Visual Studio permite editar arquivos .csproj diretamente no editor - basta descarregar o projeto primeiro. Em seguida, clique com o botão direito do mouse e selecione Editar <ProjectName> .csproj .

3. Vincule os arquivos App. *. Config ao App.config principal

Localize a seção arquivo de projeto que contém todos App.confige App.*.configreferências. Você notará que as ações de criação estão definidas para None:

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

Primeiro, defina a ação de compilação para todos eles Content.
Em seguida, torne todos os arquivos específicos da configuração dependentes dos principais, App.configpara que o Visual Studio os agrupe da mesma forma que cria arquivos de código e de designer.

Substitua XML acima por um abaixo:

<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. Ative a mágica de transformações (necessária apenas para as versões do Visual Studio anteriores ao VS2017 )

No final do arquivo após

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

e antes da final

</Project>

insira o seguinte 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>

Agora você pode recarregar o projeto, construí-lo e desfrutar de App.configtransformações!

Para sua informação

Certifique-se de que seus App.*.configarquivos tenham a configuração correta como esta:

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

Outra solução que encontrei NÃO é usar as transformações, mas apenas ter um arquivo de configuração separado, por exemplo, app.Release.config. Em seguida, adicione esta linha ao seu arquivo csproj.

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

Isso não apenas gerará o arquivo myprogram.exe.config correto, mas se você estiver usando o Projeto de Instalação e Implantação no Visual Studio para gerar o MSI, forçará o projeto de implantação a usar o arquivo de configuração correto ao compactar.

Na minha experiência, as coisas que preciso tornar específicas do ambiente são: cadeias de conexão, configurações de aplicativos e configurações frequentemente smpt. O sistema de configuração permite especificar essas coisas em arquivos separados. Então você pode usar isso em seu app.config / web.config:

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

O que normalmente faço é colocar essas seções específicas da configuração em arquivos separados, em uma subpasta chamada ConfigFiles (na raiz da solução ou no nível do projeto, depende). Eu defino um arquivo por configuração, por exemplo, smtp.config.Debug e smtp.config.Release.

Em seguida, você pode definir um evento de pré-construção da seguinte maneira:

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

No desenvolvimento da equipe, você pode ajustar isso ainda mais, incluindo% COMPUTERNAME% e / ou% USERNAME% na convenção.

Obviamente, isso implica que os arquivos de destino (x.config) NÃO devem ser colocados no controle de origem (uma vez que são gerados). Você ainda deve adicioná-los ao arquivo do projeto e definir sua propriedade de tipo de saída como 'copy always' ou 'copy if newer'.

Simples, extensível e funciona para todos os tipos de projetos do Visual Studio (console, winforms, wpf, web).

Inspirado por Oleg e outros nesta questão, levei a solução https://stackoverflow.com/a/5109530/2286801 um passo adiante para permitir o seguinte.

• Funciona com ClickOnce
• Trabalha com projetos de Instalação e Implantação no VS 2010
• Funciona com o VS2010, 2013, 2015 (não testou 2012, embora deva funcionar também).
• Funciona com o Team Build. (Você deve instalar o A) Visual Studio ou B) Microsoft.Web.Publishing.targets e Microsoft.Web.Publishing.Tasks.dll

Esta solução funciona executando a transformação app.config antes que o app.config seja referenciado pela primeira vez no processo MSBuild. Ele usa um arquivo de destinos externos para facilitar o gerenciamento em vários projetos.

Instruções:

Etapas semelhantes à outra solução. Eu citei o que permanece o mesmo e o incluí para completude e comparação mais fácil.

0. Adicione um novo arquivo ao seu projeto chamado 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. Adicione um arquivo XML para cada configuração ao projeto.

Normalmente, você terá configurações de Debug e Release, para nomear seus arquivos App.Debug.config e App.Release.config. No meu projeto, criei uma configuração para cada tipo de ambiente, para que você possa experimentar isso.

2. Descarregue o projeto e abra o arquivo .csproj para edição

O Visual Studio permite editar .csproj diretamente no editor - você só precisa descarregar o projeto primeiro. Em seguida, clique com o botão direito do mouse e selecione Editar .csproj.

3. Vincule os arquivos App. *. Config ao App.config principal

Localize a seção do arquivo do projeto que contém todas as referências App.config e App. *. Config e substitua da seguinte maneira. Você notará que usamos Nenhum em vez de Conteúdo.

<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. Ativar transformações mágicas

No final do arquivo após

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

e antes da final

</Project>

insira o seguinte XML:

<Import Project="AppConfigTransformation.targets" />

Feito!

Você pode usar um arquivo de configuração separado por configuração, por exemplo, app.Debug.config, app.Release.config e, em seguida, usar a variável de configuração no seu arquivo de projeto:

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

Isso criará o arquivo ProjectName.exe.config correto, dependendo da configuração em que você está construindo.

Eu escrevi uma boa extensão para automatizar a transformação app.config como a que foi criada na Transformação de Configuração de Projetos de Aplicativos da Web

A maior vantagem dessa extensão é que você não precisa instalá-la em todas as máquinas de compilação

Instale a "Ferramenta de transformação de configuração" no Visual Studio no Marketplace e reinicie o VS. Você também poderá ver a transformação de visualização do menu para app.config.

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

Então, acabei adotando uma abordagem um pouco diferente. Segui as etapas de Dan na etapa 3, mas adicionei outro arquivo: App.Base.Config. Este arquivo contém as definições de configuração que você deseja em todos os App.Config gerados. Então eu uso o BeforeBuild (com a adição de Yuri no TransformXml) para transformar a configuração atual com a configuração Base no App.config. O processo de compilação usa o App.config transformado normalmente. No entanto, um aborrecimento é que você deseja excluir o App.config em constante mudança do controle de origem posteriormente, mas os outros arquivos de configuração agora dependem dele.

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

Apenas um pequeno aprimoramento da solução que parece estar publicada em todos os lugares agora:

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

• isto é, a menos que você planeje ficar com sua versão atual do VS para sempre

Criei outra alternativa à publicada por Vishal Joshi, na qual o requisito de alterar a ação de compilação para Conteúdo foi removido e também implementei o suporte básico para a implantação do ClickOnce. Eu digo básico, porque não o testei completamente, mas deve funcionar no cenário típico de implantação do ClickOnce.

A solução consiste em um único projeto MSBuild que uma vez importado para um projeto de aplicativo do Windows existente (* .csproj) estende o processo de compilação para contemplar a transformação app.config.

Você pode ler uma explicação mais detalhada no Visual Studio App.config XML Transformation e o arquivo de projeto MSBuild pode ser baixado do GitHub .

Se você usa um TFS online (versão em nuvem) e deseja transformar o App.Config em um projeto, pode fazer o seguinte sem instalar nenhuma ferramenta extra. No VS => Descarregar o projeto => Editar arquivo do projeto => Vá para a parte inferior do arquivo e adicione o seguinte:

<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 e Destination funciona para uso local e servidor TFS online (Cloud).

A solução proposta não funcionará quando uma biblioteca de classes com o arquivo de configuração for referenciada em outro projeto (no meu caso, era a biblioteca de projetos do trabalhador do Azure). Ele não copiará o arquivo transformado correto da objpasta para a bin\##configuration-name##pasta. Para fazê-lo funcionar com alterações mínimas, você precisa alterar o AfterCompiledestino para BeforeCompile:

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