Settings and IsDirty when modifying the settings through external references

Question

I have a C# application with a settings field that is a collection of custom objects.

When I start the application I create some class instances that take instances from the settings entry collection and keep a reference to them internally and modify them. While debugging I saw that changes done through these external references are not reflected when I callSettings.Default.Save() but changes done by directly accessing the properties likeSettings.Default.<property> work fine.

I looked up the code responsible for Save() and saw that the implementation actually checks a SettingsPropertyValue.IsDirty field to decide whether to or not to serialize it. Of course when I access the external references to the objects in the settings field that value is not set.

Is there any lightweight solution to this?

I don't think I'm the first person to encounter this. One way I can think of is implementing the IsDirty property in the collections I serialize and add INotifyPropertyChanged interface event PropertyChanged for all the contained instances so that the container is being notified of changes and can reflect them to the actual settings property. But that means wrapping each of the settings classes around with this logic. So what I am asking for is if there is a lightweight solution to this found by anyone else who has encountered this issue.

Example

Consider this class:

namespace SettingsTest
{
    [DataContract(Name="SettingsObject")]
    public class SettingsObject
    {
        [DataMember]
        public string Property { get; set; }
    }
}

And the following program:

namespace SettingsTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var settingsObjects = new List<SettingsObject>();
            var settingsObject = new SettingsObject{Property = "foo"};
            settingsObjects.Add(settingsObject);
            Settings.Default.SettingsObjects = settingsObjects;
            Settings.Default.Save();
            settingsObject.Property = "bar";
            Settings.Default.Save();
        }
    }
}

After the second Save() call the final output in user.config file is:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <userSettings>
        <SettingsTest.Settings>
            <setting name="SettingsObjects" serializeAs="Xml">
                <value>
                    <ArrayOfSettingsObject xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
                        <SettingsObject>
                            <Property>foo</Property>
                        </SettingsObject>
                    </ArrayOfSettingsObject>
                </value>
            </setting>
        </SettingsTest.Settings>
    </userSettings>
</configuration>

As you can see the modification to the property via the external reference to the SettingsObject instance was not persisted.

Answer 1

You seem to be covering a bunch of issues with this question. As you correctly said "changes done by directly accessing the properties likeSettings.Default. work fine." Modifying in memory references will not cause the settings to be updated automatically as you wanted. INotifyProperty changed is one solution.

If you want a quick and dirty method of serializing these objects into your settings file you can use the following code.

Objects involved:

/// <summary>Generic class to support serializing lists/collections to a settings file.</summary>
[Serializable()]
public class SettingsList<T> : System.Collections.ObjectModel.Collection<T> 
{
    public string ToBase64()
    {
        // If you don't want a crash& burn at runtime should probaby add 
        // this guard clause in: 'if (typeof(T).IsDefined(typeof(SerializableAttribute), false))'
            using (var stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, this);
                stream.Position = 0;
                byte[] buffer = new byte[(int)stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                return Convert.ToBase64String(buffer);
            }
    }
    public static SettingsList<T> FromBase64(string settingsList)
    {
        using (var stream = new MemoryStream(Convert.FromBase64String(settingsList)))
        {
            var deserialized = new BinaryFormatter().Deserialize(stream);

            return (SettingsList<T>)deserialized;
        }
    }  
}
[Serializable()]
public class SettingsObject
{
    public string Property { get; set; }

    public SettingsObject()
    {
    }
}

The main method demonstrates the issue you are facing, with a solution.

class Program
{
    static void Main(string[] args)
    {
        // Make sure we don't overwrite the previous run's settings.
        if (String.IsNullOrEmpty(Settings.Default.SettingsObjects))
        {
            // Create the initial settings.
            var list = new SettingsList<SettingsObject> { 
                new SettingsObject { Property = "alpha" }, 
                new SettingsObject { Property = "beta" }
            };
            Console.WriteLine("settingsObject.Property[0] is {0}", list[0].Property);

            //Save initial values to Settings
            Settings.Default.SettingsObjects = list.ToBase64();
            Settings.Default.Save();

            // Change a property
            list[0].Property = "theta";

            // This is where you went wrong, settings will not be persisted at this point
            // because you have only modified the in memory list.

            // You need to set the property on settings again to persist the value.
            Settings.Default.SettingsObjects = list.ToBase64();
            Settings.Default.Save();
        }
        // pull that property back out & make sure it saved.
        var deserialized = SettingsList<SettingsObject>.FromBase64(Settings.Default.SettingsObjects);
        Console.WriteLine("settingsObject.Property[0] is {0}", deserialized[0].Property);            

        Console.WriteLine("Finished! Press any key to continue.");
        Console.ReadKey();
    }

}

So all I'm doing is storing your whole list of objects as a base64 encoded string. Then we deserialize on the next run.

From what I understand of the question you want to only hold in memory references without hitting the settings object. You could simply run some code at the end of main to persist this list and any other setting you need to. Any changes will still be in memory as long as you hold a reference the object & will remain around until you terminate the application.

If you need the settings to be saved while the application is running just create a Save() method of your own & call it from the end of Main() as well when the user performs an action that requires saving the settings. e.g.

public static void SaveSettings(SettingsList list)
{
    Settings.Default.SettingsObjects = list.ToBase64();
    Settings.Default.Save();
}

Edit: One caveat as mentioned in the comments below.

From my benchmarks this method is very slow, meaning it's not a good idea to persist large object lists in settings this way. Once you have more than a handful of properties you might want to look at an embedded database like SQLite. A CSV, INI or XML file could also be an option here for large numbers of trivial settings. One benefit of simpler storage formats is easy modification by non-developers eg csv in excel. Of course this may not be what you want ;)