RegistrySettingsProvider.cs

Go to the documentation of this file.

using System;
using System.Collections.Specialized;
using System.Configuration;
using System.Diagnostics;
using System.Globalization;
using Microsoft.Win32;
 
namespace AnalyzeRe.Properties
{
    internal class RegistrySettingsProvider : SettingsProvider
    {
        // We could read these attributes from the assembly, but we use it in the settings key name so changes would have to be tracked carefully.
        private const string CompanyName = "Analyze Re";
        private const string SubKeyPath = @"Software\" + CompanyName;
 
        // This value is not used anywhere we know
        public override string ApplicationName { get; set; } = CompanyName;
        public override string Name => "RegistrySettingsProvider";
        public override string Description => "Analyze Re - shared registry settings provider";
 
        private string _initializedName;
 
        private NameValueCollection _initializedConfig;
 
        public override void Initialize(string name, NameValueCollection col)
        {
            _initializedName = name;
            _initializedConfig = col;
            base.Initialize(ApplicationName, col);
        }
 
        // SetPropertyValue is invoked when ApplicationSettingsBase.Save is called
        // ASB makes sure to pass each provider only the values marked for that provider,
        // whether on a per setting or setting class-wide basis
        public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals)
        {
            // Iterate through the settings to be stored
            foreach (SettingsPropertyValue propval in propvals)
            {
                // If property hasn't been set, no need to save it
                if (!propval.IsDirty)
                {
                    continue;
                }
 
                // Application-scoped settings can't change
                // NOTE: the settings machinery may cause or allow an app-scoped setting
                // to become dirty, in which case, like the LFSP, we ignore it instead
                // of throwing an exception
                if (IsApplicationScoped(propval.Property))
                {
                    continue;
                }
 
                Debug.Print($"RegistrySettingsProvider.SetPropertyValues - Setting {propval.Name} to {propval.SerializedValue}");
                using (RegistryKey key = CreateRegKey(context, propval.Property))
                {
                    // If the value has explicitly been set to null, the user probably wishes to clear the value.
                    if (propval.PropertyValue == null)
                        key.DeleteValue(propval.Name);
                    else if (propval.PropertyValue is StringCollection sc)
                    {
                        string[] stringArray = new string[sc.Count];
                        sc.CopyTo(stringArray, 0);
                        key.SetValue(propval.Name, stringArray, RegistryValueKind.MultiString);
                    }
                    else
                    {
                        key.SetValue(propval.Name, propval.SerializedValue);
                    }
                }
            }
        }
 
        public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties)
        {
            if (!HasRegKey(context))
            {
                // Fall back to reading settings from a LocalFileSettingsProvider, hoping to get old settings for upgrade
                SettingsPropertyValueCollection localFileValues = GetLocalFilePropertyValues(context, properties);
 
                // Save those values that don't have default values to the registry
                foreach (SettingsPropertyValue value in localFileValues)
                {
                    if (!value.UsingDefaultValue &&
                        value.SerializedValue != value.Property.DefaultValue)
                    {
                        value.IsDirty = true;
                    }
                }
 
                SetPropertyValues(context, localFileValues);
                return localFileValues;
            }
 
            SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
 
            foreach (SettingsProperty prop in properties)
            {
                SettingsPropertyValue value = GetPropertyValue(context, prop);
                Debug.Assert(value != null);
                values.Add(value);
            }
 
            return values;
        }
 
        private SettingsPropertyValue GetPropertyValue(SettingsContext context, SettingsProperty prop)
        {
            SettingsPropertyValue value = new SettingsPropertyValue(prop);
 
            // Only User-scoped settings can be found in the Registry.
            // By leaving the Application-scoped setting's value at null,
            // we get the "default" value
            if (IsUserScoped(prop))
            {
                using (RegistryKey key = CreateRegKey(context, prop))
                {
                    object regValue = key.GetValue(prop.Name);
                    if (prop.PropertyType == typeof(StringCollection) &&
                        regValue is string[] regValueStrings)
                    {
                        StringCollection stringCol = new StringCollection();
                        stringCol.AddRange(regValueStrings);
                        value.PropertyValue = stringCol;
                    }
                    else
                    {
                        value.SerializedValue = regValue;
                    }
                }
            }
 
            value.IsDirty = false;
            return value;
        }
 
        // Looks in the "attribute bag" for a given property to determine if it is app-scoped
        private bool IsApplicationScoped(SettingsProperty prop)
        {
            return HasSettingScope(prop, typeof(ApplicationScopedSettingAttribute));
        }
 
        // Looks in the "attribute bag" for a given property to determine if it is user-scoped
        private bool IsUserScoped(SettingsProperty prop)
        {
            return HasSettingScope(prop, typeof(UserScopedSettingAttribute));
        }
 
        // Checks for app or user-scoped based on the attributeType argument
        // Also checks for sanity, i.e. a setting not marked as both or neither scope
        // (just like the LFSP)
        private bool HasSettingScope(SettingsProperty prop, Type attributeType)
        {
            // NOTE: No current support for roaming
            Debug.Assert(attributeType == typeof(ApplicationScopedSettingAttribute) ||
                attributeType == typeof(UserScopedSettingAttribute));
            bool isAppScoped = prop.Attributes[typeof(ApplicationScopedSettingAttribute)] != null;
            bool isUserScoped = prop.Attributes[typeof(UserScopedSettingAttribute)] != null;
 
            // Check constraints
            if (isUserScoped && isAppScoped)
                throw new Exception("Can't mark a setting as User and Application-scoped: " + prop.Name);
            if (!isUserScoped && !isAppScoped)
                throw new Exception("Must mark a setting as User or Application-scoped: " + prop.Name);
 
            // Return scope check result
            if (attributeType == typeof(ApplicationScopedSettingAttribute))
                return isAppScoped;
            if (attributeType == typeof(UserScopedSettingAttribute))
                return isUserScoped;
 
            Debug.Assert(false);
            return false;
        }
 
        private bool HasRegKey(SettingsContext context)
        {
            RegistryKey key = Registry.CurrentUser.OpenSubKey($@"{SubKeyPath}\{GetSectionName(context)}", false);
            return key != null;
        }
 
        // Creates a sub-key under HKCU\Software\CompanyName\{GetSectionName(context)}
        private RegistryKey CreateRegKey(SettingsContext context, SettingsProperty prop)
        {
            Debug.Assert(!IsApplicationScoped(prop), "Can't get Registry key for a read-only Application scoped setting: " + prop.Name);
            return Registry.CurrentUser.CreateSubKey($@"{SubKeyPath}\{GetSectionName(context)}");
        }
 
        // From LocalFileSettingsProvider
        private string GetSectionName(SettingsContext context)
        {
            string groupName = (string)context["GroupName"];
            string key = (string)context["SettingsKey"];
 
            Debug.Assert(groupName != null, "SettingsContext did not have a GroupName!");
 
            string sectionName = groupName;
 
            if (!String.IsNullOrEmpty(key))
            {
                sectionName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", sectionName, key);
            }
 
            //return XmlConvert.EncodeLocalName(sectionName);
            return sectionName;
        }
 
        private SettingsPropertyValueCollection GetLocalFilePropertyValues(
            SettingsContext context, SettingsPropertyCollection properties)
        {
            LocalFileSettingsProvider localFile = new LocalFileSettingsProvider();
            localFile.Initialize(_initializedName, _initializedConfig);
            return localFile.GetPropertyValues(context, properties);
        }
    }
}