Serializing custom classes with custom Settings Provider

Question

I'm trying to save the following classes using a custom Settings Provider but keep getting a null reference error (error details below).

[Serializable]
public class SoundClips
{

    [System.Xml.Serialization.XmlElementAttribute("Items")]
    public List<SoundKeyBind> Items { get; set; }

    public SoundClips()
    {
        Items = new List<SoundKeyBind>();
    }

}

[Serializable]
public class SoundKeyBind
{
    public string FilePath { get; set; }
    public string FileName { get; set; }
    public string KeyBindText { get; set; }
    public KeyPressedEventArgs KeyBind { get; set; }
}

Saved by:

        dgvSoundBoard.DataSource = keyBinds.Items;
        Properties.Settings.Default.SoundBinds = keyBinds;
        Properties.Settings.Default.Save();

I got the following Settings Provider on GitHub somewhere but can't find the link to reference it, sorry.

public sealed class MySettingsProvider : SettingsProvider, IApplicationSettingsProvider
{
    private const string _rootNodeName = "settings";
    private const string _localSettingsNodeName = "localSettings";
    private const string _globalSettingsNodeName = "globalSettings";
    private const string _className = "MySettingsProvider";
    private XmlDocument _xmlDocument;

    private string _filePath
    {
        get
        {
            return Path.Combine(Path.GetDirectoryName(Application.ExecutablePath),
               string.Format("{0}.settings", ApplicationName));
        }
    }

    private XmlNode _localSettingsNode
    {
        get
        {
            XmlNode settingsNode = GetSettingsNode(_localSettingsNodeName);
            XmlNode machineNode = settingsNode.SelectSingleNode(Environment.MachineName.ToLowerInvariant());

            if (machineNode == null)
            {
                machineNode = _rootDocument.CreateElement(Environment.MachineName.ToLowerInvariant());
                settingsNode.AppendChild(machineNode);
            }

            return machineNode;
        }
    }

    private XmlNode _globalSettingsNode
    {
        get { return GetSettingsNode(_globalSettingsNodeName); }
    }

    private XmlNode _rootNode
    {
        get { return _rootDocument.SelectSingleNode(_rootNodeName); }
    }

    private XmlDocument _rootDocument
    {
        get
        {
            if (_xmlDocument == null)
            {
                try
                {
                    _xmlDocument = new XmlDocument();
                    _xmlDocument.Load(_filePath);
                }
                catch (Exception)
                {

                }

                if (_xmlDocument.SelectSingleNode(_rootNodeName) != null)
                    return _xmlDocument;

                _xmlDocument = GetBlankXmlDocument();
            }

            return _xmlDocument;
        }
    }

    public override string ApplicationName
    {
        get { return Path.GetFileNameWithoutExtension(Application.ExecutablePath); }
        set { }
    }

    public override string Name
    {
        get { return _className; }
    }

    public override void Initialize(string name, NameValueCollection config)
    {
        base.Initialize(Name, config);
    }

    public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection)
    {
        foreach (SettingsPropertyValue propertyValue in collection)
            SetValue(propertyValue);

        try
        {
            _rootDocument.Save(_filePath);
        }
        catch (Exception)
        {
            /* 
             * If this is a portable application and the device has been 
             * removed then this will fail, so don't do anything. It's 
             * probably better for the application to stop saving settings 
             * rather than just crashing outright. Probably.
             */
        }
    }

    public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
    {
        SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();

        foreach (SettingsProperty property in collection)
        {
            values.Add(new SettingsPropertyValue(property)
            {
                SerializedValue = GetValue(property)
            });
        }

        return values;
    }

    private void SetValue(SettingsPropertyValue propertyValue)
    {
        XmlNode targetNode = IsGlobal(propertyValue.Property)
           ? _globalSettingsNode
           : _localSettingsNode;

        XmlNode settingNode = targetNode.SelectSingleNode(string.Format("setting[@name='{0}']", propertyValue.Name));

        if (settingNode != null)
            settingNode.InnerText = propertyValue.SerializedValue.ToString();
        else
        {
            settingNode = _rootDocument.CreateElement("setting");

            XmlAttribute nameAttribute = _rootDocument.CreateAttribute("name");
            nameAttribute.Value = propertyValue.Name;

            settingNode.Attributes.Append(nameAttribute);

            // ######### ERROR OCCURS HERE #########
            settingNode.InnerText = propertyValue.SerializedValue.ToString();
            // ######### ERROR OCCURS HERE #########

            targetNode.AppendChild(settingNode);
        }
    }

    private string GetValue(SettingsProperty property)
    {
        XmlNode targetNode = IsGlobal(property) ? _globalSettingsNode : _localSettingsNode;
        XmlNode settingNode = targetNode.SelectSingleNode(string.Format("setting[@name='{0}']", property.Name));

        if (settingNode == null)
            return property.DefaultValue != null ? property.DefaultValue.ToString() : string.Empty;

        return settingNode.InnerText;
    }

    private bool IsGlobal(SettingsProperty property)
    {
        foreach (DictionaryEntry attribute in property.Attributes)
        {
            if ((Attribute)attribute.Value is SettingsManageabilityAttribute)
                return true;
        }

        return false;
    }

    private XmlNode GetSettingsNode(string name)
    {
        XmlNode settingsNode = _rootNode.SelectSingleNode(name);

        if (settingsNode == null)
        {
            settingsNode = _rootDocument.CreateElement(name);
            _rootNode.AppendChild(settingsNode);
        }

        return settingsNode;
    }

    public XmlDocument GetBlankXmlDocument()
    {
        XmlDocument blankXmlDocument = new XmlDocument();
        blankXmlDocument.AppendChild(blankXmlDocument.CreateXmlDeclaration("1.0", "utf-8", string.Empty));
        blankXmlDocument.AppendChild(blankXmlDocument.CreateElement(_rootNodeName));

        return blankXmlDocument;
    }

    public void Reset(SettingsContext context)
    {
        _localSettingsNode.RemoveAll();
        _globalSettingsNode.RemoveAll();

        _xmlDocument.Save(_filePath);
    }

    public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
    {
        // do nothing
        return new SettingsPropertyValue(property);
    }

    public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
    {
    }
}

The error occurs in the Settings Provider, in private void SetValue(SettingsPropertyValue propertyValue) when it tries to access propertyValue.SerializedValue.ToString() which is null. I have commented around it in the code above to help highlight the location. The error is:

An unhandled exception of type 'System.NullReferenceException' occurred in SoundBoard.exe Object reference not set to an instance of an object.

In the settings designer I have set the Provider of the setting to MySettingsProvider and set Roaming to True. I'm guessing that I've got something wrong with the Serialization declaration for the classes, but I've tried a few things, for example:

[Serializable]
[SettingsSerializeAs(SettingsSerializeAs.Xml)]
public class SoundClips

and can't figure it out.

Any help would be greatly appreciated.

Answer 1

I managed to solve the problem by breaking the class down and saving each bit one at a time. The problem turned out to be that the SoundKeyBind class and the KeyPressedEventArgs class/object which was created within it required a constructor which takes no parameters.

I.e. I needed to add the following to the respective classes:

public SoundKeyBind() { }

and

public KeyPressedEventArgs() { }