码迷,mamicode.com
首页 > 移动开发 > 详细

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

时间:2019-08-14 15:14:05      阅读:174      评论:0      收藏:0      [点我收藏+]

标签:封装   详细   private   机制   序列   循环   研究   setvalue   复杂   

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

这确实是一道基础题,不管是在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),所以,有兴趣的你,可以作为扩展研究。

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

标签:封装   详细   private   机制   序列   循环   研究   setvalue   复杂   

原文地址:https://www.cnblogs.com/Chary/p/11351413.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!