visual-studio - configuracion - no se ha declarado el elemento configuration

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

Así que terminé tomando 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 construcción luego utiliza el App.config transformado como de costumbre. Sin embargo, una molestia es que, de alguna manera, desea excluir el App.config siempre cambiante del control de origen, 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>

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 la aplicación de consola.

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

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

En mi experiencia, las cosas que necesito para hacer que el entorno sea específico son cosas como cadenas de conexión, ajustes y, a menudo, configuraciones de smpt. El sistema de configuración permite especificar estas cosas en archivos separados. Así que puedes usar esto en tu 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 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.

Entonces puedes definir un evento de pre-compilación de la siguiente manera:

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

En el desarrollo de equipos, puedes ajustar esto aún más al incluir% 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). Aún así, debe agregarlos al archivo de proyecto y configurar su propiedad de tipo de salida en "copiar siempre" o "copiar si es más reciente".

Simple, extensible, y funciona para todos los tipos de proyectos de Visual Studio (consola, winforms, wpf, web).

Escribí una extensión agradable para automatizar la transformación de app.config como la que se construyó en la Transformación de la Configuración del 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

Esto funciona ahora con el complemento 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 haces esto, obtendrás 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.
Podría pensar que querría usar XSLT para transformar un web.config, pero si bien se sienten intuitivamente, en realidad es muy detallado.
Aquí hay dos transformaciones, una con XSLT y la misma con la sintaxis / espacio de nombres de la Transformación de Documentos XML. Como con todas las cosas, XSLT tiene múltiples formas de hacer esto, pero se obtiene 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 crear 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 despliegue:
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform"> <appSettings> <add name="NewSetting" value="New Setting Value" xdt:Transform="Insert"/> </appSettings> </configuration>

He creado otra alternativa a la publicada por Vishal Joshi, donde se elimina el requisito de cambiar la acción de compilación al Contenido y también se implementó un 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 solo 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 de proyecto de MSBuild se puede descargar desde GitHub .

Inspirado por olegsych.com/2010/12/config-file-transformation y otros en esta pregunta, llevé la solución https://.com/a/5109530/2286801 un paso más allá para habilitar lo siguiente.

Funciona con ClickOnce
Trabaja con proyectos de configuración e implementación en VS 2010
Funciona con VS2010, 2013, 2015 (no probó 2012, aunque también debería funcionar).
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 al app.config por primera vez en el proceso de MSBuild. Utiliza un archivo de objetivos externo para facilitar la administración en múltiples proyectos.

Instrucciones:

Pasos similares a la otra solución. He citado lo que sigue igual y lo he incluido para una comparación completa y más fácil.

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

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  <PropertyGroup>  <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>  <AppConfig>$(IntermediateOutputPath)$(TargetFileName).config</AppConfig> </PropertyGroup> <Message Text="AppConfig transformation destination: = $(AppConfig)" /> </Target>  <Target Name="TransformAppConfig" AfterTargets="PrepareForBuild" Condition="exists(''app.$(Configuration).config'')">  <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 liberación, así que 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. Vincule los archivos de configuración de App. *. A la aplicación principal.config

Busque la sección del archivo de proyecto que contiene todas las referencias de App.config y App. *. Config y sustitúyala de la siguiente manera. Notarás que usamos Ninguno en lugar de Contenido.

<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. Activar transformaciones mágicas.
Al final del archivo después de
<Import Project="$(MSBuildToolsPath)/Microsoft.CSharp.targets" />
y antes de la final
</Project>

inserte el siguiente XML:

<Import Project="AppConfigTransformation.targets" />

¡Hecho!

Instale "Configuration Transform Tool" en Visual Studio desde Marketplace y reinicie VS. También podrá ver la vista previa del menú transformar para app.config.

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

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 de la carpeta obj en la carpeta bin/##configuration-name## . Para que funcione con cambios mínimos, necesita cambiar el destino de BeforeCompile a BeforeCompile :

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

Otra solución que he encontrado es NO usar las transformaciones, sino 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 e implementación en Visual Studio para generar MSI, forzará al proyecto de implementación a usar el archivo de configuración correcto al empaquetar.

Probé varias soluciones y aquí es 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á configuraciones de Debug y Release , así que 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 archivos .csproj directamente en el editor; primero debe descargar el proyecto. Luego haga clic derecho en él y seleccione Editar <Nombre del proyecto> .csproj .

3. Vincule los archivos de configuración de App. *. A la aplicación principal.config

Busque la sección del archivo de proyecto que contiene todas las App.config y App.*.config App.config . Notarás que sus acciones de compilación están configuradas en None :

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

Primero, establezca la acción de compilación para todos ellos en Content .
Luego, haga que todos los archivos específicos de la configuración dependan de la aplicación principal.config para que Visual Studio los App.config como lo hace con los archivos de diseñador y de código subyacente.

Reemplace el código XML anterior 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. Activar transformaciones mágicas.

Al final del archivo después de

<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'')">  <TransformXml Source="app.config" Destination="$(IntermediateOutputPath)$(TargetFileName).config" Transform="app.$(Configuration).config" />  <ItemGroup> <AppConfigWithTargetPath Remove="app.config" /> <AppConfigWithTargetPath Include="$(IntermediateOutputPath)$(TargetFileName).config"> <TargetPath>$(TargetFileName).config</TargetPath> </AppConfigWithTargetPath> </ItemGroup> </Target>

¡Ahora puede volver a cargar el proyecto, construirlo y disfrutar de App.config transformaciones de App.config !

Para tu información

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

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

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 dependiendo de la configuración que esté creando.

Resuelvo este problema con esta herramienta http://ctt.codeplex.com/ . Lo uso con el script CCNet / nAnt para hacer paquetes.

Si usa un TFS en línea (versión en la nube) y desea transformar la aplicación .Config en un proyecto, puede hacer lo siguiente sin instalar herramientas adicionales. Desde VS => Descargar el proyecto => Editar archivo de proyecto => Ir a la parte inferior del archivo y agregar 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 y Destination funcionan para uso local y servidor TFS en línea (Cloud).

Solo una pequeña mejora de 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 planee quedarse con su versión actual de VS para siempre