Transformation App.Config pour les projets qui ne sont pas des projets Web dans Visual Studio?

Pour l'application Web Visual Studio 2010, nous avons des fonctionnalités de transformation de configuration qui nous permettent de gérer plusieurs fichiers de configuration pour différents environnements. Mais la même fonctionnalité n'est pas disponible pour les fichiers App.Config pour les services Windows / WinForms ou l'application console.

Il existe une solution de contournement comme suggéré ici: Application de la magie XDT à App.Config .

Cependant, ce n'est pas simple et nécessite un certain nombre d'étapes. Existe-t-il un moyen plus simple d'obtenir la même chose pour les fichiers app.config?

Cela fonctionne maintenant avec le complément Visual Studio traité dans cet article: SlowCheetah - Syntaxe de transformation Web.config désormais généralisée pour tout fichier de configuration XML .

Vous pouvez cliquer avec le bouton droit sur votre web.config et cliquer sur "Ajouter des transformations de configuration". Lorsque vous faites cela, vous obtenez un web.debug.config et un web.release.config. Vous pouvez créer un fichier web.wwhat.config si vous le souhaitez, tant que le nom correspond à un profil de configuration. Ces fichiers ne sont que les modifications que vous souhaitez apporter, pas une copie complète de votre web.config.

Vous pourriez penser que vous voudriez utiliser XSLT pour transformer un web.config, mais bien qu'ils se sentent intuitivement correct, c'est en fait très verbeux.

Voici deux transformations, une utilisant XSLT et la même utilisant la syntaxe / espace de noms XML Transform. Comme pour tout, il y a plusieurs façons de le faire en XSLT, mais vous avez l'idée générale. XSLT est un langage de transformation d'arbre généralisé, tandis que celui de déploiement est optimisé pour un sous-ensemble spécifique de scénarios courants. Mais, la partie intéressante est que chaque transformation XDT est un plugin .NET, vous pouvez donc faire le vôtre.

<?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 la même chose via la transformation de déploiement:

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

J'ai essayé plusieurs solutions et voici la plus simple que j'ai trouvée personnellement.
Dan a souligné dans les commentaires que le message d'origine appartient à Oleg Sych - merci, Oleg!

Voici les instructions:

1. Ajoutez un fichier XML pour chaque configuration au projet.

En général , vous aurez Debuget Releaseconfigurations nom pour vos fichiers App.Debug.configet App.Release.config. Dans mon projet, j'ai créé une configuration pour chaque type d'environnement, donc vous voudrez peut-être l'expérimenter.

2. Déchargez le projet et ouvrez le fichier .csproj pour le modifier

Visual Studio vous permet de modifier des fichiers .csproj directement dans l'éditeur - il vous suffit de décharger le projet en premier. Cliquez ensuite dessus avec le bouton droit de la souris et sélectionnez Modifier <ProjectName> .csproj .

3. Liez les fichiers App. *. Config au fichier principal App.config

Recherchez la section du fichier de projet qui contient tout App.configet les App.*.configréférences. Vous remarquerez que leurs actions de génération sont définies sur None:

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

Tout d'abord, définissez l'action de construction pour chacun d'eux Content.
Ensuite, rendez tous les fichiers spécifiques à la configuration dépendants du principal App.configafin que Visual Studio les regroupe comme il le fait pour les fichiers de concepteur et de code.

Remplacez XML ci-dessus par celui ci-dessous:

<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. Activez la magie des transformations (uniquement nécessaire pour les versions de Visual Studio antérieures à VS2017 )

En fin de dossier après

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

et avant la finale

</Project>

insérez le XML suivant:

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

Vous pouvez maintenant recharger le projet, le construire et profiter des App.configtransformations!

FYI

Assurez-vous que vos App.*.configfichiers ont la bonne configuration comme celle-ci:

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

Une autre solution que j'ai trouvée est de NE PAS utiliser les transformations mais d'avoir juste un fichier de configuration séparé, par exemple app.Release.config. Ajoutez ensuite cette ligne à votre fichier csproj.

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

Cela générera non seulement le bon fichier myprogram.exe.config, mais si vous utilisez le projet d'installation et de déploiement dans Visual Studio pour générer MSI, il forcera le projet de déploiement à utiliser le fichier de configuration correct lors de l'empaquetage.

D'après mon expérience, les choses dont j'ai besoin pour rendre l'environnement spécifique sont des choses comme les chaînes de connexion, les paramètres des applications et souvent les paramètres smpt. Le système de configuration permet de spécifier ces choses dans des fichiers séparés. Vous pouvez donc l'utiliser dans votre app.config / web.config:

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

Ce que je fais généralement, c'est de mettre ces sections spécifiques à la configuration dans des fichiers séparés, dans un sous-dossier appelé ConfigFiles (que ce soit à la racine de la solution ou au niveau du projet, cela dépend). Je définis un fichier par configuration, par exemple smtp.config.Debug et smtp.config.Release.

Ensuite, vous pouvez définir un événement de pré-génération comme suit:

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

Dans le développement d'équipe, vous pouvez affiner cela en incluant le% COMPUTERNAME% et / ou% USERNAME% dans la convention.

Bien sûr, cela implique que les fichiers cibles (x.config) ne doivent PAS être placés dans le contrôle de code source (car ils sont générés). Vous devez toujours les ajouter au fichier de projet et définir leur propriété de type de sortie sur "copier toujours" ou "copier si plus récent".

Simple, extensible et fonctionne pour tous les types de projets Visual Studio (console, winforms, wpf, web).

Inspiré par Oleg et d'autres dans cette question, j'ai pris la solution https://stackoverflow.com/a/5109530/2286801 un peu plus loin pour activer ce qui suit.

• Fonctionne avec ClickOnce
• Fonctionne avec les projets de configuration et de déploiement dans VS 2010
• Fonctionne avec VS2010, 2013, 2015 (n'a pas testé 2012 mais devrait également fonctionner).
• Fonctionne avec Team Build. (Vous devez installer A) Visual Studio ou B) Microsoft.Web.Publishing.targets et Microsoft.Web.Publishing.Tasks.dll)

Cette solution fonctionne en effectuant la transformation app.config avant que le fichier app.config soit référencé pour la première fois dans le processus MSBuild. Il utilise un fichier de cibles externes pour une gestion plus facile sur plusieurs projets.

Instructions:

Étapes similaires à l'autre solution. J'ai cité ce qui reste le même et je l'ai inclus pour être complet et faciliter la comparaison.

0. Ajoutez un nouveau fichier à votre projet appelé 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. Ajoutez un fichier XML pour chaque configuration au projet.

En règle générale, vous aurez des configurations de débogage et de version, alors nommez vos fichiers App.Debug.config et App.Release.config. Dans mon projet, j'ai créé une configuration pour chaque type d'environnement afin que vous souhaitiez peut-être l'expérimenter.

2. Déchargez le projet et ouvrez le fichier .csproj pour le modifier

Visual Studio vous permet d'éditer .csproj directement dans l'éditeur — il vous suffit tout d'abord de décharger le projet. Faites ensuite un clic droit dessus et sélectionnez Modifier .csproj.

3. Liez les fichiers App. *. Config au fichier principal App.config

Recherchez la section du fichier de projet qui contient toutes les références App.config et App. *. Config et remplacez comme suit. Vous remarquerez que nous utilisons None au lieu 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. Activer la magie des transformations

En fin de dossier après

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

et avant la finale

</Project>

insérez le XML suivant:

<Import Project="AppConfigTransformation.targets" />

Terminé!

Vous pouvez utiliser un fichier de configuration distinct par configuration, par exemple app.Debug.config, app.Release.config, puis utiliser la variable de configuration dans votre fichier de projet:

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

Cela créera ensuite le fichier ProjectName.exe.config correct selon la configuration dans laquelle vous construisez.

J'ai écrit une belle extension pour automatiser la transformation app.config comme celle intégrée dans la transformation de configuration de projet d'application Web

Le plus grand avantage de cette extension est que vous n'avez pas besoin de l'installer sur toutes les machines de build

Installez «Configuration Transform Tool» dans Visual Studio à partir de Marketplace et redémarrez VS. Vous pourrez également voir la transformation de l'aperçu du menu pour app.config.

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

J'ai donc fini par adopter une approche légèrement différente. J'ai suivi les étapes de Dan jusqu'à l'étape 3, mais j'ai ajouté un autre fichier: App.Base.Config. Ce fichier contient les paramètres de configuration que vous souhaitez dans chaque App.Config généré. Ensuite, j'utilise BeforeBuild (avec l'ajout de Yuri à TransformXml) pour transformer la configuration actuelle avec la configuration de base en App.config. Le processus de génération utilise ensuite normalement App.config transformé. Cependant, une gêne est que vous souhaitez exclure l'App.config en constante évolution du contrôle de code source par la suite, mais les autres fichiers de configuration en dépendent désormais.

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

Juste une petite amélioration de la solution qui semble être affichée partout maintenant:

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

• c'est-à-dire, sauf si vous prévoyez de rester avec votre version VS actuelle pour toujours

J'ai créé une autre alternative à celle publiée par Vishal Joshi où l'exigence de changer l'action de génération en Contenu est supprimée et également implémenté la prise en charge de base du déploiement ClickOnce. Je dis de base, car je ne l'ai pas testé à fond, mais cela devrait fonctionner dans le scénario de déploiement ClickOnce typique.

La solution consiste en un seul projet MSBuild qui, une fois importé dans un projet d'application Windows existant (* .csproj), étend le processus de génération pour envisager la transformation app.config.

Vous pouvez lire une explication plus détaillée sur Visual Studio App.config XML Transformation et le fichier de projet MSBuild peut être téléchargé à partir de GitHub .

Si vous utilisez un TFS en ligne (version Cloud) et que vous souhaitez transformer App.Config en projet, vous pouvez effectuer les opérations suivantes sans installer d'outils supplémentaires. Depuis VS => Déchargez le projet => Modifier le fichier de projet => Allez en bas du fichier et ajoutez ce qui suit:

<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 et Destination fonctionnent pour une utilisation locale et un serveur TFS en ligne (Cloud).

la solution proposée ne fonctionnera pas lorsqu'une bibliothèque de classes avec un fichier de configuration est référencée à partir d'un autre projet (dans mon cas, c'était la bibliothèque de projet Azure Worker). Il ne copiera pas le fichier transformé correct du objdossier dans le bin\##configuration-name##dossier. Pour le faire fonctionner avec des changements minimes, vous devez changer la AfterCompilecible pour BeforeCompile:

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