How can I save application settings in a Windows Forms application?

Question

What I want to achieve is very simple: I have a Windows Forms (.NET 3.5) application that uses a path for reading information. This path can be modified by the user, by using the options form I provide.

Now, I want to save the path value to a file for later use. This would be one of the many settings saved to this file. This file would sit directly in the application folder.

I understand three options are available:

• ConfigurationSettings file (appname.exe.config)
• Registry
• Custom XML file

I read that the .NET configuration file is not foreseen for saving values back to it. As for the registry, I would like to get as far away from it as possible.

Does this mean that I should use a custom XML file to save configuration settings?

If so, I would like to see code example of that (C#).

I have seen other discussions on this subject, but it is still not clear to me.

Solution 1

If you work with Visual Studio then it is pretty easy to get persistable settings. Right click on the project in Solution Explorer and choose Properties. Select the Settings tab and click on the hyperlink if settings doesn't exist.

Use the Settings tab to create application settings. Visual Studio creates the files Settings.settings and Settings.Designer.settings that contain the singleton class Settings inherited from ApplicationSettingsBase. You can access this class from your code to read/write application settings:

Properties.Settings.Default["SomeProperty"] = "Some Value";
Properties.Settings.Default.Save(); // Saves settings in application configuration file

This technique is applicable both for console, Windows Forms, and other project types.

Note that you need to set the scope property of your settings. If you select Application scope then Settings.Default.<your property> will be read-only.

Reference: How To: Write User Settings at Run Time with C# - Microsoft Docs

Solution 2

If you are planning on saving to a file within the same directory as your executable, here's a nice solution that uses the JSON format:

using System;
using System.IO;
using System.Web.Script.Serialization;

namespace MiscConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            MySettings settings = MySettings.Load();
            Console.WriteLine("Current value of 'myInteger': " + settings.myInteger);
            Console.WriteLine("Incrementing 'myInteger'...");
            settings.myInteger++;
            Console.WriteLine("Saving settings...");
            settings.Save();
            Console.WriteLine("Done.");
            Console.ReadKey();
        }

        class MySettings : AppSettings<MySettings>
        {
            public string myString = "Hello World";
            public int myInteger = 1;
        }
    }

    public class AppSettings<T> where T : new()
    {
        private const string DEFAULT_FILENAME = "settings.json";

        public void Save(string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(this));
        }

        public static void Save(T pSettings, string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(pSettings));
        }

        public static T Load(string fileName = DEFAULT_FILENAME)
        {
            T t = new T();
            if(File.Exists(fileName))
                t = (new JavaScriptSerializer()).Deserialize<T>(File.ReadAllText(fileName));
            return t;
        }
    }
}

Solution 3

The registry is a no-go. You're not sure whether the user which uses your application, has sufficient rights to write to the registry.

You can use the app.config file to save application-level settings (that are the same for each user who uses your application).

I would store user-specific settings in an XML file, which would be saved in Isolated Storage or in the SpecialFolder.ApplicationData directory.

Next to that, as from .NET 2.0, it is possible to store values back to the app.config file.

Solution 4

The ApplicationSettings class doesn't support saving settings to the app.config file. That's very much by design; applications that run with a properly secured user account (think Vista UAC) do not have write access to the program's installation folder.

You can fight the system with the ConfigurationManager class. But the trivial workaround is to go into the Settings designer and change the setting's scope to User. If that causes hardships (say, the setting is relevant to every user), you should put your Options feature in a separate program so you can ask for the privilege elevation prompt. Or forego using a setting.

Solution 5

The registry/configurationSettings/XML argument still seems very active. I've used them all, as the technology has progressed, but my favourite is based on Threed's system combined with Isolated Storage.

The following sample allows storage of an objects named properties to a file in isolated storage. Such as:

AppSettings.Save(myobject, "Prop1,Prop2", "myFile.jsn");

Properties may be recovered using:

AppSettings.Load(myobject, "myFile.jsn");

It is just a sample, not suggestive of best practices.

internal static class AppSettings
{
    internal static void Save(object src, string targ, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = src.GetType();

        string[] paramList = targ.Split(new char[] { ',' });
        foreach (string paramName in paramList)
            items.Add(paramName, type.GetProperty(paramName.Trim()).GetValue(src, null));

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify.
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Create, storage))
            using (StreamWriter writer = new StreamWriter(stream))
            {
                writer.Write((new JavaScriptSerializer()).Serialize(items));
            }

        }
        catch (Exception) { }   // If fails - just don't use preferences
    }

    internal static void Load(object tar, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = tar.GetType();

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Open, storage))
            using (StreamReader reader = new StreamReader(stream))
            {
                items = (new JavaScriptSerializer()).Deserialize<Dictionary<string, object>>(reader.ReadToEnd());
            }
        }
        catch (Exception) { return; }   // If fails - just don't use preferences.

        foreach (KeyValuePair<string, object> obj in items)
        {
            try
            {
                tar.GetType().GetProperty(obj.Key).SetValue(tar, obj.Value, null);
            }
            catch (Exception) { }
        }
    }
}

View more solutions

Comments

[Portman]

Is this a .NET WinForms application? If so, what version of .NET are you developing on?

[Kiquenet]

do you need save passwords or secrets values ? Maybe requires any encryption

[Gishu]

Not true.. see aku's answer above. its possible using Settings and ApplicationSettingsBase

[thenonhacker]

Use the registry, though, if you want per-login/user settings.

[Theo]

@thenonhacker: Or use Environment.GetFolderPath(Environment.SpecialFolder.Applicat‌​ionData)

[CannibalSmith]

Could you please expand upon your last sentence? Ask for elevation to write app.config or to write a separate application that would go through all users' home folers, look for user.config and edit these?

[user1703401]

The separate program requires a manifest to ask for elevation. Google 'asinvoker requireadministrator' to find the proper syntax. Editing user.config is not practical, nor necessary.

[franko_camron]

if I have a solution, will this apply for the entire solution or for each project ?

[Boczek]

Or better still; use DataContractJsonSerializer

[Four]

By default the Settings.Default.Save() method does nothing. You must use a diffrent provider. See: geek-republic.com/2010/11/08/c-portable-settings-provider

[Jon Gretar]

@Four: I've got a .NET 4.0 WinApp project here, and my SomeProperty is not readonly. Settings.Default.SomeProperty = 'value'; Settings.Default.Save(); works like a charm. Or is that because I've got User-settings?

[Jon Gretar]

@Four: When I changed a setting from User to Application-scope and save the file, I saw in the generated code the setter disappeared. This also happens with Client profile 4.0 ...

[bobobobo]

@Kb. Yes, and so is an anonymous struct within a union. Not a good reason not to use it, if you are targetting the Windows platform (from C# no less)

[minnow]

@Four: great link, though your statement that the Settings.Default.Save() does nothing is incorrect. As @aku states in the answer, app-scope settings are read-only: save is ineffective for them. Use that custom PortableSettingsProvider to save user-scope settings to the app.config located where the exe is instead of the one in the user's AppData folder. No, not generally good, but I use it during development to use the same settings from compile to compile (w/o it, they go new unique user folders with each compile).

[minnow]

Would someone mind explaining how "it is possible to store values back to the app.config file (that are the same for each user who uses your application)."? I'm with @Hans Passant in his answer: "The ApplicationSettings class doesn't support saving settings to the app.config file." The only way I've found to save settings to the app.config in the exe's folder is to use user-scope settings together with a custom SettingsProvider like this one: PortableSettingsProvider.

[Sreekumar P]

wht if I don't have a config file? or any file.. I have only one exe file

[eselk]

As of now, with .NET 3.5 it appears you can just use Settings.Default.SomeProperty to assign a value and get strong typecasting. Also, to save others time (took me a while to figure this out), you need to either type Properties.Settings.Default, or add using YourProjectNameSpace.Settings to the top of your file. "Settings" alone is not defined/found.

[deegee]

@thenonhacker - The registry is not required and should not be used for storing application settings - ever. The System.Environment.SpecialFolder.LocalApplicationData is the per-user local folder. The .ApplicationData is the per-user roaming folder. See msdn.microsoft.com/en-us/library/…

[Ian Thompson]

Error 2 The name 'Settings' does not exist in the current context. Answer does not work as stated. Should be Properties.Settings.Default

[Mitulát báti]

When I restarted my program, it didn't keep my changes... the default settings were set.

[Mitulát báti]

Ohh I haven't called the Save method. Now works. It stores the data in the app config file.

[SubmarineX]

@Four in .NET4.0, I find Properties.Settings.Default.SomeProperty = "sth"; is work fine. SomeProperty is in user-scope, why?

[downwitch]

Better/simpler answer (and no, not rep-spam attempts--only putting it here because this is the most popular version of this question): stackoverflow.com/a/8313682/409856

[Trevor]

Yes, change the DEFAULT_FILENAME to an absolute path if you want to save to another directory. I think it's most common to save the file to the same directory as the application, or a sub-directory, if you're not saving them to the registry.

[Trevor]

Oh, perhaps the better option would be to store the settings file in the user's appdata folder.

[Jesse Chisholm]

No need to change DEFAULT_FILENAME, just call settings.Save(theFileToSaveTo); Being all caps, DEFAULT_FILENAME is supposed to be a constant. If you want a read-write property, make one and have the constructor set it to DEFAULT_FILENAME. Then have the default argument value be null, test for this and use your property as the default value. It is a little more typing, but gives you a more standard interface.

[TEK]

You'll need to reference System.Web.Extensions.dll if you haven't already.

[anakic]

Could I interest you in taking a 15-second-look at a library (github.com/anakic/Jot) I've built for this sort of thing?

[Cole]

Do these settings persist if/when a new version of the application is installed over top the previous version?

[Kesty]

The user registry can be written to (lots of programs write information there, and user permissions are never a problem). The advantage of using the registry over using settings is that if you have multiple applications sharing the same folder, (say, a setup program and an an application program), they won't share the same settings.

[Kesty]

The settings cannot be shared between two applications (say, a setup app and the app itself, so if this is a requirement, this solution won't work.

[Philip Stratford]

I have this working great in development, but when I deploy the application the average user doesn't have access to the c:\program files\my application folder, so the saving of settings throws an error. I'm looking into saving the xml file in AppData instead, but I just wondered if there was an obvious way around this problem, since this approach seems to have worked for you.

[Dieter Meemken]

@PhilipStratford Since it is only a normal file, you can save it anywhere. Just find a place with write access.

[Dieter Meemken]

@PhilipStratford May be the AppData folder is an option for you, see C# getting the path of %AppData%, as mentioned by kite.

[Philip Stratford]

Thanks, I've already implemented this, saving the xml file in the AppDate folder. I just wondered whether there was an easy way to save it in the application's folder as per your example, since I assumed you had made it work. Not to worry, the AppData folder is probably a better location anyway!

[i486]

The main disadvantage of Registry is the hard way to export/copy settings to other PC. But I don't agree with "You're not sure whether the user which uses your application, has sufficient rights to write to the registry" - In HKEY_CURRENT_USER you always have rights to write. It can be denied but the filesystem can also be inaccessible for current user (all possible TEMP folders, etc).

[NucS]

I've created an entire library based on this answer with many improvements and made it available in nuget: github.com/Nucs/JsonSettings

[No Em]

There is another way to save/load settings that uses the json format is Config4Net library, it can also show a window for editing these settings at the runtime. Especially when you want to create a settings form that binds to a specific settings object, so with this library it's just one line and it done.

[EyePeaSea]

Lots of opinion (good) but very little compelling info one way or the other (config -v- Registry). @DeeGee not picking on you, but you seem so adamant that the registry should never be used. Ironic that the software platform in question uses over 400 personal registry settings, and goodness knows how many global registry settings. Would suggest that MS don't think the registry must not be used "ever". You're an experienced programmer, I'm an experienced Infrastructure and Environment person - so I know that in some situations, there are good reasons for not making AppData roam with users.

[deegee]

@EyePeaSea - I do agree with you that in the scheme of things it doesn't really matter which method a developer chooses, there are pro's and con's to any method. However, I still believe that software applications should use the provided user folders for storing application specific data including settings files. Registry hive bloat and massive numbers of orphaned keys is a real thing. The only time that I will use the Registry is when I have some items that I don't want located in an .ini file, such as software registration license keys, or cross version persisting items.

[Matt]

@NoChance - You're welcome, glad that I could help you!

[Momoro]

Nice! Finally figured it all out 😂😂😂

[Andy]

Do not write to the same folder as your exe unless you're working on an app you know will only be installed to appdata. If your exe is installed to either program folder then the user is highly unlikely to be able to save files there. Why not? It turned out allowing an app to save files into where dll and exe are stored was a security loophole.

[Moiyd]

Can you clarify where is the settings file located ? or how it looks like ?

[Moiyd]

Very great answer and saved my day. Thank you! How to modify that file using code, assuming I need to add more parameters? thanks again.

[Turker Tunali]

See the "Creating a Configuration in-memory" and "Saving a Configuration" in the github.com/cemdervis/SharpConfig.

[orfruit]

Trevor, it's just extraordinary simple and reliable solution! I was able to save my complex object instantly... with XML I would spend few days to make it work. Thank you again!