PocoEmit遥遥领先于AutoMapper之循环引用

一、什么是循环引用

循环引用就是类型相互依赖

1. 比如A类有B类的属性,B类也有A类的属性

• 这有什么问题呢?
• 编写生成A的代码需要遍历A的所有属性
• 构造B类型属性是A代码的一部分,B代码又含有A类型属性
• 这就是一个编译死循环

2. 其他循环引用的例子

• 链表结构只有一个类型也是类型循环引用
• A-B-C-A等更长的引用链条也会构成类型循环引用

二、举个树状结构的Case

• 树状结构在实际应用中很常见

1. 导航菜单代码

导航菜单是一个典型的树状结构

public class Menu
{public int Id { get; set; }public string Name { get; set; }public string Description { get; set; }public List<Menu> Children { get; set; }public static Menu GetMenu(){var programs = new Menu { Id = 2, Name = "Programs", Description = "程序" };var documents = new Menu { Id = 3, Name = "Documents", Description = "文档" };var settings = new Menu { Id = 4, Name = "Settings", Description = "设置" };var help = new Menu { Id = 5, Name = "Help", Description = "帮助" };var run = new Menu { Id = 6, Name = "Run", Description = "运行" };var shutdown = new Menu { Id = 7, Name = "Shut Down", Description = "关闭" };var start = new Menu { Id = 1, Name = "Start", Description = "开始", Children = [programs, documents, settings, help, run, shutdown] };return start;}
}

2. 把Menu转化为MenuDTO

2.1 PocoEmit执行代码

• 代码中多加了UseCollection
• 如果全局开启了集合就不需要这行代码

var menu = Menu.GetMenu();
var mapper = PocoEmit.Mapper.Create().UseCollection();
var dto = mapper.Convert<Menu, MenuDTO>(menu);

2.2 执行效果如下:

• 以下测试是使用vscode执行的(需要Jupyter Notebook插件)
• 测试代码地址为: https://github.com/donetsoftwork/MyEmit/tree/main/Notes/menu.dib
• gitee地址: https://gitee.com/donetsoftwork/MyEmit/tree/main/Notes/menu.dib

{"$id": "1","Id": 1,"Name": "Start","Description": "\u5F00\u59CB","Children": {"$id": "2","$values": [{"$id": "3","Id": 2,"Name": "Programs","Description": "\u7A0B\u5E8F","Children": null},{"$id": "4","Id": 3,"Name": "Documents","Description": "\u6587\u6863","Children": null},{"$id": "5","Id": 4,"Name": "Settings","Description": "\u8BBE\u7F6E","Children": null},{"$id": "6","Id": 5,"Name": "Help","Description": "\u5E2E\u52A9","Children": null},{"$id": "7","Id": 6,"Name": "Run","Description": "\u8FD0\u884C","Children": null},{"$id": "8","Id": 7,"Name": "Shut Down","Description": "\u5173\u95ED","Children": null}]}
}

3. 与AutoMapper性能对比如下

Method	Mean	Error	StdDev	Median	Ratio	RatioSD	Gen0	Gen1	Allocated	Alloc Ratio
Auto	320.14 ns	0.420 ns	0.484 ns	320.10 ns	5.51	0.10	0.0751	0.0003	1296 B	2.95
AutoFunc	289.80 ns	6.580 ns	7.313 ns	295.77 ns	4.98	0.15	0.0751	0.0003	1296 B	2.95
Poco	58.17 ns	1.031 ns	1.103 ns	58.17 ns	1.00	0.03	0.0255	-	440 B	1.00
PocoFunc	48.10 ns	1.059 ns	1.087 ns	49.06 ns	0.83	0.02	0.0255	-	440 B	1.00

• AutoMapper耗时是Poco的5倍多
• AutoMapper内存是Poco的近3倍
• 哪怕是用上AutoMapper内部生成的委托也挽救不了多少局面

4. 我们增加无循环引用再测试一下

4.1 无循环引用菜单

public class Menu0
{public int ParentId { get; set; }public int Id { get; set; }public string Name { get; set; }public string Description { get; set; }public static List<Menu0> GetMenus(){var start = new Menu0 { Id = 1, Name = "Start", Description = "开始", ParentId = 0 };var programs = new Menu0 { Id = 2, Name = "Programs", Description = "程序", ParentId = 1 };var documents = new Menu0 { Id = 3, Name = "Documents", Description = "文档", ParentId = 1 };var settings = new Menu0 { Id = 4, Name = "Settings", Description = "设置", ParentId = 1 };var help = new Menu0 { Id = 5, Name = "Help", Description = "帮助", ParentId = 1 };var run = new Menu0 { Id = 6, Name = "Run", Description = "运行" , ParentId = 1 };var shutdown = new Menu0 { Id = 7, Name = "Shut Down", Description = "关闭", ParentId = 1 };return [start, programs, documents, settings, help, run, shutdown];}
}

4.2 性能测试如下

Method	Mean	Error	StdDev	Median	Ratio	RatioSD	Gen0	Gen1	Allocated	Alloc Ratio
Auto	320.14 ns	0.420 ns	0.484 ns	320.10 ns	5.51	0.10	0.0751	0.0003	1296 B	2.95
Auto0	110.60 ns	1.130 ns	1.302 ns	110.30 ns	1.90	0.04	0.0264	-	456 B	1.04
AutoFunc	289.80 ns	6.580 ns	7.313 ns	295.77 ns	4.98	0.15	0.0751	0.0003	1296 B	2.95
Poco	58.17 ns	1.031 ns	1.103 ns	58.17 ns	1.00	0.03	0.0255	-	440 B	1.00
Poco0	60.80 ns	0.176 ns	0.202 ns	60.73 ns	1.05	0.02	0.0227	-	392 B	0.89
PocoFunc	48.10 ns	1.059 ns	1.087 ns	49.06 ns	0.83	0.02	0.0255	-	440 B	1.00

• Auto0是AutoMapper把Menu0列表转化为DTO的case
• Poco0是Poco把Menu0列表转化为DTO的case
• AutoMapper循环引用处理耗时和内存都是列表的3倍
• Poco循环引用处理和列表性能差不多
• 当然就算是无循环引用的列表处理,AutoMapper耗时也几乎是Poco的两倍
• 这充分说明AutoMapper处理循环引用是有问题的

5. 先对比一下AutoMapper有无循环引用的代码

5.1 AutoMapper无循环引用的代码如下

T __f<T>(System.Func<T> f) => f();
(Func<List<Menu0>, List<Menu0DTO>, ResolutionContext, List<Menu0DTO>>)((List<Menu0> source, List<Menu0DTO> mapperDestination, ResolutionContext context) => //List<Menu0DTO>(source == null) ? new List<Menu0DTO>() : __f(() => {try{List<Menu0DTO> collectionDestination = null;List<Menu0DTO> passedDestination = null;passedDestination = mapperDestination;collectionDestination = passedDestination ?? new List<Menu0DTO>();collectionDestination.Clear();List<Menu0>.Enumerator enumerator = default;Menu0 item = null;enumerator = source.GetEnumerator();try{while (true){if (enumerator.MoveNext()){item = enumerator.Current;collectionDestination.Add(((Func<Menu0, Menu0DTO, ResolutionContext, Menu0DTO>)((Menu0 source_1, Menu0DTO destination, ResolutionContext context) => //Menu0DTO(source_1 == null) ? (destination == null) ? (Menu0DTO)null : destination : __f(() => {Menu0DTO typeMapDestination = null;typeMapDestination = destination ?? new Menu0DTO();try{typeMapDestination.ParentId = source_1.ParentId;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Id = source_1.Id;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Name = source_1.Name;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Description = source_1.Description;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}return typeMapDestination;}))).Invoke(item,(Menu0DTO)null,context));}else{goto LoopBreak;}}LoopBreak:;}finally{enumerator.Dispose();}return collectionDestination;}catch (Exception ex){throw MapperConfiguration.GetMappingError(ex,default(MapRequest)/*NOTE: Provide the non-default value for the Constant!*/);}}));

5.2 AutoMapper循环引用的代码如下

5.2.1 Menu转MenuDTO

T __f<T>(System.Func<T> f) => f();
(Func<Menu, MenuDTO, ResolutionContext, MenuDTO>)((Menu source, MenuDTO destination, ResolutionContext context) => //MenuDTO(source == null) ? (destination == null) ? (MenuDTO)null : destination : __f(() => {MenuDTO typeMapDestination = null;ResolutionContext.CheckContext(ref context);return ((MenuDTO)context.GetDestination(source,typeof(MenuDTO))) ?? __f(() => {typeMapDestination = destination ?? new MenuDTO();context.CacheDestination(source,typeof(MenuDTO),typeMapDestination);typeMapDestination;try{typeMapDestination.Id = source.Id;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Name = source.Name;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Description = source.Description;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{List<Menu> resolvedValue = null;List<MenuDTO> mappedValue = null;resolvedValue = source.Children;mappedValue = (resolvedValue == null) ? new List<MenuDTO>() : context.MapInternal<List<Menu>, List<MenuDTO>>(resolvedValue,(destination == null) ? (List<MenuDTO>)null : typeMapDestination.Children,(MemberMap)default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);typeMapDestination.Children = mappedValue;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}return typeMapDestination;});}));

5.2.2 List<Menu>转List<MenuDTO>

T __f<T>(System.Func<T> f) => f();
(Func<List<Menu>, List<MenuDTO>, ResolutionContext, List<MenuDTO>>)((List<Menu> source,List<MenuDTO> mapperDestination,ResolutionContext context) => //List<MenuDTO>(source == null) ?new List<MenuDTO>() :__f(() => {try{List<MenuDTO> collectionDestination = null;List<MenuDTO> passedDestination = null;ResolutionContext.CheckContext(ref context);passedDestination = mapperDestination;collectionDestination = passedDestination ?? new List<MenuDTO>();collectionDestination.Clear();List<Menu>.Enumerator enumerator = default;Menu item = null;enumerator = source.GetEnumerator();try{while (true){if (enumerator.MoveNext()){item = enumerator.Current;collectionDestination.Add(((Func<Menu, MenuDTO, ResolutionContext, MenuDTO>)((Menu source_1,MenuDTO destination,ResolutionContext context) => //MenuDTO(source_1 == null) ?(destination == null) ? (MenuDTO)null : destination :__f(() => {MenuDTO typeMapDestination = null;ResolutionContext.CheckContext(ref context);return ((MenuDTO)context.GetDestination(source_1,typeof(MenuDTO))) ??__f(() => {typeMapDestination = destination ?? new MenuDTO();context.CacheDestination(source_1,typeof(MenuDTO),typeMapDestination);typeMapDestination;try{typeMapDestination.Id = source_1.Id;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Name = source_1.Name;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{typeMapDestination.Description = source_1.Description;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}try{List<Menu> resolvedValue = null;List<MenuDTO> mappedValue = null;resolvedValue = source_1.Children;mappedValue = (resolvedValue == null) ?new List<MenuDTO>() :context.MapInternal<List<Menu>, List<MenuDTO>>(resolvedValue,(destination == null) ? (List<MenuDTO>)null :typeMapDestination.Children,(MemberMap)default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);typeMapDestination.Children = mappedValue;}catch (Exception ex){throw TypeMapPlanBuilder.MemberMappingError(ex,default(PropertyMap)/*NOTE: Provide the non-default value for the Constant!*/);}return typeMapDestination;});}))).Invoke(item,(MenuDTO)null,context));}else{goto LoopBreak;}}LoopBreak:;}finally{enumerator.Dispose();}return collectionDestination;}catch (Exception ex){throw MapperConfiguration.GetMappingError(ex,default(MapRequest)/*NOTE: Provide the non-default value for the Constant!*/);}}));

5.3 AutoMapper有无循环引用的代码分析如下

• 循环引用的代码有2段,1段处理Menu,另1段处理List<Menu>
• 直接对比处理List<Menu>部分
• 很明显有循环引用部分多了不少特殊代码

5.3.1 AutoMapper循环引用多出以下代码

• ResolutionContext.CheckContext消耗内存
• context.GetDestination消耗内存和cpu
• context.CacheDestination消耗内存和cpu
• context.MapInternal用于调用代码

5.3.2 AutoMapper代码总结

• MapInternal用于解决编译死循环的问题
• GetDestination和CacheDestination用于解决执行死循环的问题
• 但是这个case没有对象重复引用,没有执行死循环
• 也就是说这里的GetDestination和CacheDestination只是消耗内存和cpu做无用功
• 更让人无法接受的是,做这些无用功的消耗居然是正常代码的好几倍
• 在无循环引用代码中ResolutionContext就是个摆设,无任何作用

6. 执行死循环该怎么处理呢

• .net序列化给了我们答案
• 序列化默认不支持对象循环引用,需要特殊配置,这是为了照顾大部分情况下的性能

6.1 序列化对象循环引用代码

Node node9 = new() { Id = 9, Name = "node9" };
Node node8 = new() { Id = 8, Name = "node8", Next = node9 };
Node node7 = new() { Id = 7, Name = "node7", Next = node8 };
Node node6 = new() { Id = 6, Name = "node6", Next = node7 };
Node node5 = new() { Id = 5, Name = "node5", Next = node6 };
Node node4 = new() { Id = 4, Name = "node4", Next = node5 };
Node node3 = new() { Id = 3, Name = "node3", Next = node4 };
Node node2 = new() { Id = 2, Name = "node2", Next = node3 };
Node node1 = new() { Id = 1, Name = "node1", Next = node2 };
node9.Next = node1; // 形成环
var referenceJson = JsonSerializer.Serialize(dto, new JsonSerializerOptions{ReferenceHandler = ReferenceHandler.Preserve,WriteIndented = true
});
referenceJson.Display();

• 如果以上代码不配置ReferenceHandler会报错
• 异常信息为A possible object cycle was detected...

7. 对比Poco循环引用处理的代码

7.1 Poco循环引用处理的代码如下

(Func<Menu, MenuDTO>)((Menu source) => //MenuDTO
{MenuDTO dest = null;if ((source != (Menu)null)){dest = new MenuDTO();List<Menu> Children = null;dest.Id = source.Id;dest.Name = source.Name;dest.Description = source.Description;Children = source.Children;if ((Children != null)){dest.Children = default(CompiledConverter<List<Menu>, List<MenuDTO>>)/*NOTE: Provide the non-default value for the Constant!*/.Convert(Children);}}return dest;
});

7.2 代码对比AutoMapper

• AutoMapper生成代码量是Poco的3倍多
• CompiledConverter.Convert对应AutoMapper的context.MapInternal
• 本case中Poco无多余缓存处理,节省了大量cpu和内存
• 如果有对象循环引用Poco该怎么办呢

三、再举个环形链表的Case

• 链表是类型循环引用
• 环形链表又是对象循环引用
• 中国传统有九九归一的说法,以此为例

1. 九九归一代码

public class Node
{public int Id { get; set; }public string Name { get; set; }public Node Next { get; set; }public static Node GetNode(){Node node9 = new() { Id = 9, Name = "node9" };Node node8 = new() { Id = 8, Name = "node8", Next = node9 };Node node7 = new() { Id = 7, Name = "node7", Next = node8 };Node node6 = new() { Id = 6, Name = "node6", Next = node7 };Node node5 = new() { Id = 5, Name = "node5", Next = node6 };Node node4 = new() { Id = 4, Name = "node4", Next = node5 };Node node3 = new() { Id = 3, Name = "node3", Next = node4 };Node node2 = new() { Id = 2, Name = "node2", Next = node3 };Node node1 = new() { Id = 1, Name = "node1", Next = node2 };node9.Next = node1; // 形成环return node1;}
}

2. PocoEmit配置缓存解决对象循环引用问题

• ComplexCached.Circle表示只有检测到循环引用才开启缓存
• ComplexCached.Circle策略基本等同AutoMapper
• 默认是ComplexCached.Never,不开启缓存

var node = Node.GetNode();
var manager = PocoEmit.Mapper.Create(new MapperOptions { Cached = ComplexCached.Circle });
var dto = manager.Convert<Node, NodeDTO>(node);

2.1 执行效果如下:

• 以下测试是使用vscode执行的(需要Jupyter Notebook插件)
• 测试代码地址为: https://github.com/donetsoftwork/MyEmit/tree/main/Notes/node.dib
• gitee地址: https://gitee.com/donetsoftwork/MyEmit/tree/main/Notes/node.dib

{"$id": "1","Id": 1,"Name": "node1","Next": {"$id": "2","Id": 2,"Name": "node2","Next": {"$id": "3","Id": 3,"Name": "node3","Next": {"$id": "4","Id": 4,"Name": "node4","Next": {"$id": "5","Id": 5,"Name": "node5","Next": {"$id": "6","Id": 6,"Name": "node6","Next": {"$id": "7","Id": 7,"Name": "node7","Next": {"$id": "8","Id": 8,"Name": "node8","Next": {"$id": "9","Id": 9,"Name": "node9","Next": {"$ref": "1"}}}}}}}}}
}

2.2 与AutoMapper性能对比如下

Method	Mean	Error	StdDev	Median	Ratio	RatioSD	Gen0	Gen1	Allocated	Alloc Ratio
Auto	678.3 ns	12.65 ns	14.06 ns	666.1 ns	1.78	0.04	0.0936	0.0004	1616 B	4.49
AutoFunc	632.7 ns	4.18 ns	4.64 ns	628.8 ns	1.66	0.02	0.0936	0.0004	1616 B	4.49
Poco	381.8 ns	2.66 ns	3.07 ns	382.0 ns	1.00	0.01	0.0208	-	360 B	1.00
PocoFunc	365.4 ns	2.73 ns	2.92 ns	366.9 ns	0.96	0.01	0.0208	-	360 B	1.00

• 首先可以看出Poco和AutoMapper执行耗时都挺高的
• 所以建议大家使用AutoMapper尽量避免类型循环引用
• 使用Poco也建议大家尽量避免对象循环引用
• Poco性能好不少,差不多2倍
• 内存分配上Poco优势更明显,AutoMapper分配了4倍多的内存

3. PocoEmit还可以通过GetContextConvertFunc来控制对象缓存

3.1 GetContextConvertFunc调用代码

• GetContextConvertFunc是强制开启缓存,忽略mapper的缓存配置
• 并设置当前类型必须缓存

var node = Node.GetNode();
var manager = PocoEmit.Mapper.Create();
Func<IConvertContext, Node, NodeDTO> contextFunc = manager.GetContextConvertFunc<Node, NodeDTO>();
using var context = SingleContext<Node, NodeDTO>.Pool.Get();
var dto = _pocoContextFunc(context, _node);

• 需要特别强调,context是用来做缓存的,不是专门用来做处理循环引用的
• 巧的是缓存能解决对象循环引用问题
• 缓存除了处理对象循环引用当然还有其他用处

3.2 加入GetContextConvertFunc对比如下

Method	Mean	Error	StdDev	Median	Ratio	RatioSD	Gen0	Gen1	Allocated	Alloc Ratio
Auto	657.2 ns	8.03 ns	8.92 ns	664.7 ns	1.81	0.04	0.0936	0.0004	1616 B	4.49
AutoFunc	621.6 ns	8.09 ns	8.65 ns	614.4 ns	1.71	0.04	0.0936	0.0004	1616 B	4.49
Poco	363.5 ns	6.60 ns	7.60 ns	359.6 ns	1.00	0.03	0.0208	-	360 B	1.00
PocoFunc	349.1 ns	1.51 ns	1.74 ns	348.8 ns	0.96	0.02	0.0208	-	360 B	1.00
PocoContextFunc	350.8 ns	3.15 ns	3.63 ns	350.0 ns	0.97	0.02	0.0208	-	360 B	1.00

• PocoContextFunc性能和GetConvertFunc差不多
• 主要影响性能的是缓存的读写
• 该方法通过暴露IConvertContext参数给自定义和配置提供了想象空间
• 是不是可以通过实现IConvertContext来实现想要的逻辑和性能

四、重复引用非循环的Case

1. 一个突击小组的代码

• 小组只有3人
• 1人做队长
• 1人做通讯员

public class SoldierTeam
{public Soldier Leader { get; set; }public Soldier Courier { get; set; }public List<Soldier> Members { get; set; }public static SoldierTeam GetTeam(){var leader = new Soldier { Name = "张三" };var courier = new Soldier { Name = "李四" };var other = new Soldier { Name = "王二" };var team = new SoldierTeam{Leader = leader,Courier = courier,Members = new List<Soldier>{leader,courier,other}};return team;}
}
public class Soldier
{public string Name { get; set; }
}

2. Poco默认情况下转化为5个对象

• 这明显并不是用户想要的结果
• AutoMapper可以通过PreserveReferences配置跟踪引用(就是缓存)

var manager = PocoEmit.Mapper.Create().UseCollection();
var team = SoldierTeam.GetTeam();
var dto = manager.Convert<SoldierTeam, SoldierTeamDTO>(team);
// dtoList.Length == 5
var dtoList = dto.Members.Concat([dto.Leader, dto.Courier]).Distinct().ToArray();

3. Poco配置缓存可以解决问题

• ComplexCached.Always表示可能需要缓存就开启
• 实际是检测有类被属性多次引用就开启缓存
• 或有循环引用也开启缓存

3.1 Poco缓存转化代码

var manager = PocoEmit.Mapper.Create(new MapperOptions { Cached = ComplexCached.Always }).UseCollection();
var team = SoldierTeam.GetTeam();
var dto = manager.Convert<SoldierTeam, SoldierTeamDTO>(team);
// dtoList.Length == 3
var dtoList = dto.Members.Concat([dto.Leader, dto.Courier]).Distinct().ToArray();

3.2 Poco生成以下代码

T __f<T>(System.Func<T> f) => f();
(Func<SoldierTeam, SoldierTeamDTO>)((SoldierTeam source) => //SoldierTeamDTO
{SoldierTeamDTO dest = null;IConvertContext context = null;if ((source != (SoldierTeam)null)){context = ConvertContext.Create();if ((source != (SoldierTeam)null)){dest = new SoldierTeamDTO();context.SetCache<SoldierTeam, SoldierTeamDTO>(source,dest);Soldier Leader = null;Soldier Courier = null;List<Soldier> Members = null;Leader = source.Leader;if ((Leader != null)){// { The block result will be assigned to `dest.Leader`SoldierDTO dest_1 = null;dest.Leader = context.TryGetCache<Soldier, SoldierDTO>(Leader,out dest_1) ? dest_1 : __f(() => {SoldierDTO dest_2 = null;if ((Leader != (Soldier)null)){dest_2 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(Leader,dest_2);dest_2.Name = Leader.Name;}return dest_2;});// } end of block assignment;}Courier = source.Courier;if ((Courier != null)){// { The block result will be assigned to `dest.Courier`SoldierDTO dest_3 = null;dest.Courier = context.TryGetCache<Soldier, SoldierDTO>(Courier,out dest_3) ? dest_3 : __f(() => {SoldierDTO dest_4 = null;if ((Courier != (Soldier)null)){dest_4 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(Courier,dest_4);dest_4.Name = Courier.Name;}return dest_4;});// } end of block assignment;}Members = source.Members;if ((Members != null)){// { The block result will be assigned to `dest.Members`List<SoldierDTO> dest_5 = null;dest.Members = context.TryGetCache<List<Soldier>, List<SoldierDTO>>(Members,out dest_5) ? dest_5 : __f(() => {List<SoldierDTO> dest_6 = null;if ((Members != (List<Soldier>)null)){dest_6 = new List<SoldierDTO>(Members.Count);context.SetCache<List<Soldier>, List<SoldierDTO>>(Members,dest_6);int index = default;int len = default;index = 0;len = Members.Count;while (true){if ((index < len)){Soldier sourceItem = null;SoldierDTO destItem = null;sourceItem = Members[index];// { The block result will be assigned to `destItem`SoldierDTO dest_7 = null;destItem = context.TryGetCache<Soldier, SoldierDTO>(sourceItem,out dest_7) ? dest_7 : __f(() => {SoldierDTO dest_8 = null;if ((sourceItem != (Soldier)null)){dest_8 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(sourceItem,dest_8);dest_8.Name = sourceItem.Name;}return dest_8;});// } end of block assignment;dest_6.Add(destItem);index++;}else{goto forLabel;}}forLabel:;}return dest_6;});// } end of block assignment;}}context.Dispose();}return dest;
});

4. Poco通过GetContextConvertFunc也可以处理

4.1 GetContextConvertFunc转化代码

var manager = PocoEmit.Mapper.Create().UseCollection();
var team = SoldierTeam.GetTeam();
Func<IConvertContext, SoldierTeam, SoldierTeamDTO> func = manager.GetContextConvertFunc<SoldierTeam, SoldierTeamDTO>();
using var context = SingleContext<Soldier, SoldierDTO>.Pool.Get();
var dto = func(context, team);
// dtoList.Length == 3
var dtoList = dto.Members.Concat([dto.Leader, dto.Courier]).Distinct().ToArray();

4.2 Poco生成以下代码

T __f<T>(System.Func<T> f) => f();
(Func<IConvertContext, SoldierTeam, SoldierTeamDTO>)((IConvertContext context, SoldierTeam source) => //SoldierTeamDTO
{SoldierTeamDTO dest = null;if ((source != (SoldierTeam)null)){dest = new SoldierTeamDTO();context.SetCache<SoldierTeam, SoldierTeamDTO>(source,dest);Soldier Leader = null;Soldier Courier = null;List<Soldier> Members = null;Leader = source.Leader;if ((Leader != null)){// { The block result will be assigned to `dest.Leader`SoldierDTO dest_1 = null;dest.Leader = context.TryGetCache<Soldier, SoldierDTO>(Leader,out dest_1) ? dest_1 : __f(() => {SoldierDTO dest_2 = null;if ((Leader != (Soldier)null)){dest_2 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(Leader,dest_2);dest_2.Name = Leader.Name;}return dest_2;});// } end of block assignment;}Courier = source.Courier;if ((Courier != null)){// { The block result will be assigned to `dest.Courier`SoldierDTO dest_3 = null;dest.Courier = context.TryGetCache<Soldier, SoldierDTO>(Courier,out dest_3) ? dest_3 : __f(() => {SoldierDTO dest_4 = null;if ((Courier != (Soldier)null)){dest_4 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(Courier,dest_4);dest_4.Name = Courier.Name;}return dest_4;});// } end of block assignment;}Members = source.Members;if ((Members != null)){// { The block result will be assigned to `dest.Members`List<SoldierDTO> dest_5 = null;dest.Members = context.TryGetCache<List<Soldier>, List<SoldierDTO>>(Members,out dest_5) ? dest_5 : __f(() => {List<SoldierDTO> dest_6 = null;if ((Members != (List<Soldier>)null)){dest_6 = new List<SoldierDTO>(Members.Count);context.SetCache<List<Soldier>, List<SoldierDTO>>(Members,dest_6);int index = default;int len = default;index = 0;len = Members.Count;while (true){if ((index < len)){Soldier sourceItem = null;SoldierDTO destItem = null;sourceItem = Members[index];// { The block result will be assigned to `destItem`SoldierDTO dest_7 = null;destItem = context.TryGetCache<Soldier, SoldierDTO>(sourceItem,out dest_7) ? dest_7 : __f(() => {SoldierDTO dest_8 = null;if ((sourceItem != (Soldier)null)){dest_8 = new SoldierDTO();context.SetCache<Soldier, SoldierDTO>(sourceItem,dest_8);dest_8.Name = sourceItem.Name;}return dest_8;});// } end of block assignment;dest_6.Add(destItem);index++;}else{goto forLabel;}}forLabel:;}return dest_6;});// } end of block assignment;}}return dest;
});

5. 性能测试如下

Method	Mean	Error	StdDev	Ratio	RatioSD	Gen0	Allocated	Alloc Ratio
Auto	306.8 ns	10.60 ns	12.21 ns	1.39	0.06	0.0459	792 B	4.12
AutoFunc	259.1 ns	1.32 ns	1.47 ns	1.18	0.02	0.0459	792 B	4.12
Poco	220.2 ns	2.95 ns	3.39 ns	1.00	0.02	0.0111	192 B	1.00
PocoFunc	206.8 ns	2.26 ns	2.61 ns	0.94	0.02	0.0111	192 B	1.00
PocoContextFunc	207.4 ns	2.74 ns	3.15 ns	0.94	0.02	0.0111	192 B	1.00

• PocoFunc性能和PocoContextFunc性能差不多
• 如果喜欢隔离配置的同学,可以使用缓存配置方案
• 如果喜欢集中配置的同学,可以使用GetContextConvertFunc
• AutoMapper耗时1.4倍,内存占用4倍多

五、总结

1. 与AutoMapper处理循环引用的原理是一样的

• 用其他对象调用,代替当时尚未编译的代码处理编译死循环
• 使用缓存解决执行死循环
• 缓存操作比原本对象转化耗时多太多,请大家慎用缓存

2. AutoMapper处理粗犷一点

• 所有对象转化都加上下文对象,哪怕完全用不上
• 检测到循环引用就加读写缓存,拖累到性能
• 用了AutoMapper如果感觉获取数据慢,可以查一下是否有循环引用
• 如果AutoMapper转化数据比实际数据库操作还慢也不要太过惊讶
• 这里链接园内大佬的一篇文章: https://www.cnblogs.com/dudu/p/5863042.html

3. Poco处理就细致的多

• 只有需要时才加上下文
• 上下文来自内存池,用完回收复用,节约内存
• 用户可以通过配置或GetContextConvertFunc选择性开启缓存
• 自定义IConvertContext可以提供更多想象的空间
• 另外无论是否开启缓存,Poco的性能都优于AutoMapper

另外源码托管地址: https://github.com/donetsoftwork/MyEmit ，欢迎大家直接查看源码。
gitee同步更新:https://gitee.com/donetsoftwork/MyEmit

如果大家喜欢请动动您发财的小手手帮忙点一下Star,谢谢！！！