關於對象映射（Dto->model） 思路的一些想法

    最近粗淺的學習了下AutoMapper 這個做對象映射的第三方工具，覺得非常方便使用，所以簡單的總結了一下我能想到的簡單的對象映射的方式。

   占時先不考慮源對象成員到目標對象成員的指定映射（即成員名不一致），先准備好兩個類Students-StudentsDto；Teachers-TeachersDto

    public class Students
    {
        public int No { get; set; }
        public string Name { get; set; }
        public bool Gender { get; set; }
        public string Class { get; set; }

        public string _remark;
    }

    public class StudentsDto
    {
        public int No { get; set; }
        public string Name { get; set; }
        public bool Gender { get; set; }
        public string Class { get; set; }

        public string _remark;
    }

    public class Teachers
    {
        public int No { get; set; }

        public string Course { get; set; }

        public string Name { get; set; }
    }

    public class TeachersDto
    {
        public int No { get; set; }

        public string Course { get; set; }

        public string Name { get; set; }
    }

我們先使用普通的對象裝載方式：

StudentsDto studentsDto = new StudentsDto { No = 1, Name = "Epic", Gender = true, Class = "家里蹲一班", _remark = "逗比" };
TeachersDto teachersDto = new TeachersDto { No = 2, Name = "Eleven", Course = ".net" };
Students students = new Students
                    {
                        No = studentsDto.No,
                        Name = studentsDto.Name,
                        Gender = studentsDto.Gender,
                        Class = studentsDto.Class,
                        _remark = studentsDto._remark
                    };
 Teachers teachers = new Teachers
                    {
                        No = teachersDto.No,
                        Name = teachersDto.Name,
                        Course = teachersDto.Course
                    };

總結：其思路無非就是先new一個對象實例，然后將該實例的成員一一賦值。

1.通過反射的方式來實現對象映射，是我們最容易想到的方式，思路也很簡單

 

    public static TModel Trans<TModel, TModelDto>(TModelDto dto)
            where TModel : class
            where TModelDto : class
        {
            TModel model = Activator.CreateInstance(typeof(TModel)) as TModel;
            //獲取TModel的屬性集合
            PropertyInfo[] modlePropertys = typeof(TModel).GetProperties();
            //獲取TModelDto的屬性集合
            Type type = dto.GetType();
            PropertyInfo[] propertys = type.GetProperties();
            foreach (var property in propertys)
            {
                foreach (var mproperty in modlePropertys)
                {
                    //如果屬性名稱一致，則將該屬性值賦值到TModel實例中
                    //這里可以用Attribute來實現成員的自定義映射
                    if (property.Name.Equals(mproperty.Name))
                    {
                        mproperty.SetValue(model, property.GetValue(dto));
                        break;
                    }
                }
            }

            //獲取TModel的字段集合
            FieldInfo[] modelfieldInfos = typeof(TModel).GetFields();
            //獲取TModelDto的字段集合
            FieldInfo[] fieldInfos = type.GetFields();
            foreach (var field in fieldInfos)
            {
                foreach (var mfield in modelfieldInfos)
                {
                    //如果字段名稱一致，則將該字段值賦值到TModel實例中
                    if (field.Name.Equals(mfield.Name))
                    {
                        mfield.SetValue(model, field.GetValue(dto));
                        break;
                    }
                }
            }
            return model;
        }

總結：通過反射來創建對象實例，然后將實例成語的值通過反射的方式獲取並賦值。

2.通過序列號的方式，對象類型可以轉換成json字符串，然后再由json字符串轉換成所需的對象不就可以了么

public static TModel Trans<TModel, TModelDto>(TModelDto dto)
            where TModel : class
            where TModelDto : class
        {
            return JsonConvert.DeserializeObject<TModel>(JsonConvert.SerializeObject(dto));
        }

總結：通過序列號然后反序列化，這樣使用感覺並不是Newtonsoft.Json的初衷，不知道性能到底如何呢？

3.使用Expression表達式的方式來解決，將所需實例對象new、賦值的過程先寫入表達式，然后生成lambda表達式，最后編譯該表達式生成委托，invoke即可

   public static class ExpressionAndSeesionMethod

    {
        public static Dictionary<string, object> _dictionary = new Dictionary<string, object>();

        public static TModel Trans<TModel, TModelDto>(TModelDto dto)
        {
            Type modelType = typeof(TModel);
            Type modelDtoType = typeof(TModelDto);

            //如果_dictionary中不存在該key，則存進去
            string key = $"{modelDtoType.Name}-->{modelType.Name}";
            if (!_dictionary.ContainsKey(key))
            {
                //創建一個lambda參數x，定義的對象為TModelDto
                ParameterExpression parameterExpression = Expression.Parameter(modelDtoType, "x");
                //開始生成lambda表達式
                List<MemberBinding> list = new List<MemberBinding>();
                foreach (var item in modelType.GetProperties())
                {
                    //為x參數表達式生成一個屬性值
                    MemberExpression property = Expression.Property(parameterExpression, modelDtoType.GetProperty(item.Name));
                    //將該屬性初始化 eg:No=x.No
                    MemberBinding memberBinding = Expression.Bind(item, property);
                    list.Add(memberBinding);
                }

                foreach (var item in typeof(TModel).GetFields())
                {
                    //為x參數表達式生成一個字段值
                    MemberExpression field = Expression.Field(parameterExpression, modelDtoType.GetField(item.Name));
                    //將該字段初始化
                    MemberBinding memberBinding = Expression.Bind(item, field);
                    list.Add(memberBinding);
                }
                //調用構造函數，初始化一個TModel eg: new{No=x.No...}
                MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(modelType), list);
                //創建lambda表達式  eg: x=>new{ No=x.No...}
                Expression<Func<TModelDto, TModel>> lambda = Expression.Lambda<Func<TModelDto, TModel>>(memberInitExpression, parameterExpression);
                //將lambda表達式生成委托
                Func<TModelDto, TModel> func = lambda.Compile();
                _dictionary[key] = func;
            }
            return ((Func<TModelDto, TModel>)_dictionary[key]).Invoke(dto);
        }
    }

總結：使用表達式樹的方式，可以將生成的委托保存起來,這里使用dictionary字典，在需要使用的時候調用即可（一次生成委托，后續可多次使用）；既然是多個委托，那是不是可以使用的泛型委托Func<TIn,TResult>呢？

使用泛型緩存：

    /// <summary>
    ///泛型委托基於泛型類之上
    ///泛型靜態類在確定參數類型的時候會調用其靜態函數
    ///在執行委托時，泛型委托會內置查找相應的委托來執行
    /// </summary>
    public static class ExpressionAndFuncMethod<TModel, TModelDto>
       where TModel : class
       where TModelDto : class
    {
        static ExpressionAndFuncMethod()
        {
            ExpressionMapper();
        }

        public static Func<TModelDto, TModel> _func = null;

        public static void ExpressionMapper()
        {
            Type modelType = typeof(TModel);
            Type modelDtoType = typeof(TModelDto);

            //創建一個lambda參數x，定義的對象為TModelDto
            ParameterExpression parameterExpression = Expression.Parameter(modelDtoType, "x");
            //開始生成lambda表達式
            List<MemberBinding> list = new List<MemberBinding>();
            foreach (var item in modelType.GetProperties())
            {
                //為x參數表達式生成一個屬性值
                MemberExpression property = Expression.Property(parameterExpression, modelDtoType.GetProperty(item.Name));
                //將該屬性初始化 eg:No=x.No
                MemberBinding memberBinding = Expression.Bind(item, property);
                list.Add(memberBinding);
            }

            foreach (var item in typeof(TModel).GetFields())
            {
                //為x參數表達式生成一個字段值
                MemberExpression field = Expression.Field(parameterExpression, modelDtoType.GetField(item.Name));
                //將該字段初始化
                MemberBinding memberBinding = Expression.Bind(item, field);
                list.Add(memberBinding);
            }
            //調用構造函數，初始化一個TModel eg: new{No=x.No...}
            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(modelType), list);
            //創建lambda表達式  eg: x=>new{ No=x.No...}
            Expression<Func<TModelDto, TModel>> lambda = Expression.Lambda<Func<TModelDto, TModel>>(memberInitExpression, parameterExpression);
            //將lambda表達式生成委托
            _func = lambda.Compile();
        }

        public static TModel Trans(TModelDto dto)
        {
            if (_func != null)
                return _func(dto);
            return default(TModel);
        }
    }

總結：使用泛型委托時，即用到了其泛型緩存，在調用指定參數的委托時，能快速查找並調用（這個性能應該是高於使用字典的查找）

4.使用AutoMapper

    public static class AutoMapperMethod
    {
        /// <summary>
        /// AutoMapper 必須先創建映射
        /// </summary>
        /// <param name="dictionary"></param>
        public static void Init(Dictionary<Type, Type> dictionary)
        {
            AutoMapper.Mapper.Initialize(x =>
            {
                foreach (var item in dictionary)
                {
                    x.CreateMap(item.Key, item.Value);
                }
            });
        }


        public static TModel Trans<TModel, TModelDto>(TModelDto dto)
                           where TModel : class
       where TModelDto : class
        {
            return AutoMapper.Mapper.Map<TModelDto, TModel>(dto);
        }
    }

總結：AutoMapper先創建再調用的原則，非常適合core項目的 注冊-調用 思想，在Configure中進行注冊，然后使用時Map即可，AutoMap使用emit代碼開發（不太明白），性能很好，是現在最流行的映射工具。

最后，來看一下以上幾種方式的性能對比吧，測試條件是將StudentsDto實例轉換成Students實例，將TeachersDto實例轉換成Teachers實例，各轉換50萬次，耗時如下圖：

從上往下依次是：普通類型裝載、反射、序列化、表達式緩存、表達式泛型緩存、AutoMapper 

由此可見，反射和序列化是比較慢的，表達式和AutoMapper的表現差不多，一般項目中，類型映射的次數也不會很大，使用AutoMapper就已經非常夠用了。

本人不才，還希望園內技術牛人多多指正。