• 经典面试题之——如何自由转换两个没有继承关系的字段及类型相同的实体模型,AutoMapper?


    相信很多童鞋们都被问到过这个问题,不管是在面试的时候被问过,还是笔试题里考过,甚至有些童鞋们找我要学习资料的时候我也考过这个问题,包括博主我自己,也曾被问过,而且博主现在有时作为公司的面试官,也喜欢问应试者这样的问题。

    这确实是一道基础题,不管是在java里面还是在C#里面,都属于一道非常基础的题,但很多童鞋竟然说没遇到过这样的场景,或者说学习基础的时候没重视过,所以自然不会了,那行,今天博主在这里就针对这个问题,做出详细的解释并由这个问题,同时,也给大家做个扩展学习吧。

    在实际的项目当中,这是个非常非常需要的,我们经常需要在不同用途的实体之间相互转换进行数据传输,最典型的当然就是Entity和DTO之间的相互转换咯(不懂什么是DTO的自己去科普下,或者在这儿你看成是ViewModel也行,这无所谓)。当然,开这篇文章肯定不是只讲简简单单反射这么简单,那我写这篇文章可能有点大动干戈了,所以,你们赚了,除了讲反射,自然也就引出了各种创建对象的效率问题,以及除了反射还有哪些方式可以转换实体。

    首先说一下,我听到的最多的答案,就是:

    1. new一个目标实体出来,然后把对应字段的值赋值上就好了

    2. 通过反射获取对象的属性,然后挨个循环属性,把对应属性名赋值到另一个对象里面

    3. 使用AutoMapper完成不同实体的转换。

    上面这几个答案都是对的,只是答案1的童鞋钻漏子勉强回答对了,而答案2的通用性比较高了,答案3的就是拿来主义,有现成的直接用就好了,底层怎么实现的不知道…。可能有些童鞋以前答不上来的时候看到这些答案就恍然大悟了,而有的童鞋可能还是有点懵,这样的话确实应该回头再学一遍基础了。好吧,来点实际的吧。

    那就从上面三个答案开始吧。

    先准备两个实体吧:

        public class Person

        {

            public string Name { get; set; }

            public int Age { get; set; }

        }

        public class PersonDto

        {

            public string Name { get; set; }

            public int Age { get; set; }

        }

     

    1. 硬编码实现实体的相互转换

    最简单粗暴的方法也就是这样的咯,但如果面试这样回答,基本上不会加分。

    Person p = new Person()

    {

        Age = 10,

        Name = "张三"

    };

    PersonDto pd = new PersonDto()

    {

        Name = p.Name,

        Age = p.Age

    };

    这样做,也不是不可以,毕竟效率是最高的,但是,通用性不强,如果要转换其他实体,每个都必须重新手写,不可复用,如果一个实体属性达到了几十上百个呢?这样写你不嫌手累嘛,看上去也不优雅是不。那下面这个,看上去稍微优雅点的:

     

    2. 委托实现实体的相互转换

    相比之上,稍微优雅了一点点,但,还是硬编码,面试这样回答的可能会加分;

    Person p = new Person()

    {

        Age = 10,

        Name = "张三"

    };

    Func<Person, PersonDto> func = c => new PersonDto()

    {

        Age = c.Age,

        Name = c.Name

    };

    PersonDto pd = func(p);

    这里直接写了个Func类型的委托,在委托里面硬编码给DTO实体的字段挨个赋值,看上去稍微优雅点了,毕竟用上了委托,哈哈……

    那好,又优雅又不是硬编码的来了。

     

    3. 使用AutoMapper完成不同实体的转换

    当然,这拿来主义在实际项目中确实也用得非常多,包括博主我自己,在项目中也是用AutoMapper居多,毕竟人家实体转换效率还是蛮高的,面试中可能会加分。

    Person p = new Person() { Age = 10, Name = "张三" };

    Mapper.Initialize(m => m.CreateMap<Person, PersonDto>());

    PersonDto pd = Mapper.Map<PersonDto>(p);

    这代码,看上去确实很简单就完成了,拿来主义嘛,那要是就不准让你用AutoMapper,又要达到它这样的高性能,你咋办?!那好,后面有终极武器,比AutoMapper的转换效率更高效,所以看到这篇文章的童鞋们,你们赚大了!

     

    4. 通过反射实现实体的相互转换

    可能这样回答的人基础都是比较好的了,面试都会加分的。

    首先准备一个方法,专门对实体进行映射:

    /// <summary>

    /// 实体映射

    /// </summary>

    /// <typeparam name="TDestination">目标实体</typeparam>

    /// <param name="source">源实体</param>

    /// <returns></returns>

    public static TDestination MapTo<TDestination>(object source) where TDestination : new()

    {

        TDestination dest = new TDestination();//创建目标实体对象

        foreach (var p in dest.GetType().GetProperties())//获取源实体所有的属性

        {

            p.SetValue(dest, source.GetType().GetProperty(p.Name)?.GetValue(source));//挨个为目标实体对应字段名进行赋值

        }

        return dest;

    }

    然后在需要进行实体转换的地方直接调这个方法就OK了;

    Person p = new Person() { Age = 10, Name = "张三" };

    PersonDto pd = MapTo<PersonDto>(p);

    很好,这很优雅,但是,博主我觉得,还不够优雅,毕竟,可能好多人没看懂?

    那好,来个更简单更直接的办法:反序列化进行实体转换;

     

    5. 通过Json反序列化实现实体的相互转换

    到这儿为止,很多童鞋就想不到了,实体转换还能通过json来进行;确实可以的,这也方便,而且还自带支持多成实体的映射转换,比如实体里面还包含List这样的数据结构;一句话就能搞定实体映射,不信你看:

    首先通过nuget把Newtonsoft.Json引进来,然后coding...

    Person p = new Person() { Age = 10, Name = "张三" };

    PersonDto pd = JsonConvert.DeserializeObject<PersonDto>(JsonConvert.SerializeObject(p));

    卧槽,居然这就搞定了,还能这么优雅?!那你试试吧。

    上面这几种方式都是经常用到的,但是,当你进行超大批量的实体转换时,你会发现,反射和反序列化的方式出现瓶颈了,那有没有办法来优化呢,肯定有啊,不能优化的话那怎么去支撑千万级数据?!那你想到的是什么?表达式树?emit?

    既然反射效率那么低,那是不是就不能用反射了?还是离不开反射,前方带你弯道超车,还请各位站稳扶好!

    如果你在面试当中用到了下面这几种方式,那么,可能面试官都会膜拜你了,最后的可能,就是你选公司而不是公司选你了,哈哈…,当然,可能有点夸大其词,毕竟面试你的也不是什么技术菜鸟,至少会给你的面试大大加分!

     

    6. 表达式树实现实体的相互转换

    来吧,拼接表达式,走起!

    Person p = new Person() { Age = 10, Name = "张三" };

    ParameterExpression parameterExpression = Expression.Parameter(typeof(Person), "p");

    List<MemberBinding> memberBindingList = new List<MemberBinding>();//表示绑定的类派生自的基类,这些绑定用于对新创建对象的成员进行初始化(vs的注解。太生涩了,我这样的小白解释不了,大家将就着看)

    foreach (var item in typeof(PersonDto).GetProperties()) //遍历目标类型的所有属性

    {

        MemberExpression property = Expression.Property(parameterExpression, typeof(Person).GetProperty(item.Name));//获取到对应的属性

        MemberBinding memberBinding = Expression.Bind(item, property);//初始化这个属性

        memberBindingList.Add(memberBinding);

    }

    foreach (var item in typeof(PersonDto).GetFields())//遍历目标类型的所有字段

    {

        MemberExpression property = Expression.Field(parameterExpression, typeof(Person).GetField(item.Name));//获取到对应的字段

        MemberBinding memberBinding = Expression.Bind(item, property);//同上

        memberBindingList.Add(memberBinding);

    }

    MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(PersonDto)), memberBindingList.ToArray());//初始化创建新对象

    Expression<Func<Person, PersonDto>> lambda = Expression.Lambda<Func<Person, PersonDto>>(memberInitExpression, parameterExpression);

    PersonDto pd = lambda.Compile()(p);

    卧槽,看起来好复杂,不明觉厉啊!那,自己慢慢摸索下吧,都说了要站稳扶好的,这就不怪老司机了哈!

    结果如上图所示,但是问题又来了,我们不可能只有一个类,也不可能只有一个Dto,那我们应该怎么实现呢? 对 ,可以用泛型来实现。

    但是,博主我觉得还不够,每次转换还得写这么一大坨看不懂的东西,封装一下岂不更好用?那好,开始封装吧;

     

    7. 表达式树的封装实现通用实体的相互转换

    public static TDestination ExpressionTreeMapper<TSource, TDestination>(TSource source)

    {

        ParameterExpression parameterExpression = Expression.Parameter(typeof(TSource), "p");

        List<MemberBinding> memberBindingList = new List<MemberBinding>();//表示绑定的类派生自的基类,这些绑定用于对新创建对象的成员进行初始化(vs的注解。太生涩了,我这样的小白解释不了,大家将就着看)

        foreach (var item in typeof(TDestination).GetProperties()) //遍历目标类型的所有属性

        {

            MemberExpression property = Expression.Property(parameterExpression, typeof(TSource).GetProperty(item.Name));//获取到对应的属性

            MemberBinding memberBinding = Expression.Bind(item, property);//初始化这个属性

            memberBindingList.Add(memberBinding);

        }

        foreach (var item in typeof(TDestination).GetFields())//遍历目标类型的所有字段

        {

            MemberExpression property = Expression.Field(parameterExpression, typeof(TSource).GetField(item.Name));//获取到对应的字段

            MemberBinding memberBinding = Expression.Bind(item, property);//同上

            memberBindingList.Add(memberBinding);

        }

        MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TDestination)), memberBindingList.ToArray());//初始化创建新对象

        Expression<Func<TSource, TDestination>> lambda = Expression.Lambda<Func<TSource, TDestination>>(memberInitExpression, parameterExpression);

        return lambda.Compile()(source); //拼装是一次性的

    }

    封装之后,调用倒是方便了,但我觉得没区别,封装之后每次调用这个方法不也得走一遍编译表达式树的过程,这个过程岂不多余了?这个过程性能瓶颈很大。

    那好,能不能把编译之后的表达式树缓存起来?答案是肯定可以的,继续优化,走起;

     

    8. 表达式树缓存实现通用实体的相互转换

    实现思路:把每次编译后的表达式树缓存起来,如果存在,直接拿现成的编译好的表达式树调用就好了

    /// <summary>

    /// 生成表达式目录树。字典缓存

    /// </summary>

    public class ExpressionMapper

    {

        private static Dictionary<string, object> _dic = new Dictionary<string, object>();//缓存字典,缓存后的就是硬编码所以性能高。

        /// <summary>

        /// 字典缓存表达式树

        /// </summary>

        /// <typeparam name="TSource"></typeparam>

        /// <typeparam name="TDestination"></typeparam>

        /// <param name="source"></param>

        /// <returns></returns>

        public static TDestination Map<TSource, TDestination>(TSource source)

        {

            string key = $"funckey_{typeof(TSource).FullName}_{typeof(TDestination).FullName}";

            if (!_dic.ContainsKey(key)) //如果该表达式不存在,则走一遍编译过程

            {

                ParameterExpression parameterExpression = Expression.Parameter(typeof(TSource), "p");

                List<MemberBinding> memberBindingList = new List<MemberBinding>();//表示绑定的类派生自的基类,这些绑定用于对新创建对象的成员进行初始化(vs的注解。太生涩了,我这样的小白解释不了,大家将就着看)

                foreach (var item in typeof(TDestination).GetProperties()) //遍历目标类型的所有属性

                {

                    MemberExpression property = Expression.Property(parameterExpression, typeof(TSource).GetProperty(item.Name));//获取到对应的属性

                    MemberBinding memberBinding = Expression.Bind(item, property);//初始化这个属性

                    memberBindingList.Add(memberBinding);

                }

                foreach (var item in typeof(TDestination).GetFields())//遍历目标类型的所有字段

                {

                    MemberExpression property = Expression.Field(parameterExpression, typeof(TSource).GetField(item.Name));//获取到对应的字段

                    MemberBinding memberBinding = Expression.Bind(item, property);//同上

                    memberBindingList.Add(memberBinding);

                }

                MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TDestination)), memberBindingList.ToArray());//初始化创建新对象

                Expression<Func<TSource, TDestination>> lambda = Expression.Lambda<Func<TSource, TDestination>>(memberInitExpression, parameterExpression);

                _dic[key] = lambda.Compile(); //拼装是一次性的

            }

            return ((Func<TSource, TDestination>)_dic[key]).Invoke(source);

        }

    }

    恩,这样缓存起来,再执行重复类型的转换,就直接取缓存好的表达式树进行调用了,性能貌似提升了,非常棒!但博主我认为,这还有优化的余地,既然有了缓存,那我干脆直接把泛型搬到整个类上面,进行缓存起来,好的,走起;

     

    9. 表达式树泛型缓存实现通用实体的相互转换

    /// <summary>

    /// 生成表达式目录树  泛型缓存

    /// </summary>

    public class ExpressionGenericMapper

    {

        private static object func;

        public static TDestination Map<TSource, TDestination>(TSource source)

        {

            if (func is null)//如果表达式不存在,则走一遍编译过程

            {

                ParameterExpression parameterExpression = Expression.Parameter(typeof(TSource), "p");

                var memberBindingList = new List<MemberBinding>();//表示绑定的类派生自的基类,这些绑定用于对新创建对象的成员进行初始化(vs的注解。太生涩了,我这样的小白解释不了,大家将就着看)

                foreach (var item in typeof(TDestination).GetProperties()) //遍历目标类型的所有属性

                {

                    MemberExpression property = Expression.Property(parameterExpression, typeof(TSource).GetProperty(item.Name));//获取到对应的属性

                    MemberBinding memberBinding = Expression.Bind(item, property);//初始化这个属性

                    memberBindingList.Add(memberBinding);

                }

                foreach (var item in typeof(TDestination).GetFields())

                {

                    MemberExpression property = Expression.Field(parameterExpression, typeof(TSource).GetField(item.Name));//获取到对应的字段

                    MemberBinding memberBinding = Expression.Bind(item, property);//同上

                    memberBindingList.Add(memberBinding);

                }

                MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TDestination)), memberBindingList.ToArray());//初始化创建新对象

                Expression<Func<TSource, TDestination>> lambda = Expression.Lambda<Func<TSource, TDestination>>(memberInitExpression, parameterExpression);

                func = lambda.Compile();

            }

            return ((Func<TSource, TDestination>)func)(source); //拼装是一次性的

        }

    }

     

    10. 最后,来个性能测试吧

    我们挨个用这些方法,都循环映射1,000,000次,看谁跑得最快!

    单线程测试代码:

    static void Main(string[] args)

    {

        Person p = new Person() { Age = 10, Name = "张三" };

        Stopwatch sw = new Stopwatch();

        sw.Start();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = new PersonDto() { Name = p.Name, Age = p.Age };

        }

        sw.Stop();

        Console.WriteLine($"使用硬编码映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        Func<Person, PersonDto> func = c => new PersonDto()

        {

            Age = c.Age,

            Name = c.Name

        };

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = func(p);

        }

        sw.Stop();

        Console.WriteLine($"使用委托映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Mapper.Initialize(m => m.CreateMap<Person, PersonDto>());

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = Mapper.Map<PersonDto>(p);

        }

        sw.Stop();

        Console.WriteLine($"使用AutoMapper映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = MapTo<PersonDto>(p);

        }

        sw.Stop();

        Console.WriteLine($"使用反射映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = JsonConvert.DeserializeObject<PersonDto>(JsonConvert.SerializeObject(p));

        }

        sw.Stop();

        Console.WriteLine($"使用Json反序列化映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = ExpressionTreeMapper<Person, PersonDto>(p);

        }

        sw.Stop();

        Console.WriteLine($"使用编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = ExpressionMapper.Trans<Person,PersonDto>(p);

        }

        sw.Stop();

        Console.WriteLine($"使用缓存编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        for (int i = 0; i < 1_000_000; i++)

        {

            PersonDto pd = ExpressionGenericMapper.Map<Person,PersonDto>(p);

        }

        sw.Stop();

        Console.WriteLine($"使用泛型缓存编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Console.ReadKey();

    }

    测试结果:

    并行计算测试代码:

    static void Main(string[] args)

    {

        Person p = new Person() { Age = 10, Name = "张三" };

        Stopwatch sw = new Stopwatch();

        sw.Start();

        Parallel.For(0, 1_000_000, (l, state) =>

          {

              PersonDto pd = new PersonDto() { Name = p.Name, Age = p.Age };

          });

        sw.Stop();

        Console.WriteLine($"使用硬编码映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        Func<Person, PersonDto> func = c => new PersonDto()

        {

            Age = c.Age,

            Name = c.Name

        };

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = func(p);

        });

        sw.Stop();

        Console.WriteLine($"使用委托映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Mapper.Initialize(m => m.CreateMap<Person, PersonDto>());

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = Mapper.Map<PersonDto>(p);

        });

        sw.Stop();

        Console.WriteLine($"使用AutoMapper映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = MapTo<PersonDto>(p);

        });

        sw.Stop();

        Console.WriteLine($"使用反射映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = JsonConvert.DeserializeObject<PersonDto>(JsonConvert.SerializeObject(p));

        });

        sw.Stop();

        Console.WriteLine($"使用Json反序列化映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = ExpressionTreeMapper<Person, PersonDto>(p);

        });

        sw.Stop();

        Console.WriteLine($"使用编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = ExpressionMapper.Trans<Person, PersonDto>(p);

        });

        sw.Stop();

        Console.WriteLine($"使用缓存编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Parallel.For(0, 1_000_000, (l, state) =>

        {

            PersonDto pd = ExpressionGenericMapper.Map<Person, PersonDto>(p);

        });

        sw.Stop();

        Console.WriteLine($"使用泛型缓存编译表达式树映射1000000次耗时{sw.Elapsed.TotalMilliseconds}ms");

        sw.Restart();

        Console.ReadKey();

    }

    测试结果:

    很显然,不管是串行代码还是并行代码,硬编码效率肯定是最高的,至于为什么直接new的硬编码在并行的时候似乎慢了点,这就需要你们从多线程和内存的角度考虑下了,Newtonsoft.Json虽然是高性能的序列化插件,但是使用不当也会造成性能瓶颈的,你们如果用JavascriptSerializer序列化,估计看出来的差距更大了,所以一开始我也就选择Newtonsoft.Json来做本次的评测,也能看出来,表达式树不缓存的时候也是非常耗性能的,毕竟每次都要走一遍编译过程,所以就慢了,而一旦加上了缓存机制,就得到了质的飞跃,而最后的表达式树泛型缓存的写法,性能最接近硬编码的写法,所以,优化无止境!

    至于为什么AutoMapper的性能还没有表达式树高,有兴趣的童鞋可以去github研究下它的源码,它的底层实现其实是用的emit写法,这篇文章就不准备再讲emit了,估计这个更容易把你们给搞晕,毕竟涉及到很多中间语言代码(MSIL),所以,有兴趣的你,可以作为扩展研究。

  • 相关阅读:
    Centos下安装FastDFS
    elasticsearch5.6.8安装和配置
    maven利用插件发布项目到tomcat
    vue-cli安装以及mongodb原生操作
    J2EE基础
    Debian Gun/linux基本用法
    SpringCloud 中如何使微服务只能被指定的程序调用
    CentOS 使用Docker 部署多台Springboot程序,并用Nginx做负载均衡
    CentOS上没有ifcofig命令
    CentOS yum安装时报错 yum install cannot find a vaild baseur
  • 原文地址:https://www.cnblogs.com/Chary/p/11351413.html
Copyright © 2020-2023  润新知