关于C#中对象和字典间相互转换的说明

一、对象转换为字典：

/// <summary>
/// 转换对象为字典
/// </summary>
/// <param name="obj">要转换的对象</param>
/// <param name="members">需要转换的成员</param>
/// <param name="ignoreMembers">忽略转换的成员</param>
/// <returns>返回字典</returns>
public virtual Dictionary<string, object> ConvertDictionary(object obj, string[] members, string[] ignoreMembers)
{
    // 创建目标字典
    Dictionary<string, object> dictionary = new Dictionary<string, object>();
    // 获取对象类型
    Type type = obj.GetType();
    // 获取成员字段
    FieldInfo[] fieldInfos = type.GetFields();
    // 遍历成员字段，添加要转换的成员字段到字典中
    foreach (FieldInfo fieldInfo in fieldInfos)
    {
        // 获取当前字段名
        string name = fieldInfo.Name;
        // 判断当前字段是否需要转换
        if ((members == null || members.Length <= 0 || members.Contains("*") || members.Contains(name)) && (ignoreMembers == null || ignoreMembers.Length <= 0 || (!ignoreMembers.Contains("*") && !ignoreMembers.Contains(name))))
        {
            // 判断当前字段是否是公开的
            if (fieldInfo.IsPublic)
            {
                // 判断当前字段是否是静态的
                if (fieldInfo.IsStatic)
                {
                    // 获取成员字段的静态值并设置到字典中
                    dictionary[name] = fieldInfo.GetValue(null);
                }
                else
                {
                    // 获取成员字段的实例值并设置到字典中
                    dictionary[name] = fieldInfo.GetValue(obj);
                }
            }
        }
    }
    // 获取成员属性
    PropertyInfo[] propertyInfos = type.GetProperties();
    // 遍历成员属性，添加要转换的成员属性到字典中
    foreach (PropertyInfo propertyInfo in propertyInfos)
    {
        // 获取当前属性名
        string name = propertyInfo.Name;
        // 判断当前属性是否需要转换
        if ((members == null || members.Length <= 0 || members.Contains("*") || members.Contains(name)) && (ignoreMembers == null || ignoreMembers.Length <= 0 || (!ignoreMembers.Contains("*") && !ignoreMembers.Contains(name))))
        {
            // 判断当前属性是否可读的并且是简单的类型
            if (propertyInfo.CanRead)
            {
                // 获取当前属性的GET访问器
                MethodInfo methodInfo = propertyInfo.GetGetMethod();
                // 判断当前属性的GET访问器是否是公开的
                if (methodInfo.IsPublic)
                {
                    // 判断当前属性的GET访问器是否是静态的
                    if (methodInfo.IsStatic)
                    {
                        // 获取成员属性的静态值并设置到字典中
                        dictionary[name] = propertyInfo.GetValue(null, null);
                    }
                    else
                    {
                        // 获取成员属性的实例值并设置到字典中
                        dictionary[name] = propertyInfo.GetValue(obj, null);
                    }
                }
            }
        }
    }
    // 返回字典
    return dictionary;
}

二、字典转换为对象：

/// <summary>
/// 转换字典为对象
/// </summary>
/// <param name="type">对象类型</param>
/// <param name="dictionary">要转换的字典</param>
/// <param name="members">需要转换的成员</param>
/// <param name="ignoreMembers">忽略转换的成员</param>
/// <returns>返回对象</returns>
public virtual object ConvertDictionary(Type type, Dictionary<string, object> dictionary, string[] members, string[] ignoreMembers)
{
    // 创建目标对象
    object obj = Activator.CreateInstance(type);
    // 遍历字典，添加要转换的数据到对象成员中
    foreach (KeyValuePair<string, object> item in dictionary)
    {
        // 获取成员名称
        string name = item.Key;
        // 判断当前成员是否需要转换
        if ((members == null || members.Length <= 0 || members.Contains("*") || members.Contains(name)) && (ignoreMembers == null || ignoreMembers.Length <= 0 || (!ignoreMembers.Contains("*") && !ignoreMembers.Contains(name))))
        {
            // 获取当前成员名称对应的数据
            object value = item.Value;
            // 根据当前成员名称获取成员属性
            PropertyInfo propertyInfo = type.GetProperty(name);
            // 判断是否有对应名称的成员属性
            if (propertyInfo == null)
            {
                // 根据当前列名获取成员字段
                FieldInfo fieldInfo = type.GetField(name);
                // 判断成员字段是否存在并且是否是公开可写的
                if (fieldInfo != null && fieldInfo.IsPublic && !fieldInfo.IsLiteral && !fieldInfo.IsInitOnly)
                {
                    // 根据成员字段类型转换数据类型
                    value = this.ConvertType(value, fieldInfo.FieldType);
                    // 判断数据转换是否成功
                    if (value != null)
                    {
                        // 判断成员字段是否是静态的
                        if (fieldInfo.IsStatic)
                        {
                            // 设置成员字段的静态值
                            fieldInfo.SetValue(null, value);
                        }
                        else
                        {
                            // 设置成员字段的实例值
                            fieldInfo.SetValue(obj, value);
                        }
                    }
                }
            }
            else
            {
                // 判断成员属性是否可写
                if (propertyInfo.CanWrite)
                {
                    // 获取成员属性的SET访问器
                    MethodInfo methodInfo = propertyInfo.GetSetMethod();
                    // 判断成员属性的SET访问器是否是公开的
                    if (methodInfo.IsPublic)
                    {
                        // 根据成员属性类型转换数据类型
                        value = this.ConvertType(value, propertyInfo.PropertyType);
                        // 判断数据转换是否成功
                        if (value != null)
                        {
                            // 判断成员属性的SET访问器是否是静态的
                            if (methodInfo.IsStatic)
                            {
                                // 设置成员属性的静态值
                                propertyInfo.SetValue(null, value, null);
                            }
                            else
                            {
                                // 设置成员属性的实例值
                                propertyInfo.SetValue(obj, value, null);
                            }
                        }
                    }
                }
            }
        }
    }
    // 返回目标对象
    return obj;
}