关于对象映射（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就已经非常够用了。

本人不才，还希望园内技术牛人多多指正。