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

最新推荐文章于 2024-02-20 15:17:56 发布

weixin_30840573

最新推荐文章于 2024-02-20 15:17:56 发布

阅读量273

点赞数

文章标签：面试 json 数据结构与算法

原文链接：http://www.cnblogs.com/Chary/p/11351413.html

版权

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

这确实是一道基础题，不管是在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");

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");

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），所以，有兴趣的你，可以作为扩展研究。

转载于:https://www.cnblogs.com/Chary/p/11351413.html