C# PortableSettings

using System;
using System.Collections.Specialized;
using System.Collections;
using System.Configuration;
using System.IO;
using System.Reflection;
using System.Xml;
using System.Xml.Linq;

namespace PortableSettings
{
    public class Provider : ProviderBase
    {
        public static string SettingsFileName { get; set; } = "Settings.config";

        public override string Name => "PortableSettingsProvider";

        public static void Apply(params ApplicationSettingsBase[] settingsList) => Apply(new Provider(), settingsList);

        private string ApplicationSettingsFile => Path.Combine(SettingsDirectory, SettingsFileName);

        public override void Reset(SettingsContext context)
        {
            if (File.Exists(ApplicationSettingsFile))
                File.Delete(ApplicationSettingsFile);
        }

        private XDocument GetXmlDoc()
        {
            XDocument xmlDoc = null;
            bool initnew = false;
            if (File.Exists(ApplicationSettingsFile))
            {
                try
                {
                    xmlDoc = XDocument.Load(ApplicationSettingsFile);
                }
                catch
                {
                    initnew = true;
                }
            }
            else
            {
                initnew = true;
            }
            if (initnew)
            {
                xmlDoc = new XDocument(new XElement("configuration", new XElement("userSettings", new XElement("Roaming"))));
            }
            return xmlDoc;
        }

        public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
        {
            XDocument xmlDoc = GetXmlDoc();
            SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
            foreach (SettingsProperty setting in collection)
            {
                SettingsPropertyValue value = new SettingsPropertyValue(setting)
                {
                    IsDirty = false,
                    SerializedValue = getXmlValue(xmlDoc, XmlConvert.EncodeLocalName((string)context["GroupName"]), setting)
                };
                values.Add(value);
            }
            return values;
        }

        public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection)
        {
            XDocument xmlDoc = GetXmlDoc();
            foreach (SettingsPropertyValue value in collection)
            {
                setXmlValue(xmlDoc, XmlConvert.EncodeLocalName((string)context["GroupName"]), value);
            }
            try
            {
                using (var writer = XmlWriter.Create(ApplicationSettingsFile, new XmlWriterSettings() { NewLineHandling = NewLineHandling.Entitize, Indent = true }))
                {
                    xmlDoc.Save(writer);
                }
            }
            catch { }
        }

        private object getXmlValue(XDocument xmlDoc, string scope, SettingsProperty prop)
        {
            object result = null;
            if (!IsUserScoped(prop))
                return result;
            XElement xmlSettings = xmlDoc.Element("configuration").Element("userSettings");
            if (IsRoaming(prop))
                xmlSettings = xmlSettings.Element("Roaming");
            else
                xmlSettings = xmlSettings.Element("PC_" + Environment.MachineName);
            if (xmlSettings != null && xmlSettings.Element(scope) != null && xmlSettings.Element(scope).Element(prop.Name) != null)
            {
                using (var reader = xmlSettings.Element(scope).Element(prop.Name).CreateReader())
                {
                    reader.MoveToContent();
                    switch (prop.SerializeAs)
                    {
                        case SettingsSerializeAs.Xml:
                            result = reader.ReadInnerXml();
                            break;
                        case SettingsSerializeAs.Binary:
                            result = reader.ReadInnerXml();
                            result = Convert.FromBase64String(result as string);
                            break;
                        default:
                            result = reader.ReadElementContentAsString();
                            break;
                    }
                }
            }
            else
            {
                result = prop.DefaultValue;
            }
            return result;
        }

        private void setXmlValue(XDocument xmlDoc, string scope, SettingsPropertyValue value)
        {
            if (!IsUserScoped(value.Property)) return;
            XElement xmlSettings = xmlDoc.Element("configuration").Element("userSettings");
            XElement xmlSettingsLoc;
            if (IsRoaming(value.Property))
                xmlSettingsLoc = xmlSettings.Element("Roaming");
            else
                xmlSettingsLoc = xmlSettings.Element("PC_" + Environment.MachineName);
            XNode serialized;
            if (value.SerializedValue == null || value.SerializedValue is string s && String.IsNullOrWhiteSpace(s))
                serialized = new XText("");
            else if (value.Property.SerializeAs == SettingsSerializeAs.Xml)
                serialized = XElement.Parse((string)value.SerializedValue);
            else if (value.Property.SerializeAs == SettingsSerializeAs.Binary)
                serialized = new XText(Convert.ToBase64String((byte[])value.SerializedValue));
            else
                serialized = new XText((string)value.SerializedValue);
            if (xmlSettingsLoc == null)
            {
                if (IsRoaming(value.Property))
                    xmlSettingsLoc = new XElement("Roaming");
                else
                    xmlSettingsLoc = new XElement("PC_" + Environment.MachineName);
                xmlSettingsLoc.Add(new XElement(scope, new XElement(value.Name, serialized)));
                xmlSettings.Add(xmlSettingsLoc);
            }
            else
            {
                XElement xmlScope = xmlSettingsLoc.Element(scope);
                if (xmlScope != null)
                {
                    XElement xmlElem = xmlScope.Element(value.Name);
                    if (xmlElem == null)
                        xmlScope.Add(new XElement(value.Name, serialized));
                    else
                        xmlElem.ReplaceAll(serialized);
                }
                else
                {
                    xmlSettingsLoc.Add(new XElement(scope, new XElement(value.Name, serialized)));
                }
            }
        }
    }

    public abstract class ProviderBase : SettingsProvider, IApplicationSettingsProvider
    {
        public static bool AllRoaming { get; set; } = false;

        public static string SettingsDirectory { get; set; } = AppDomain.CurrentDomain.BaseDirectory;

        public override string ApplicationName { get { return Assembly.GetExecutingAssembly().GetName().Name; } set { } }

        protected static void Apply(ProviderBase provider, params ApplicationSettingsBase[] settingsList)
        {
            foreach (var settings in settingsList)
            {
                settings.Providers.Clear();
                settings.Providers.Add(provider);
                foreach (SettingsProperty prop in settings.Properties)
                    prop.Provider = provider;
                settings.Reload();
            }
        }

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

        public virtual SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
        {
            throw new NotImplementedException();
        }

        public abstract void Reset(SettingsContext context);

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

        protected bool IsUserScoped(SettingsProperty prop)
        {
            foreach (DictionaryEntry d in prop.Attributes)
            {
                Attribute a = (Attribute)d.Value;
                if (a.GetType() == typeof(UserScopedSettingAttribute))
                    return true;
            }
            return false;
        }

        protected bool IsRoaming(SettingsProperty prop)
        {
            if (AllRoaming)
                return true;
            foreach (DictionaryEntry d in prop.Attributes)
            {
                Attribute a = (Attribute)d.Value;
                if (a.GetType() == typeof(SettingsManageabilityAttribute))
                    return true;
            }
            return false;
        }
    }
}