Trasformazione App.Config per progetti che non sono progetti Web in Visual Studio?

Per l'applicazione basata su Web di Visual Studio 2010 sono disponibili funzionalità di trasformazione della configurazione con cui è possibile gestire più file di configurazione per ambienti diversi. Ma la stessa funzione non è disponibile per i file App.Config per Windows Services / WinForms o Applicazione console.

È disponibile una soluzione alternativa come suggerito qui: Applicazione della magia XDT su App.Config .

Tuttavia non è semplice e richiede una serie di passaggi. Esiste un modo più semplice per ottenere lo stesso per i file app.config?

Funziona ora con il componente aggiuntivo di Visual Studio trattato in questo articolo: SlowCheetah - Sintassi di trasformazione Web.config ora generalizzata per qualsiasi file di configurazione XML .

È possibile fare clic con il tasto destro del mouse su web.config e fare clic su "Aggiungi trasformazioni di configurazione". Quando lo fai, otterrai un web.debug.config e un web.release.config. Se lo desideri, puoi creare un web.whatever.config, purché il nome sia allineato con un profilo di configurazione. Questi file sono solo le modifiche che vuoi apportare, non una copia completa di web.config.

Potresti pensare di voler usare XSLT per trasformare un web.config, ma mentre si sentono intuitivamente bene, in realtà è molto dettagliato.

Ecco due trasformazioni, una che utilizza XSLT e la stessa che utilizza la sintassi / lo spazio dei nomi di XML Document Transform. Come per tutte le cose, in XSLT ci sono molti modi per farlo, ma ottieni l'idea generale. XSLT è un linguaggio di trasformazione dell'albero generalizzato, mentre questo linguaggio di distribuzione è ottimizzato per un sottoinsieme specifico di scenari comuni. Ma la parte interessante è che ogni trasformazione XDT è un plugin .NET, quindi puoi crearne uno tuo.

<?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 la stessa cosa tramite la trasformazione di distribuzione:

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

Ho provato diverse soluzioni ed ecco la più semplice che ho trovato personalmente.
Dan ha sottolineato nei commenti che il post originale appartiene a Oleg Sych - grazie, Oleg!

Ecco le istruzioni:

1. Aggiungere un file XML per ogni configurazione al progetto.

In genere avrai Debuge Releaseconfigurazioni quindi dai un nome ai tuoi file App.Debug.confige App.Release.config. Nel mio progetto, ho creato una configurazione per ogni tipo di ambiente, quindi potresti voler sperimentare.

2. Scaricare il progetto e aprire il file .csproj per la modifica

Visual Studio ti consente di modificare i file .csproj direttamente nell'editor: devi solo scaricare prima il progetto. Quindi fare clic con il tasto destro su di esso e selezionare Modifica <nome progetto> .csproj .

3. Associa i file App. *. Config a App.config principale

Trova la sezione del file di progetto che contiene tutto App.confige App.*.configriferimenti. Noterai che le loro azioni di costruzione sono impostate su None:

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

Innanzitutto, imposta l'azione di compilazione per tutti Content.
Quindi, fai in modo che tutti i file specifici della configurazione dipendano dal principale in App.configmodo che Visual Studio li raggruppi come fa con i file designer e code-behind.

Sostituisci XML sopra con quello sotto:

<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. Attiva trasformazioni magiche (necessario solo per le versioni di Visual Studio precedenti a VS2017 )

Alla fine del file dopo

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

e prima della finale

</Project>

inserisci il seguente 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>

Ora puoi ricaricare il progetto, costruirlo e goderti le App.configtrasformazioni!

FYI

Assicurati che i tuoi App.*.configfile abbiano la giusta configurazione in questo modo:

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

Un'altra soluzione che ho trovato NON è quella di utilizzare le trasformazioni ma di avere solo un file di configurazione separato, ad esempio app.Release.config. Quindi aggiungi questa linea al tuo file csproj.

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

Ciò non solo genererà il file myprogram.exe.config corretto, ma se si utilizza il progetto di installazione e distribuzione in Visual Studio per generare MSI, forzerà il progetto di distribuzione a utilizzare il file di configurazione corretto durante il packaging.

Nella mia esperienza, le cose che devo rendere specifiche per l'ambiente sono cose come stringhe di connessione, impostazioni delle app e impostazioni spesso smpt. Il sistema di configurazione consente di specificare queste cose in file separati. Quindi puoi usarlo nel tuo app.config / web.config:

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

Quello che faccio di solito è mettere queste sezioni specifiche della configurazione in file separati, in una sottocartella chiamata ConfigFiles (dipende dalla radice della soluzione oa livello di progetto). Definisco un file per configurazione, ad esempio smtp.config.Debug e smtp.config.Release.

Quindi puoi definire un evento pre-build in questo modo:

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

Nello sviluppo del team, è possibile modificarlo ulteriormente includendo% COMPUTERNAME% e / o% USERNAME% nella convenzione.

Naturalmente, ciò implica che i file di destinazione (x.config) NON devono essere messi nel controllo del codice sorgente (poiché sono generati). Dovresti comunque aggiungerli al file di progetto e impostare la loro proprietà del tipo di output su 'copia sempre' o 'copia se più recente'.

Semplice, estensibile e funziona per tutti i tipi di progetti Visual Studio (console, winforms, wpf, web).

Ispirato da Oleg e altri in questa domanda, ho preso la soluzione https://stackoverflow.com/a/5109530/2286801 un ulteriore passo avanti per consentire quanto segue.

• Funziona con ClickOnce
• Funziona con progetti di installazione e distribuzione in VS 2010
• Funziona con VS2010, 2013, 2015 (non ha testato il 2012 anche se dovrebbe funzionare anche).
• Funziona con Team Build. (È necessario installare A) Visual Studio o B) Microsoft.Web.Publishing.targets e Microsoft.Web.Publishing.Tasks.dll)

Questa soluzione funziona eseguendo la trasformazione app.config prima di fare riferimento per la prima volta a app.config nel processo MSBuild. Utilizza un file target esterno per una gestione più semplice su più progetti.

Istruzioni:

Passaggi simili all'altra soluzione. Ho citato ciò che rimane lo stesso e l'ho incluso per completezza e confronto più facile.

0. Aggiungi un nuovo file al tuo progetto chiamato 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. Aggiungere un file XML per ogni configurazione al progetto.

In genere, avrai le configurazioni di debug e rilascio, quindi dai un nome ai tuoi file App.Debug.config e App.Release.config. Nel mio progetto, ho creato una configurazione per ogni tipo di ambiente, quindi potresti voler sperimentare.

2. Scaricare il progetto e aprire il file .csproj per la modifica

Visual Studio ti consente di modificare .csproj direttamente nell'editor: devi solo scaricare prima il progetto. Quindi fai clic destro su di esso e seleziona Modifica .csproj.

3. Associa i file App. *. Config a App.config principale

Trova la sezione del file di progetto che contiene tutti i riferimenti App.config e App. *. Config e sostituisci come segue. Noterai che utilizziamo Nessuno invece di Contenuto.

<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. Attiva le trasformazioni magiche

Alla fine del file dopo

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

e prima della finale

</Project>

inserisci il seguente XML:

<Import Project="AppConfigTransformation.targets" />

Fatto!

È possibile utilizzare un file di configurazione separato per configurazione, ad esempio app.Debug.config, app.Release.config e quindi utilizzare la variabile di configurazione nel file di progetto:

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

Ciò creerà quindi il file ProjectName.exe.config corretto in base alla configurazione in cui si sta creando.

Ho scritto una piacevole estensione per automatizzare la trasformazione app.config come quella integrata nella trasformazione della configurazione del progetto di applicazione Web

Il più grande vantaggio di questa estensione è che non è necessario installarlo su tutte le macchine di compilazione

Installa "Configuration Transform Tool" in Visual Studio dal Marketplace e riavvia VS. Sarai in grado di vedere la trasformazione dell'anteprima del menu anche per app.config.

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

Quindi ho finito con un approccio leggermente diverso. Ho seguito i passaggi di Dan attraverso il passaggio 3, ma ho aggiunto un altro file: App.Base.Config. Questo file contiene le impostazioni di configurazione desiderate in ogni App.Config generato. Quindi uso BeforeBuild (con l'aggiunta di Yuri a TransformXml) per trasformare la configurazione corrente con la configurazione Base in App.config. Il processo di generazione utilizza quindi l'App.config trasformato normalmente. Tuttavia, una seccatura è che in un certo senso si desidera escludere App.config in continua evoluzione dal controllo del codice sorgente in seguito, ma gli altri file di configurazione ora dipendono da esso.

  <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 un piccolo miglioramento alla soluzione che sembra essere pubblicata ovunque ora:

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

• cioè, a meno che tu non abbia intenzione di rimanere con la tua attuale versione VS per sempre

Ho creato un'altra alternativa a quella pubblicata da Vishal Joshi in cui l'obbligo di modificare l'azione di costruzione in Contenuto viene rimosso e implementato anche il supporto di base per la distribuzione ClickOnce. Dico di base, perché non l'ho testato a fondo ma dovrebbe funzionare nel tipico scenario di distribuzione ClickOnce.

La soluzione consiste in un singolo progetto MSBuild che una volta importato in un progetto di applicazione Windows esistente (* .csproj) estende il processo di compilazione per contemplare la trasformazione app.config.

Puoi leggere una spiegazione più dettagliata su Trasformazione XML di Visual Studio App.config e il file di progetto MSBuild può essere scaricato da GitHub .

Se si utilizza un TFS online (versione Cloud) e si desidera trasformare App.Config in un progetto, è possibile effettuare le seguenti operazioni senza installare strumenti aggiuntivi. Da VS => Scarica il progetto => Modifica file progetto => Vai alla fine del file e aggiungi quanto segue:

<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 funzionano per uso locale e server TFS online (Cloud).

la soluzione proposta non funzionerà quando si fa riferimento a una libreria di classi con file di configurazione da un altro progetto (nel mio caso si trattava della libreria di progetti di lavoro di Azure). Non copierà il file trasformato corretto dalla objcartella alla bin\##configuration-name##cartella. Per farlo funzionare con modifiche minime, è necessario modificare l' AfterCompileobiettivo in BeforeCompile:

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