2010-06-22 8 views
12

¿Alguien conoce una forma de establecer las configuraciones de nivel de aplicación (o usuario) en una aplicación .Net que estén condicionadas al modo de desarrollo actual de las aplicaciones? IE: Depurar/LiberarDiferentes configuraciones de aplicación según el modo de configuración

Para ser más específicos, tengo una referencia de URL a mis servicios web en la configuración de mi aplicación. Durante el modo de lanzamiento me gustaría que esas configuraciones apunten a http://myWebservice.MyURL.com durante el modo de depuración. Me encantaría que esas configuraciones sean http://myDebuggableWebService.MyURL.com.

¿Alguna idea?

+0

Gracias hhravn! –

Respuesta

5

No existe, hasta donde yo sé, ninguna forma de hacerlo. En nuestro proyecto, mantenemos 4 archivos de configuración diferentes, y alternamos entre ellos copiando cada uno en el archivo activo en el paso de preconstrucción de la compilación.

copy "$(ProjectDir)properties\settings.settings.$(ConfigurationName).xml" "$(ProjectDir)properties\settings.settings" 
copy "$(ProjectDir)properties\settings.designer.$(ConfigurationName).cs" "$(ProjectDir)properties\settings.Designer.cs" 

Esto ha funcionado perfectamente para nosotros durante unos años. Simplemente cambie el objetivo y todo el archivo de configuración también cambiará.

Editar: Los archivos se nombran p. settings.settings.Debug.xml, etc .. l settings.settings.Release.xm

de Scott Hanselman ha descrito un enfoque ligeramente 'más inteligente', la única diferencia es que no tenemos la comprobación para ver si el archivo ha cambiado: http://www.hanselman.com/blog/ManagingMultipleConfigurationFileEnvironmentsWithPreBuildEvents.aspx

4

Si Desea mantener todo en un archivo de configuración. Puede introducir una sección de configuración personalizada en su aplicación. Configuraciones para almacenar propiedades para los modos de depuración y liberación.

Puede persistir el objeto en su aplicación que almacena la configuración específica del modo dev o anular una aplicación existente basada en el conmutador de depuración.

Aquí está un ejemplo breve aplicación de consola (DevModeDependencyTest):

App.config:

<?xml version="1.0" encoding="utf-8"?> 
<configuration> 
    <configSections> 
    <sectionGroup name="DevModeSettings"> 
     <section name="debug" type="DevModeDependencyTest.DevModeSetting,DevModeDependencyTest" allowLocation="true" allowDefinition="Everywhere" /> 
     <section name="release" type="DevModeDependencyTest.DevModeSetting,DevModeDependencyTest" allowLocation="true" allowDefinition="Everywhere" /> 
    </sectionGroup> 
    </configSections> 
    <DevModeSettings> 
    <debug webServiceUrl="http://myDebuggableWebService.MyURL.com" /> 
    <release webServiceUrl="http://myWebservice.MyURL.com" /> 
    </DevModeSettings> 
    <appSettings> 
    <add key="webServiceUrl" value="http://myWebservice.MyURL.com" /> 
    </appSettings> 
</configuration> 

El objeto de almacenar la configuración personalizada (DevModeSettings.cs):

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Configuration; 

namespace DevModeDependencyTest 
{ 
    public class DevModeSetting : ConfigurationSection 
    { 
     public override bool IsReadOnly() 
     { 
      return false; 
     } 

     [ConfigurationProperty("webServiceUrl", IsRequired = false)] 
     public string WebServiceUrl 
     { 
      get 
      { 
       return (string)this["webServiceUrl"]; 
      } 
      set 
      { 
       this["webServiceUrl"] = value; 
      } 
     } 
    } 
} 

Un controlador para acceder a la configuración de configuración personalizada (DevModeSettingsHandler.cs):

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Configuration; 

namespace DevModeDependencyTest 
{ 
    public class DevModeSettingsHandler 
    { 
     public static DevModeSetting GetDevModeSetting() 
     { 
      return GetDevModeSetting("debug"); 
     } 

     public static DevModeSetting GetDevModeSetting(string devMode) 
     { 
      string section = "DevModeSettings/" + devMode; 

      ConfigurationManager.RefreshSection(section); // This must be done to flush out previous overrides 
      DevModeSetting config = (DevModeSetting)ConfigurationManager.GetSection(section); 

      if (config != null) 
      { 
       // Perform validation etc... 
      } 
      else 
      { 
       throw new ConfigurationErrorsException("oops!"); 
      } 

      return config; 
     } 
    } 
} 

Y finalmente su punto de entrada a la aplicación de consola (DevModeDependencyTest.cs):

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Configuration; 

namespace DevModeDependencyTest 
{ 
    class DevModeDependencyTest 
    { 
     static void Main(string[] args) 
     { 
      DevModeSetting devMode = new DevModeSetting(); 

      #if (DEBUG) 
       devMode = DevModeSettingsHandler.GetDevModeSetting("debug"); 
       ConfigurationManager.AppSettings["webServiceUrl"] = devMode.WebServiceUrl; 
      #endif 

      Console.WriteLine(ConfigurationManager.AppSettings["webServiceUrl"]); 
      Console.ReadLine(); 
     } 
    } 
} 
14

Sé que esto se le pidió hace años, pero por si acaso alguien está buscando una solución simple y eficaz que utilizo .

  1. Vaya a las propiedades del proyecto, la pestaña Configuración (verá la URL de su servicio web o cualquier otra configuración ya incluida aquí).

  2. Haga clic en el botón "Ver código" disponible en la página Configuración.

  3. Escriba esto en el constructor.

    this.SettingsLoaded += Settings_SettingsLoaded; 
    
  4. agregue la siguiente función en el marco del constructor:

    void Settings_SettingsLoaded(object sender, System.Configuration.SettingsLoadedEventArgs e) 
    { 
        #if(DEBUG) 
        this["YOUR_SETTING_NAME"] = VALUE_FOR_DEBUG_CONFIGURATION; 
        #else 
        this["YOUR_SETTING_NAME"] = VALUE_FOR_RELEASE_CONFIGURATION; 
        #endif 
    } 
    

Ahora cada vez que ejecute el proyecto, se compilará sólo la línea que coincide con la configuración de generación actual.

3

SlowCheetah añade la funcionalidad de pedir no sólo para App.config sino para cualquier archivo XML en su proyecto - http://visualstudiogallery.msdn.microsoft.com/69023d00-a4f9-4a34-a6cd-7e854ba318b5

+1

Si bien esto podría responder teóricamente a la pregunta, [sería preferible] (http://meta.stackexchange.com/q/8259) incluir aquí las partes esenciales de la respuesta y proporcionar el enlace de referencia. – Spontifixus

+0

Creo que esta es probablemente la mejor respuesta: parece permitir la configuración por configuración de configuración.config de configuración (al igual que la construcción en web.config transforma). –

12

Esto es un poco tarde a la fiesta, pero tropezó con una bonita manera de aplicar el web.transform enfoque para app.config archivos. (es decir, hace uso del espacio de nombres http://schemas.microsoft.com/XML-Document-Transform)

Creo que es "bueno" porque es un enfoque de xml puro y no requiere software de terceros.

  • Un archivo App.config padre/desciende de forma predeterminada, de acuerdo con sus diferentes configuraciones de construcción.
  • Estos descendientes solo anulan lo que necesitan.

En mi opinión, esto es mucho más sofisticado y robusto que tener que mantener x número de archivos de configuración, que son copiadas en su totalidad, como en otras respuestas.

Un tutorial ha sido publicado aquí: http://mitasoft.wordpress.com/2011/09/28/multipleappconfig/


Mira, mamá - No hay explícitas colocar acumulaciones eventos en mi IDE!

+0

Cheers Mate funciona perfectamente! – petric

0

tuve un problema similar para resolver y terminó con el TXD (web.config) transformar motor, que ya se sugirió en la respuesta de ne1410s que se pueden encontrar aquí: https://stackoverflow.com/a/27546685/410906

Pero en lugar de hacerlo manualmente como se describe en el enlace que he utilizado este plugin: https://visualstudiogallery.msdn.microsoft.com/579d3a78-3bdd-497c-bc21-aa6e6abbc859

el plugin es sólo ayudar a configurar la configuración, porque no es necesario para la construcción y la solución puede construirse sobre otras máquinas o en un servidor de compilación sin el plugin o cualquier otras herramientas que se requieren.

Cuestiones relacionadas