c#注册表对象映射

用于快捷保存与读取注册表，为对应的对象

示例

        [RegistryRoot(Name = "superAcxxxxx")]
        public class Abc : IRegistry
        {
            public string Name { get; set; }

            public int Age { get; set; }
        }

保存

            Abc a = new Abc
            {
                Name = "mokeyish",
                Age = 100
            };
            RegistryKey register = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, Environment.Is64BitOperatingSystem
                ? RegistryView.Registry64
                : RegistryView.Registry32);

            RegistryKey writeKey=register.CreateSubKey("SOFTWARE");
            if (writeKey != null)
            {
                a.Save(writeKey);
                writeKey.Dispose();
            }
            register.Dispose();

读取

            Abc a=new Abc();
            RegistryKey register = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, Environment.Is64BitOperatingSystem
                ? RegistryView.Registry64
                : RegistryView.Registry32);

            RegistryKey writeKey=register.OpenSubKey("SOFTWARE");
            if (writeKey != null)
            {
                a.Read(writeKey);

                writeKey.Dispose();
            }
            register.Dispose();

该类实现比较完善，首先使用单例模式，再加上应用程序域的退出保存策略。这样可以保存该类可以在程序退出的时候将值保存到注册表

#region summary
//   ------------------------------------------------------------------------------------------------
//   <copyright file="ApplicationInfo.cs" company="bda">
//     用户：mokeyish
//     日期：2016/10/20
//     时间：16:52
//   </copyright>
//   ------------------------------------------------------------------------------------------------
#endregion

using System;
using Microsoft.Win32;

namespace RegistryHelp
{
    /// <summary>
    /// 应用程序信息
    /// </summary>
    [RegistryRoot(Name = "RegistryHelp")]
    public class ApplicationInfo:IRegistry
    {
        [RegistryMember(Name = "Path")]
        private string _path;

        [RegistryMember(Name = "Server")]
        private readonly string _server;

        [RegistryMember(Name = "Descirption")]
        private string _descirption;

        private bool _isChanged;

        /// <summary>
        /// 获取应用程序信息单例
        /// </summary>
        public static readonly ApplicationInfo Instance = new ApplicationInfo();

        private ApplicationInfo()
        {
            this._path = AppDomain.CurrentDomain.BaseDirectory;
            this._server = string.Empty;
            AppDomain.CurrentDomain.ProcessExit += this.CurrentDomain_ProcessExit;
            this._descirption = "注册表描述";
            this._isChanged = !this.Read();
            this._isChanged = !this.Save();
        }

        private void CurrentDomain_ProcessExit(object sender, EventArgs e)
        {
            this.Save();
        }

        /// <summary>
        /// 应用程序目录
        /// </summary>
        public string Path
        {
            get { return this._path; }
            set
            {
                if (this._path==value)return;
                this._isChanged = true;
                this._path = value;
            }
        }
        

        /// <summary>
        /// 服务器地址
        /// </summary>
        public string Server => this._server;

        /// <summary>
        /// 描述
        /// </summary>
        public string Descirption
        {
            get { return this._descirption; }
            set
            {
                if (this._descirption == value) return;
                this._isChanged = true;
                this._descirption = value;
            }
        }

        private bool Read()
        {
            RegistryKey registry = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, Environment.Is64BitOperatingSystem
                ? RegistryView.Registry64
                : RegistryView.Registry32);
            using (registry)
            {
                RegistryKey baseKey = registry.OpenSubKey("SOFTWARE");
                using (baseKey) return this.Read(baseKey);
            }
        }

        private bool Save()
        {
            if (!this._isChanged) return false;
            RegistryKey registry = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, Environment.Is64BitOperatingSystem
                ? RegistryView.Registry64
                : RegistryView.Registry32);
            using (registry)
            {
                RegistryKey baseKey = registry.CreateSubKey("SOFTWARE");
                using (baseKey) return this.Save(baseKey);
            }
        }
    }
}

#region summary

//   ------------------------------------------------------------------------------------------------
//   <copyright file="IRegistry.cs" company="bda">
//     用户：mokeyish
//     日期：2016/10/15
//     时间：13:26
//   </copyright>
//   ------------------------------------------------------------------------------------------------

#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Microsoft.Win32;

namespace RegistryHelp
{
    /// <summary>
    /// 可用于注册表快捷保存读取的接口
    /// </summary>
    public interface IRegistry
    {
    }

    /// <summary>
    /// RegistryExitensionMethods
    /// </summary>
    public static class RegistryExitensionMethods
    {
        private static readonly Type IgnoreAttribute = typeof(RegistryIgnoreAttribute);
        private static readonly Type MemberAttribute = typeof(RegistryMemberAttribute);
        private static readonly Type RegistryInterface = typeof(IRegistry);

        /// <summary>
        /// 读取注册表
        /// </summary>
        /// <param name="rootKey"></param>
        /// <param name="registry"></param>
        /// <param name="name"></param>
        /// <exception cref="ArgumentNullException">registry is null</exception>
        /// <exception cref="Exception">Member type is same with class type.</exception>
        public static bool Read(this RegistryKey rootKey, IRegistry registry, string name = null)
        {
            if (registry == null) throw new ArgumentNullException(nameof(registry));

            rootKey = rootKey?.OpenSubKey(name ?? registry.GetRegistryRootName());

            if (rootKey == null) return false;

            bool flag = true;
            using (rootKey)
            {
                Tuple<PropertyInfo[], FieldInfo[]> members = registry.GetMembers();

                if (members.Item1.Length + members.Item2.Length == 0) return false;

                foreach (PropertyInfo property in members.Item1)
                {
                    string registryName = property.GetRegistryName();
                    object value;
                    if (RegistryInterface.IsAssignableFrom(property.PropertyType))
                    {
                        if (property.PropertyType == registry.GetType())
                        {
                            throw new Exception("Member type is same with Class type.");
                        }

                        object oldvalue = property.GetValue(registry, null);
                        value = oldvalue ?? Activator.CreateInstance(property.PropertyType);
                        if (!rootKey.Read((IRegistry) value, registryName)) value = null;
                    }
                    else
                    {
                        value = rootKey.GetValue(registryName);
                    }

                    if (value != null)
                    {
                        property.SetValue(registry, ChangeType(value, property.PropertyType), null);
                    }
                    else
                    {
                        flag = false;
                    }
                }

                foreach (FieldInfo fieldInfo in members.Item2)
                {
                    string registryName = fieldInfo.GetRegistryName();
                    object value;
                    if (RegistryInterface.IsAssignableFrom(fieldInfo.FieldType))
                    {
                        if (fieldInfo.FieldType == registry.GetType())
                        {
                            throw new Exception("Member type is same with Class type.");
                        }

                        value = fieldInfo.GetValue(registry) ?? Activator.CreateInstance(fieldInfo.FieldType);
                        rootKey.Read((IRegistry) value, registryName);
                    }
                    else
                    {
                        value = rootKey.GetValue(registryName);
                    }

                    if (value != null)
                    {
                        fieldInfo.SetValue(registry, ChangeType(value, fieldInfo.FieldType));
                    }
                    else
                    {
                        flag = false;
                    }
                }
            }
            return flag;
        }

        /// <summary>
        /// 保存到注册表
        /// </summary>
        /// <param name="rootKey"></param>
        /// <param name="registry"></param>
        /// <param name="name"></param>
        /// <exception cref="ArgumentNullException">registry is null</exception>
        /// <exception cref="Exception">Member type is same with Class type.</exception>
        public static bool Save(this RegistryKey rootKey, IRegistry registry, string name = null)
        {
            if (registry == null) throw new ArgumentNullException(nameof(registry));

            rootKey = rootKey?.CreateSubKey(name ?? registry.GetRegistryRootName());

            if (rootKey == null) return false;

            using (rootKey)
            {
                Tuple<PropertyInfo[], FieldInfo[]> members = registry.GetMembers();

                if (members.Item1.Length + members.Item2.Length == 0) return false;

                foreach (PropertyInfo property in members.Item1)
                {
                    string registryName = property.GetRegistryName();
                    object value = property.GetValue(registry, null);
                    if (RegistryInterface.IsAssignableFrom(property.PropertyType))
                    {
                        if (property.PropertyType == registry.GetType())
                        {
                            throw new Exception("Member type is same with Class type.");
                        }

                        if (value != null) rootKey.Save((IRegistry) value, registryName);
                    }
                    else
                    {
                        value = ChangeType(value, TypeCode.String);
                        if (value != null) rootKey.SetValue(registryName, value, RegistryValueKind.String);
                    }

                }

                foreach (FieldInfo fieldInfo in members.Item2)
                {
                    string registryName = fieldInfo.GetRegistryName();
                    object value = fieldInfo.GetValue(registry);
                    if (RegistryInterface.IsAssignableFrom(fieldInfo.FieldType))
                    {
                        if (fieldInfo.FieldType == registry.GetType())
                        {
                            throw new Exception("Member type is same with Class type.");
                        }

                        if (value != null) rootKey.Save((IRegistry) value, registryName);
                    }
                    else
                    {
                        value = ChangeType(value, TypeCode.String);
                        if (value != null) rootKey.SetValue(registryName, value, RegistryValueKind.String);
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// 读取注册表
        /// </summary>
        /// <param name="registry"></param>
        /// <param name="rootKey"></param>
        /// <param name="name"></param>
        /// <exception cref="ArgumentNullException">registry is null</exception>
        /// <exception cref="Exception">Member type is same with class type.</exception>
        public static bool Read(this IRegistry registry, RegistryKey rootKey, string name = null)
        {
            return rootKey.Read(registry, name);
        }

        /// <summary>
        /// 保存到注册表
        /// </summary>
        /// <param name="registry"></param>
        /// <param name="rootKey"></param>
        /// <param name="name"></param>
        /// <exception cref="ArgumentNullException">registry is null</exception>
        /// <exception cref="Exception">Member type is same with class type.</exception>
        public static bool Save(this IRegistry registry, RegistryKey rootKey, string name = null)
        {
            return rootKey.Save(registry, name);
        }

        private static object ChangeType(object value, Type conversionType)
        {
            try
            {
                if (conversionType == RegistryInterface)
                {
                    return value;
                }

                if (conversionType == typeof(Guid))
                {
                    return new Guid((string) value);
                }

                if (conversionType.IsEnum)
                {
                    return Enum.Parse(conversionType, (string) value);
                }

                return Convert.ChangeType(value, conversionType);

            }
            catch (Exception)
            {
                return null;
            }
        }

        private static object ChangeType(object value, TypeCode typeCode)
        {
            try
            {

                if (value is IConvertible) return Convert.ChangeType(value, typeCode);
                return value.ToString();
            }
            catch (Exception)
            {
                return null;
            }
        }

        private static bool IsDefinedRegistryAttribute(this MemberInfo memberInfo)
        {
            return memberInfo.IsDefined(IgnoreAttribute, false) || memberInfo.IsDefined(MemberAttribute, false);
        }

        private static string GetRegistryRootName(this IRegistry registry)
        {
            Type rootType = registry.GetType();
            return rootType.IsDefined(typeof(RegistryRootAttribute), false)
                ? rootType.GetCustomAttribute<RegistryRootAttribute>().Name
                : rootType.Name;
        }

        private static string GetRegistryName(this MemberInfo memberInfo)
        {
            return memberInfo.IsDefined(MemberAttribute, false)
                ? memberInfo.GetCustomAttribute<RegistryMemberAttribute>().Name
                : memberInfo.Name;
        }

        private static Tuple<PropertyInfo[], FieldInfo[]> GetMembers(this IRegistry registry)
        {
            if (registry == null) throw new ArgumentNullException(nameof(registry));
            Type t = registry.GetType();

            IList<MemberInfo> lst =
                t.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static |
                             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField |
                             BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty).ToList();


            bool isDefinedAttribute = lst.Any(i => i.IsDefinedRegistryAttribute());
            if (isDefinedAttribute)
            {
                lst = lst.Where(i => i.IsDefinedRegistryAttribute()).ToList();
            }
            return isDefinedAttribute
                ? new Tuple<PropertyInfo[], FieldInfo[]>(lst.OfType<PropertyInfo>().ToArray(),
                    lst.OfType<FieldInfo>().ToArray())
                : new Tuple<PropertyInfo[], FieldInfo[]>(t.GetProperties(), t.GetFields());
        }

        /// <summary>
        /// The get custom attribute.
        /// </summary>
        /// <param name="element">
        /// The element.
        /// </param>
        /// <typeparam name="T">Attribute type
        /// </typeparam>
        /// <returns>
        /// The custom attribute
        /// </returns>
        private static T GetCustomAttribute<T>(this MemberInfo element) where T : Attribute
        {
            return (T)Attribute.GetCustomAttribute(element, typeof(T));
        }
    }
    
    /// <summary>
    /// RegistryRootAttribute:用于描述注册表对象类
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    public class RegistryRootAttribute : Attribute
    {
        /// <summary>
        /// Name
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Value
        /// </summary>
        public string Value { get; set; }
    }
    
    /// <summary>
    /// RegistryIgnoreAttribute:忽略注册表成员,使用了该特性，将忽略未定义RegistryMemberAttribute的成员
    /// </summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    public class RegistryIgnoreAttribute : Attribute { }

    /// <summary>
    /// RegistryMemberAttribute：用于描述注册表成员,使用了该特性，将忽略未定义RegistryMemberAttribute的成员
    /// </summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    public class RegistryMemberAttribute : Attribute
    {
        /// <summary>
        /// Name
        /// </summary>
        public string Name { get; set; }
    }
}