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 =
            };
            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 == ) 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 == ) 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; }
     }
 }

注册表对象映射实现类