开发过程中经常会遇到对象类型之间的转换映射，例如Model和ViewModel之间的映射绑定，下面总结几种常见的转换方式。事先准备两个类：CheckFile 和 CheckFileModel
public class CheckFile
{
public string Id { get; set; }
public string FileTitle { get; set; }
public string Author { get; set; }
public DateTime? CreatTime;
}
public class CheckFileModel
{
public string Id { get; set; }
public string FileTitle { get; set; }
public string Author { get; set; }
public DateTime? CreatTime;
public string Source { get; set; }
}1. 使用强类型赋值绑定
CheckFile checkFile = new CheckFile
{
Id = "123",
FileTitle = "对象类型转换映射",
Author = "张三",
CreatTime = DateTime.Now
};
CheckFileModel fileModel = new CheckFileModel
{
Id = checkFile.Id,
FileTitle = checkFile.FileTitle,
Author = checkFile.Author,
CreatTime = checkFile.CreatTime
};2. 使用泛型+反射
/// <summary>
/// 泛型+反射
/// </summary>
/// <typeparam name="TOut"></typeparam>
/// <typeparam name="TIn"></typeparam>
/// <param name="objIn"></param>
/// <returns></returns>
public static TOut TypeConvert<TOut, TIn>(TIn objIn)
{
Type tOut = typeof(TOut);
Type tIn = typeof(TIn);
TOut outModel = Activator.CreateInstance<TOut>();
// 属性赋值
foreach (var prop in tOut.GetProperties())
{
var propInfo = tIn.GetProperty(prop.Name);
if (propInfo != null)
{
var inValue = propInfo.GetValue(objIn);
prop.SetValue(outModel, inValue);
}
}
// 字段赋值
foreach (var field in tOut.GetFields())
{
var fieldInfo = tIn.GetField(field.Name);
if (fieldInfo != null)
{
var inValue = fieldInfo.GetValue(objIn);
field.SetValue(outModel, inValue);
}
}
return outModel;
}3. 使用Json序列化转换
/// <summary>
/// Json序列化转换
/// </summary>
/// <typeparam name="TOut"></typeparam>
/// <typeparam name="TIn"></typeparam>
/// <param name="objIn"></param>
/// <returns></returns>
public static TOut SerializeConvert<TOut, TIn>(TIn objIn)
{
string inString = JsonConvert.SerializeObject(objIn);
TOut outModel = JsonConvert.DeserializeObject<TOut>(inString);
return outModel;
}4. 使用AutoMapper序列化转换
/// <summary>
/// AutoMapper序列化转换
/// </summary>
/// <typeparam name="TOut"></typeparam>
/// <typeparam name="TIn"></typeparam>
/// <param name="objIn"></param>
/// <returns></returns>
public static TOut AutoMapperConvert<TOut, TIn>(TIn objIn)
{
// 初始化
Mapper.Initialize(n => n.CreateMap<TIn, TOut>());
TOut outModel = Mapper.Map<TIn, TOut>(objIn);
return outModel;
}5. 使用Expression表达式目录树转换
/// <summary>
/// Expression表达式目录树转换
/// </summary>
/// <typeparam name="TOut"></typeparam>
/// <typeparam name="TIn"></typeparam>
/// <param name="objIn"></param>
/// <returns></returns>
public static TOut ExpressionConvert<TOut, TIn>(TIn objIn)
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
List<MemberBinding> memberBindingList = new List<MemberBinding>();
// 绑定属性
PropertyInfo[] outPropertyInfos = typeof(TOut).GetProperties();
foreach (var prop in outPropertyInfos)
{
PropertyInfo inPropertyInfo = typeof(TIn).GetProperty(prop.Name);
if (inPropertyInfo != null)
{
MemberExpression property = Expression.Property(parameterExpression, inPropertyInfo);
MemberBinding memberBinding = Expression.Bind(prop, property);
memberBindingList.Add(memberBinding);
}
}
// 绑定字段
FieldInfo[] outFieldInfos = typeof(TOut).GetFields();
foreach (var field in outFieldInfos)
{
FieldInfo inFieldInfo = typeof(TIn).GetField(field.Name);
if (inFieldInfo != null)
{
MemberExpression fieldInfo = Expression.Field(parameterExpression, inFieldInfo);
MemberBinding memberBinding = Expression.Bind(field, fieldInfo);
memberBindingList.Add(memberBinding);
}
}
MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
{
parameterExpression
});
Func<TIn, TOut> func = lambda.Compile();
return func.Invoke(objIn);
}
//----------------------------------------------------------
// 等价于构造一个下面的表达式
Expression<Func<CheckFile, CheckFileModel>> lambda = p => new CheckFileModel
{
Id = p.Id,
FileTitle = p.FileTitle,
Author = p.Author,
CreatTime = p.CreatTime
};
lambda.Compile().Invoke(checkFile);表达式目录树介绍
每个矩形框为一个节点（表达式类型），节点有多种类型，对于而这个 a*b+2 的几个节点：
- a,b是参数，类型为ParameterExpression
- +，*，为二元运符，类型为BinaryExpression
- 2为常量，类型为ConstantExpression
Expression<Func<int, int, int>> exp1 = (a, b) => a * b+2;
//两个参数
ParameterExpression a = Expression.Parameter(typeof(int), "a");
ParameterExpression b = Expression.Parameter(typeof(int), "b");
//求积
BinaryExpression Multi=Expression.Multiply(a,b);
//常量
ConstantExpression x2 = Expression.Constant(2);
//求和
BinaryExpression Add = Expression.Add(Multi, x2);
//创建一个表示lambda表达式的对象
LambdaExpression lexp = Expression.Lambda<Func<int, int, int>>(Add, a, b);
//查看表达式
Console.WriteLine(lexp.ToString());
//简单使用
Expression<Func<int, int, int>> lexp = Expression.Lambda<Func<int, int, int>>(Add, a, b);
Func<int, int, int> fun = lexp.Compile();
Console.WriteLine(fun(3,5));| END |
出处：https://blog.csdn.net/qq_31176861/article/details/86551996
=======================================================================================
C# 高性能对象映射(表达式树实现)
前言
上篇简单实现了对象映射,针对数组，集合，嵌套类并没有给出实现，这一篇继续完善细节。
开源对象映射类库映射分析
1.AutoMapper
实现原理：主要通过表达式树Api 实现对象映射
优点： .net功能最全的对象映射类库。
缺点：当出现复杂类型和嵌套类型时性能直线下降，甚至不如序列化快
2.TinyMapper
实现原理：主要通过Emit 实现对象映射
优点：速度非常快。在处理复杂类型和嵌套类型性能也很好
缺点：相对AutoMapper功能上少一些，Emit的实现方案，在代码阅读和调试上相对比较麻烦，而表达式树直接观察 DebugView中生成的代码结构便可知道问题所在
3. 本文的对象映射库
针对AutoMapper 处理复杂类型和嵌套类型时性能非常差的情况，自己实现一个表达式树版的高性能方案
此篇记录下实现对象映射库的过程
构造测试类
1 public class TestA
2 {
3 public int Id { get; set; }
4 public string Name { get; set; }
5
6 public TestC TestClass { get; set; }
7
8 public IEnumerable<TestC> TestLists { get; set; }
9 }
10
11 public class TestB
12 {
13 public int Id { get; set; }
14 public string Name { get; set; }
15
16 public TestD TestClass { get; set; }
17
18 public TestD[] TestLists { get; set; }
19 }
20
21 public class TestC
22 {
23 public int Id { get; set; }
24 public string Name { get; set; }
25
26 public TestC SelfClass { get; set; }
27 }
28
29 public class TestD
30 {
31 public int Id { get; set; }
32 public string Name { get; set; }
33
34 public TestD SelfClass { get; set; }
35 }
1.初步实现
利用表达式树给属性赋值 利用 Expresstion.New构造 var b=new B{};
1 private static Func<TSource, TTarget> GetMap<TSource, TTarget>()
2 {
3 var sourceType = typeof(TSource);
4 var targetType = typeof(TTarget);
5
6 //构造 p=>
7 var parameterExpression = Expression.Parameter(sourceType, "p");
8
9 //构造 p=>new TTarget{ Id=p.Id,Name=p.Name };
10 var memberBindingList = new List<MemberBinding>();
11 foreach (var sourceItem in sourceType.GetProperties())
12 {
13 var targetItem = targetType.GetProperty(sourceItem.Name);
14 if (targetItem == null || sourceItem.PropertyType != targetItem.PropertyType)
15 continue;
16
17 var property = Expression.Property(parameterExpression, sourceItem);
18 var memberBinding = Expression.Bind(targetItem, property);
19 memberBindingList.Add(memberBinding);
20 }
21 var memberInitExpression = Expression.MemberInit(Expression.New(targetType), memberBindingList);
22
23 var lambda = Expression.Lambda<Func<TSource, TTarget>>(memberInitExpression, parameterExpression );
24
25 Console.WriteLine(lambda);
26 return lambda.Compile();
27 }
调用如下
14
15 class Program
16 {
17 static void Main(string[] args)
18 {
19 var testA = new TestA { Id = 1, Name = "张三" };
20 var func = Map<TestA, TestB>();
21 TestB testB = func(testA);
22 Console.WriteLine($"testB.Id={testB.Id},testB.Name={testB.Name}");
23 Console.ReadLine();
24 }
25 }
输出结果
总结：此方法需要调用前需要手动编译下，然后再调用委托没有缓存委托，相对麻烦。
2.缓存实现
利用静态泛型类缓存泛型委托
1 public class DataMapper<TSource, TTarget>
2 {
3 private static Func<TSource, TTarget> MapFunc { get; set; }
4
5 public static TTarget Map(TSource source)
6 {
7 if (MapFunc == null)
8 MapFunc = GetMap();//方法在上边
9 return MapFunc(source);
10 }11 }
调用方法
1 static void Main(string[] args)
2 {
3 var testA = new TestA { Id = 1, Name = "张三" };
4 TestB testB = DataMapper<TestA, TestB>.Map(testA);//委托不存在时自动生成，存在时调用静态缓存
5
6 Console.WriteLine($"testB.Id={testB.Id},testB.Name={testB.Name}");
7 Console.ReadLine();
8 }
输出结果
总结：引入静态泛型类能解决泛型委托缓存提高性能，但是有两个问题 1.当传入参数为null时 则会抛出空引用异常 2.出现复杂类型上述方法便不能满足了
3.解决参数为空值和复杂类型的问题
首先先用常规代码实现下带有复杂类型赋值的情况
1 public TestB GetTestB(TestA testA)
2 {
3 TestB testB;
4 if (testA != null)
5 {
6 testB = new TestB();
7 testB.Id = testA.Id;
8 testB.Name = testA.Name;
9 if (testA.TestClass != null)
10 {
11 testB.TestClass = new TestD();
12 testB.TestClass.Id = testA.TestClass.Id;
13 testB.TestClass.Name = testA.TestClass.Name;
14 }
15 }
16 else
17 {
18 testB = null;
19 }
20 return testB;
21 }
将上面的代码翻译成表达式树
1 private static Func<TSource, TTarget> GetMap()
2 {
3 var sourceType = typeof(TSource);
4 var targetType = typeof(TTarget);
5
6 //Func委托传入变量
7 var parameter = Expression.Parameter(sourceType);
8
9 //声明一个返回值变量
10 var variable = Expression.Variable(targetType);
11 //创建一个if条件表达式
12 var test = Expression.NotEqual(parameter, Expression.Constant(null, sourceType));// p==null;
13 var ifTrue = Expression.Block(GetExpression(parameter, variable, sourceType, targetType));
14 var IfThen = Expression.IfThen(test, ifTrue);
15
16 //构造代码块
17 var block = Expression.Block(new[] { variable }, parameter, IfThen, variable);
18
19 var lambda = Expression.Lambda<Func<TSource, TTarget>>(block, parameter);
20 return lambda.Compile();
21 }
22
23 private static List<Expression> GetExpression(Expression parameter, Expression variable, Type sourceType, Type targetType)
24 {
25 //创建一个表达式集合
26 var expressions = new List<Expression>();
27
28 expressions.Add(Expression.Assign(variable, Expression.MemberInit(Expression.New(targetType))));
29
30 foreach (var targetItem in targetType.GetProperties().Where(x => x.PropertyType.IsPublic && x.CanWrite))
31 {
32 var sourceItem = sourceType.GetProperty(targetItem.Name);
33
34 //判断实体的读写权限
35 if (sourceItem == null || !sourceItem.CanRead || sourceItem.PropertyType.IsNotPublic)
36 continue;
37
38 var sourceProperty = Expression.Property(parameter, sourceItem);
39 var targetProperty = Expression.Property(variable, targetItem);
40
41 //判断都是class 且类型不相同时
42 if (targetItem.PropertyType.IsClass && sourceItem.PropertyType.IsClass && targetItem.PropertyType != sourceItem.PropertyType)
43 {
44 if (targetItem.PropertyType != targetType)//不处理嵌套循环的情况
45 {
46 //由于类型是class 所以默认值是null
47 var testItem = Expression.NotEqual(sourceProperty, Expression.Constant(null, sourceItem.PropertyType));
48
49 var itemExpressions = GetExpression(sourceProperty, targetProperty, sourceItem.PropertyType, targetItem.PropertyType);
50 var ifTrueItem = Expression.Block(itemExpressions);
51
52 var IfThenItem = Expression.IfThen(testItem, ifTrueItem);
53 expressions.Add(IfThenItem);
54
55 continue;
56 }
57 }
58
59 //目标值类型时 且两者类型不一致时跳过
60 if (targetItem.PropertyType != sourceItem.PropertyType)
61 continue;
62
63 expressions.Add(Expression.Assign(targetProperty, sourceProperty));
64 }
65
66 return expressions;
67 }
总结：此方案，运用 Expression.IfThen(testItem, ifTrueItem) 判断空值问题，通过递归调用 GetExpression()方法，处理复杂类型。 但是。。。针对嵌套类仍然不能解决。因为表达式树是在实际调用方法之前就生成的，在没有实际的
参数值传入之前，生成的表达式是不知道有多少层级的。有个比较low的方案是，预先设定嵌套层级为10层，然后生成一个有10层 if(P!=null) 的判断。如果传入的参数层级超过10层了呢，就得手动调整生成的树，此方案也否决。
最后得出的结论只能在表达式中动态调用方法。
4.最终版本
通过动态调用方法解决嵌套类，代码如下
using static System.Linq.Expressions.Expression;
public static class Mapper<TSource, TTarget> where TSource : class where TTarget : class
{
public readonly static Func<TSource, TTarget> MapFunc = GetMapFunc();
public readonly static Action<TSource, TTarget> MapAction = GetMapAction();
/// <summary>
/// 将对象TSource转换为TTarget
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static TTarget Map(TSource source) => MapFunc(source);
public static List<TTarget> MapList(IEnumerable<TSource> sources)=> sources.Select(MapFunc).ToList();
/// <summary>
/// 将对象TSource的值赋给给TTarget
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
public static void Map(TSource source, TTarget target) => MapAction(source, target);
private static Func<TSource, TTarget> GetMapFunc()
{
var sourceType = typeof(TSource);
var targetType = typeof(TTarget);
//Func委托传入变量
var parameter = Parameter(sourceType, "p");
var memberBindings = new List<MemberBinding>();
var targetTypes = targetType.GetProperties().Where(x => x.PropertyType.IsPublic && x.CanWrite);
foreach (var targetItem in targetTypes)
{
var sourceItem = sourceType.GetProperty(targetItem.Name);
//判断实体的读写权限
if (sourceItem == null || !sourceItem.CanRead || sourceItem.PropertyType.IsNotPublic)
continue;
//标注NotMapped特性的属性忽略转换
if (sourceItem.GetCustomAttribute<NotMappedAttribute>() != null)
continue;
var sourceProperty = Property(parameter, sourceItem);
//当非值类型且类型不相同时
if (!sourceItem.PropertyType.IsValueType && sourceItem.PropertyType != targetItem.PropertyType)
{
//判断都是(非泛型)class
if (sourceItem.PropertyType.IsClass && targetItem.PropertyType.IsClass &&
!sourceItem.PropertyType.IsGenericType && !targetItem.PropertyType.IsGenericType)
{
var expression = GetClassExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
memberBindings.Add(Bind(targetItem, expression));
}
//集合数组类型的转换
if (typeof(IEnumerable).IsAssignableFrom(sourceItem.PropertyType) && typeof(IEnumerable).IsAssignableFrom(targetItem.PropertyType))
{
var expression = GetListExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
memberBindings.Add(Bind(targetItem, expression));
}
continue;
}
if (targetItem.PropertyType != sourceItem.PropertyType)
continue;
memberBindings.Add(Bind(targetItem, sourceProperty));
}
//创建一个if条件表达式
var test = NotEqual(parameter, Constant(null, sourceType));// p==null;
var ifTrue = MemberInit(New(targetType), memberBindings);
var condition = Condition(test, ifTrue, Constant(null, targetType));
var lambda = Lambda<Func<TSource, TTarget>>(condition, parameter);
return lambda.Compile();
}
/// <summary>
/// 类型是clas时赋值
/// </summary>
/// <param name="sourceProperty"></param>
/// <param name="targetProperty"></param>
/// <param name="sourceType"></param>
/// <param name="targetType"></param>
/// <returns></returns>
private static Expression GetClassExpression(Expression sourceProperty, Type sourceType, Type targetType)
{
//条件p.Item!=null
var testItem = NotEqual(sourceProperty, Constant(null, sourceType));
//构造回调 Mapper<TSource, TTarget>.Map()
var mapperType = typeof(Mapper<,>).MakeGenericType(sourceType, targetType);
var iftrue = Call(mapperType.GetMethod(nameof(Map), new[] { sourceType }), sourceProperty);
var conditionItem = Condition(testItem, iftrue, Constant(null, targetType));
return conditionItem;
}
/// <summary>
/// 类型为集合时赋值
/// </summary>
/// <param name="sourceProperty"></param>
/// <param name="targetProperty"></param>
/// <param name="sourceType"></param>
/// <param name="targetType"></param>
/// <returns></returns>
private static Expression GetListExpression(Expression sourceProperty, Type sourceType, Type targetType)
{
//条件p.Item!=null
var testItem = NotEqual(sourceProperty, Constant(null, sourceType));
//构造回调 Mapper<TSource, TTarget>.MapList()
var sourceArg = sourceType.IsArray ? sourceType.GetElementType() : sourceType.GetGenericArguments()[0];
var targetArg = targetType.IsArray ? targetType.GetElementType() : targetType.GetGenericArguments()[0];
var mapperType = typeof(Mapper<,>).MakeGenericType(sourceArg, targetArg);
var mapperExecMap = Call(mapperType.GetMethod(nameof(MapList), new[] { sourceType }), sourceProperty);
Expression iftrue;
if (targetType == mapperExecMap.Type)
{
iftrue = mapperExecMap;
}
else if (targetType.IsArray)//数组类型调用ToArray()方法
{
iftrue = Call(mapperExecMap, mapperExecMap.Type.GetMethod("ToArray"));
}
else if (typeof(IDictionary).IsAssignableFrom(targetType))
{
iftrue = Constant(null, targetType);//字典类型不转换
}
else
{
iftrue = Convert(mapperExecMap, targetType);
}
var conditionItem = Condition(testItem, iftrue, Constant(null, targetType));
return conditionItem;
}
private static Action<TSource, TTarget> GetMapAction()
{
var sourceType = typeof(TSource);
var targetType = typeof(TTarget);
//Func委托传入变量
var sourceParameter = Parameter(sourceType, "p");
var targetParameter = Parameter(targetType, "t");
//创建一个表达式集合
var expressions = new List<Expression>();
var targetTypes = targetType.GetProperties().Where(x => x.PropertyType.IsPublic && x.CanWrite);
foreach (var targetItem in targetTypes)
{
var sourceItem = sourceType.GetProperty(targetItem.Name);
//判断实体的读写权限
if (sourceItem == null || !sourceItem.CanRead || sourceItem.PropertyType.IsNotPublic)
continue;
//标注NotMapped特性的属性忽略转换
if (sourceItem.GetCustomAttribute<NotMappedAttribute>() != null)
continue;
var sourceProperty = Property(sourceParameter, sourceItem);
var targetProperty = Property(targetParameter, targetItem);
//当非值类型且类型不相同时
if (!sourceItem.PropertyType.IsValueType && sourceItem.PropertyType != targetItem.PropertyType)
{
//判断都是(非泛型)class
if (sourceItem.PropertyType.IsClass && targetItem.PropertyType.IsClass &&
!sourceItem.PropertyType.IsGenericType && !targetItem.PropertyType.IsGenericType)
{
var expression = GetClassExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
expressions.Add(Assign(targetProperty, expression));
}
//集合数组类型的转换
if (typeof(IEnumerable).IsAssignableFrom(sourceItem.PropertyType) && typeof(IEnumerable).IsAssignableFrom(targetItem.PropertyType))
{
var expression = GetListExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
expressions.Add(Assign(targetProperty, expression));
}
continue;
}
if (targetItem.PropertyType != sourceItem.PropertyType)
continue;
expressions.Add(Assign(targetProperty, sourceProperty));
}
//当Target!=null判断source是否为空
var testSource = NotEqual(sourceParameter, Constant(null, sourceType));
var ifTrueSource = Block(expressions);
var conditionSource = IfThen(testSource, ifTrueSource);
//判断target是否为空
var testTarget = NotEqual(targetParameter, Constant(null, targetType));
var conditionTarget = IfThen(testTarget, conditionSource);
var lambda = Lambda<Action<TSource, TTarget>>(conditionTarget, sourceParameter, targetParameter);
return lambda.Compile();
}
}
输出的 表达式
格式化后
1 p => IIF((p != null),
2 new TestB()
3 {
4 Id = p.Id,
5 Name = p.Name,
6 TestClass = IIF(
7 (p.TestClass != null),
8 Map(p.TestClass),
9 null
10 ),
11 TestLists = IIF(
12 (p.TestLists != null),
13 MapList(p.TestLists).ToArray(),
14 null
15 )
16 },
17 null)
说明 Map(p.TestClass) MapList(p.TestLists).ToArray(), 完整的信息为 Mapper<TestC,TestD>.Map() Mapper<TestC,TestD>.MapList()
总结：解决嵌套类的核心代码
101 //构造回调 Mapper<TSource, TTarget>.Map()
102 var mapperType = typeof(DataMapper<,>).MakeGenericType(sourceType, targetType);
103 var mapperExecMap = Expression.Call(mapperType.GetMethod(nameof(Map), new[] { sourceType }), sourceProperty);
利用Expression.Call 根据参数类型动态生成 对象映射的表达式
性能测试
写了这么多最终目的还是为了解决性能问题，下面将对比下性能
1.测试类
1 public static class MapperTest
2 {
3 //执行次数
4 public static int Count = 100000;
5
6 //简单类型
7 public static void Nomal()
8 {
9 Console.WriteLine($"******************简单类型:{Count / 10000}万次执行时间*****************");
10 var model = new TestA
11 {
12 Id =1,
13 Name = "张三",
14 };
15
16 //计时
17 var sw = Stopwatch.StartNew();
18 for (int i = 0; i < Count; i++)
19 {
20 if (model != null)
21 {
22 var b = new TestB
23 {
24 Id = model.Id,
25 Name = model.Name,
26 };
27 }
28 }
29 sw.Stop();
30 Console.WriteLine($"原生的时间:{sw.ElapsedMilliseconds}ms");
31
32 Exec(model);
33 }
34
35 //复杂类型
36 public static void Complex()
37 {
38 Console.WriteLine($"********************复杂类型:{Count / 10000}万次执行时间*********************");
39 var model = new TestA
40 {
41 Id = 1,
42 Name = "张三",
43 TestClass = new TestC
44 {
45 Id = 2,
46 Name = "lisi",
47 },
48 };
49
50 //计时
51 var sw = Stopwatch.StartNew();
52 for (int i = 0; i < Count; i++)
53 {
54
55 if (model != null)
56 {
57 var b = new TestB
58 {
59 Id = model.Id,
60 Name = model.Name,
61 };
62 if (model.TestClass != null)
63 {
64 b.TestClass = new TestD
65 {
66 Id = i,
67 Name = "lisi",
68 };
69 }
70 }
71 }
72 sw.Stop();
73 Console.WriteLine($"原生的时间:{sw.ElapsedMilliseconds}ms");
74 Exec(model);
75 }
76
77 //嵌套类型
78 public static void Nest()
79 {
80 Console.WriteLine($"*****************嵌套类型:{Count / 10000}万次执行时间*************************");
81 var model = new TestA
82 {
83 Id = 1,
84 Name = "张三",
85 TestClass = new TestC
86 {
87 Id = 1,
88 Name = "lisi",
89 SelfClass = new TestC
90 {
91 Id = 2,
92 Name = "lisi",
93 SelfClass = new TestC
94 {
95 Id = 3,
96 Name = "lisi",
97 SelfClass = new TestC
98 {
99 Id = 4,
100 Name = "lisi",
101 },
102 },
103 },
104 },
105 };
106 //计时
107 var item = model;
108 var sw = Stopwatch.StartNew();
109 for (int i = 0; i < Count; i++)
110 {
111 //这里每一步需要做非空判断的，书写太麻烦省去了
112 if (model != null)
113 {
114 var b = new TestB
115 {
116 Id = model.Id,
117 Name = model.Name,
118 TestClass = new TestD
119 {
120 Id = model.TestClass.Id,
121 Name = model.TestClass.Name,
122 SelfClass = new TestD
123 {
124 Id = model.TestClass.SelfClass.Id,
125 Name = model.TestClass.SelfClass.Name,
126 SelfClass = new TestD
127 {
128 Id = model.TestClass.SelfClass.SelfClass.Id,
129 Name = model.TestClass.SelfClass.SelfClass.Name,
130 SelfClass = new TestD
131 {
132 Id = model.TestClass.SelfClass.SelfClass.SelfClass.Id,
133 Name = model.TestClass.SelfClass.SelfClass.SelfClass.Name,
134 },
135 },
136 },
137 },
138 };
139 }
140 }
141 sw.Stop();
142 Console.WriteLine($"原生的时间:{sw.ElapsedMilliseconds}ms");
143
144 Exec(model);
145 }
146
147 //集合
148 public static void List()
149 {
150 Console.WriteLine($"********************集合类型:{Count/10000}万次执行时间***************************");
151
152 var model = new TestA
153 {
154 Id = 1,
155 Name = "张三",
156 TestLists = new List<TestC> {
157 new TestC{
158 Id = 1,
159 Name = "张三",
160 },
161 new TestC{
162 Id = -1,
163 Name = "张三",
164 },
165 }
166 };
167
168
169 //计时
170 var sw = Stopwatch.StartNew();
171 for (int i = 0; i < Count; i++)
172 {
173 var item = model;
174 if (item != null)
175 {
176 var b = new TestB
177 {
178 Id = item.Id,
179 Name = item.Name,
180 TestLists = new List<TestD> {
181 new TestD{
182 Id = item.Id,
183 Name = item.Name,
184 },
185 new TestD{
186 Id = -item.Id,
187 Name = item.Name,
188 },
189 }.ToArray()
190 };
191 }
192 }
193 sw.Stop();
194 Console.WriteLine($"原生的时间:{sw.ElapsedMilliseconds}ms");
195
196 Exec(model);
197 }
198
199 public static void Exec(TestA model)
200 {
201 //表达式
202 Mapper<TestA, TestB>.Map(model);
203 var sw = Stopwatch.StartNew();
204 for (int i = 0; i < Count; i++)
205 {
206 var b = Mapper<TestA, TestB>.Map(model);
207 }
208 sw.Stop();
209 Console.WriteLine($"表达式的时间:{sw.ElapsedMilliseconds}ms");
210
211 //AutoMapper
212 sw.Restart();
213 for (int i = 0; i < Count; i++)
214 {
215 var b = AutoMapper.Mapper.Map<TestA, TestB>(model);
216 }
217 sw.Stop();
218 Console.WriteLine($"AutoMapper时间:{sw.ElapsedMilliseconds}ms");
219
220 //TinyMapper
221 sw.Restart();
222 for (int i = 0; i < Count; i++)
223 {
224 var b = TinyMapper.Map<TestA, TestB>(model);
225 }
226 sw.Stop();
227 Console.WriteLine($"TinyMapper时间:{sw.ElapsedMilliseconds}ms");
228 }
229 }
230
231
2.调用测试
1 static void Main(string[] args)
2 {
3 AutoMapper.Mapper.Initialize(cfg => cfg.CreateMap<TestA, TestB>());
4 TinyMapper.Bind<TestA, TestB>();
5 Mapper<TestA, TestB>.Map(new TestA());
6
7
8 MapperTest.Count = 10000;
9 MapperTest.Nomal();
10 MapperTest.Complex();
11 MapperTest.Nest();
12 MapperTest.List();
13
14 MapperTest.Count = 100000;
15 MapperTest.Nomal();
16 MapperTest.Complex();
17 MapperTest.Nest();
18 MapperTest.List();
19
20 MapperTest.Count = 1000000;
21 MapperTest.Nomal();
22 MapperTest.Complex();
23 MapperTest.Nest();
24 MapperTest.List();
25
26 MapperTest.Count = 10000000;
27 MapperTest.Nomal();
28 MapperTest.Complex();
29 MapperTest.Nest();
30 MapperTest.List();
31
32
33 Console.WriteLine($"------------结束--------------------");
34 Console.ReadLine();
35 }
3.结果
1万次
10万次
100万次
1000万次
上图结果AutoMapper 在非简单类型的转换上比其他方案有50倍以上的差距，几乎就跟反射的结果一样。
作者：costyuan
GitHub地址：https://github.com/bieyuan/.net-core-DTO
出处：https://www.cnblogs.com/castyuan/p/9324088.html