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?

score 18 · Answer 1 · answered Dec 18 '14 at 12:31

18

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!

answered Dec 18 '14 at 12:31

ne1410s

6,864
6
55
61

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 https://stackoverflow.com/a/45354395/2964949 – Patrick Apr 04 '18 at 13:04
1

For VS 2017, `v10.0` has to be replaced with `v15.0` in ``. – Jean-François Beauchamp Aug 31 '18 at 15:24
2

Use `Project=”$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Web\Microsoft.Web.Publishing.targets”` for any Visual Studio version (from the comments in the link). – Papa Mufflon Oct 31 '18 at 08:25
1

There's now a VS plugin for this: [Configuration Transform](https://marketplace.visualstudio.com/items?itemName=GolanAvraham.ConfigurationTransform). – StackOverthrow Dec 07 '18 at 20:07
Does this work in .net core ? it does not work for me looks like the debug and release files are never used – IronHide Feb 08 '23 at 15:51

dotNET · Accepted Answer · 2017-07-11T13:14:52.860

15

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

Go to project properties, Settings tab (you'll see your web service URL or any other settings already listed here).
Click the "View Code" button available on the Settings page.

Type this in the constructor.

this.SettingsLoaded += Settings_SettingsLoaded;

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.

edited Jul 11 '17 at 13:14

answered Sep 18 '12 at 22:48

dotNET

33,414
24
162
251

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? – Steve Smith Apr 17 '18 at 08:39
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`. – dotNET Apr 17 '18 at 12:06
Thanks. I wasn't sure where your `DEBUG` came from. – Steve Smith Apr 17 '18 at 12:41

score 7 · Answer 3 · edited Jun 14 '17 at 20:43

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

jadusty · Answer 4 · 2010-06-22T10:48:13.913

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();
        }
    }
}

score 3 · Answer 5 · answered Jan 28 '13 at 12:26

3

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

answered Jan 28 '13 at 12:26

Konrad Brodzik

419
4
3

1

Whilst this may theoretically answer the question, [it would be preferable](http://meta.stackexchange.com/q/8259) to include the essential parts of the answer here, and provide the link for reference. – Spontifixus Jan 28 '13 at 12:43
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). – David Faivre Dec 06 '13 at 14:21

score 1 · Answer 6 · edited May 23 '17 at 11:46

I had a similar problem to solve and ended up using the XDT (web.config) transform engine, that was already suggested in the answer from ne1410s that can be found here: https://stackoverflow.com/a/27546685/410906

But instead of doing it manually as described in his link I used this plugin: https://visualstudiogallery.msdn.microsoft.com/579d3a78-3bdd-497c-bc21-aa6e6abbc859

The plugin is only helping to setup the configuration, it's not needed to build and the solution can be built on other machines or on a build server without the plugin or any other tools being required.

Different application settings depending on configuration mode

6 Answers6

Linked