Different application settings depending on configuration mode

Question

Is anyone aware of a way that I can set application (or user) level settings in a .Net application that are conditional on the applications current development mode? IE: Debug/Release

To be more specific, I have a url reference to my webservices held in my application settings. During release mode I would like those settings to point to http://myWebservice.MyURL.com during debug mode I would love those settings to be http://myDebuggableWebService.MyURL.com.

Any ideas?

Solution 1

I know this was asked years ago, but just in case anyone is looking for a simple and effective solution that I use.

1. Go to project properties, Settings tab (you'll see your web service URL or any other settings already listed here).

2. Click the "View Code" button available on the Settings page.

3. Type this in the constructor.

   this.SettingsLoaded += Settings_SettingsLoaded;
   

4. Add the following function under the 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
   }
   

Now whenever you run your project, it will compile only the line that matches the current build configuration.

Solution 2

This is somewhat late to the party, but I stumbled upon a nice way of implementing the web.transform approach for app.config files. (i.e. it makes use of the namespace http://schemas.microsoft.com/XML-Document-Transform)

I think it is "nice" because it is a pure xml approach and doesn't require 3rd party software.

• A parent / default App.config file is descended from, according to your various build configurations.
• These descendants then only override what they need to.

In my opinion this is much more sophisticated and robust than having to maintain x number of config files which get copied in their entirety, such as in other answers.

A walkthrough has been posted here: http://mitasoft.wordpress.com/2011/09/28/multipleappconfig/

---

Look, Mom - No explicit post-build events in my IDE!

Solution 3

There is, as far as I know, no built in way of doing this. In our project we maintain 4 different settings files, and switch between them by copying each into the active file in the prebuild step of the build.

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

This has worked flawlessly for us for a few years. Simply change the target and the entire config file is switched as well.

Edit: The files are named e.g. settings.settings.Debug.xml, settings.settings.Release.xml etc..

Scott Hanselman has described a slightly 'smarter' approach, the only difference is that we don't have the check to see if the file has changed: http://www.hanselman.com/blog/ManagingMultipleConfigurationFileEnvironmentsWithPreBuildEvents.aspx

Solution 4

If you want to keep everything in one configuration file you can introduce a custom configuration section to your app.settings to store properties for debug and release modes.

You can either persist the object in your app that stores dev mode specific settings or override an existing appsetting based on the debug switch.

Here is a brief console app example (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>

The object to store your custom configuration (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;
            }
        }
    }
}

A handler to access your custom configuration settings (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;
        }
    }
}

And finally your entry point to the console app (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();
        }
    }
}

Solution 5

SlowCheetah adds the functionality you ask for not only for App.config but for any XML file in your project - http://visualstudiogallery.msdn.microsoft.com/69023d00-a4f9-4a34-a6cd-7e854ba318b5

View more solutions

Comments

[Spontifixus]

Whilst this may theoretically answer the question, it would be preferable to include the essential parts of the answer here, and provide the link for reference.

[David Faivre]

I think this is probably the best answer -- it seems to allow per-build configuration app.config transforms (much like the build in web.config transforms).

[Patrick]

Worked, thanks! If you are using VS 2017 and the error appears that it can not find the Web*.targets, then check out this answer stackoverflow.com/a/45354395/2964949

[Steve Smith]

Where/how do you specify the changes per configuration? For e.g., if I create a configuration called "QARelease", how would I check that this is the current one?

[dotNET]

Not sure if I understood you correctly, but there is #if(DEBUG) preprocessor directive for distinguishing between DEBUG and RELEASE configurations.Moreover you could define your own compilation symbols per configuration and use them in #if.

[Steve Smith]

Thanks. I wasn't sure where your DEBUG came from.

[Jean-François Beauchamp]

For VS 2017, v10.0 has to be replaced with v15.0 in <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v15‌​.0\Web\Microsoft.Web‌​.Publishing.targets" />.

[Papa Mufflon]

Use Project=”$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(‌​VisualStudioVersion)‌​\Web\Microsoft.Web.P‌​ublishing.targets” for any Visual Studio version (from the comments in the link).

[StackOverthrow]

There's now a VS plugin for this: Configuration Transform.