登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›恋爱虽易，相处不易：当EntityFramework爱上AutoMapper ...

恋爱虽易，相处不易：当EntityFramework爱上AutoMapper

高清宁 2025-5-29 17:00:41
剧情开始

1.jpeg
2.jpeg


  • 为何相爱？
  • 相处的问题？
  • 女人的伟大？
  • 剧情收尾？
　　有时候相识即是一种缘分，相爱也不需要太多的理由，一个眼神足矣，当EntityFramework遇上AutoMapper，就是如此，恋爱虽易，相处不易。
　　在DDD（领域驱动设计）中，使用AutoMapper一般场景是（Domain Layer）领域层与Presentation Layer（表现层）之间数据对象的转换，也就是DTO与Domin Model之间的相互转换，但是如果对AutoMapper有深入了解之后，就会发现她所涉及的领域不仅仅局限如此，应该包含所有对象之间的转换。另一边，当EntityFramework还在为单身苦恼时，不经意的一瞬间相识了AutoMapper，从此就深深的爱上了她。
　　AutoMapper是一个强大的Object-Object Mapping工具，关于AutoMapper请参照：

  • 【AutoMapper官方文档】DTO与Domin Model相互转换（上）
  • 【AutoMapper官方文档】DTO与Domin Model相互转换（中）
  • 【AutoMapper官方文档】DTO与Domin Model相互转换（下）
为何相爱？

3.jpeg

　　上面是AutoMapper对象转换示意图，可以看出AutoMapper的主要用途是用在对象映射转换上，她不管是什么对象，只是负责转换，就像一个女人在家只负责相夫教子一样。看下AutoMapper的基本用法：
  1. 1       // 配置 AutoMapper
  2. 2       Mapper.CreateMap<Order, OrderDto>();
  3. 3       // 执行 mapping
  4. 4       OrderDto dto = Mapper.Map<Order, OrderDto>(order);
复制代码
　　EntityFramework是什么？他是微软开发的基于ADO.NET的ORM(Object/Relational Mapping)框架，是个大人物，是有身份和地位的人，就像一个“王子”一样，而AutoMapper准确的来说只是一个小角色，就像“灰姑娘”一样，况且他们也不是一个世界的人，那为什么EntityFramework会看上AutoMapper呢？这里面必定有内情，我们来探查一番。
　　假如存在这样一个业务场景，Order表中存在百万条订单数据，而且Order表有几百列，根据业务场景要求，我们要对订单进行分离，比如：客户信息订单、产品订单等等，可能只是用到订单表中的某些字段，如果我们去做这样的一个操作，可以想象这样查询出的数据是怎样的，某些我们并不需要的字段会查询出来，而且数据并没有得到过滤，所以我们要在数据访问层做下面这样一个操作：
  1. 1         using (var context = new OrderContext())
  2. 2         {
  3. 3             var orderConsignee = from order in context.Orders
  4. 4                                  select new OrderConsignee
  5. 5                                  {
  6. 6                                      OrderConsigneeId = order.OrderId,
  7. 7                                      //OrderItems = order.OrderItems,
  8. 8                                      OrderItemCount = order.OrderItemCount,
  9. 9                                      ConsigneeName = order.ConsigneeName,
  10. 10                                      ConsigneeRealName = order.ConsigneeRealName,
  11. 11                                      ConsigneePhone = order.ConsigneePhone,
  12. 12                                      ConsigneeProvince = order.ConsigneeProvince,
  13. 13                                      ConsigneeAddress = order.ConsigneeAddress,
  14. 14                                      ConsigneeZip = order.ConsigneeZip,
  15. 15                                      ConsigneeTel = order.ConsigneeTel,
  16. 16                                      ConsigneeFax = order.ConsigneeFax,
  17. 17                                      ConsigneeEmail = order.ConsigneeEmail
  18. 18                                  };<br>19             Console.ReadKey();
  19. 20         }
复制代码
　　orderConsignee表示订单客户，这只是订单信息分离的一种子集，如果有多种分离的子集，并且子集中的字段并不比订单表少多少，你就会发现在数据访问层填充这些子集要做的工作量有多少了，虽然它是高效的，从生成的SQL代码中就可以看出：
  1. 1 SELECT
  2. 2     [Extent1].[OrderItemCount] AS [OrderItemCount],
  3. 3     [Extent1].[OrderId] AS [OrderId],
  4. 4     [Extent1].[ConsigneeName] AS [ConsigneeName],
  5. 5     [Extent1].[ConsigneeRealName] AS [ConsigneeRealName],
  6. 6     [Extent1].[ConsigneePhone] AS [ConsigneePhone],
  7. 7     [Extent1].[ConsigneeProvince] AS [ConsigneeProvince],
  8. 8     [Extent1].[ConsigneeAddress] AS [ConsigneeAddress],
  9. 9     [Extent1].[ConsigneeZip] AS [ConsigneeZip],
  10. 10     [Extent1].[ConsigneeTel] AS [ConsigneeTel],
  11. 11     [Extent1].[ConsigneeFax] AS [ConsigneeFax],
  12. 12     [Extent1].[ConsigneeEmail] AS [ConsigneeEmail]
  13. 13     FROM [dbo].[Orders] AS [Extent1]
复制代码
　　但是这种效果并不能让EntityFramework满意，于是他就盯上了人家AutoMapper，为什么？因为AutoMapper的一段代码就可以搞定上面的问题：
  1. 1     OrderDto dto = Mapper.Map<Order, OrderDto>(order);
复制代码
相处的问题？

　　因为EntityFramework的疯狂追求，再加上他显赫的地位，让AutoMapper不得不接受了他，于是他们就交往了，但好像就是后羿和嫦娥的故事一样，不是一个世界的人，相处起来总会出现一些问题。虽然AutoMapper在对象转换方面很强大，而且大部分应用场景是Domain与ViewModel之间的映射转换，当涉及到数据访问时，AutoMapper就不是那么有用了。换句话说，AutoMapper工作在内存中的对象转换，而不是应用在数据访问中IQueryable的接口，在数据访问层我们使用EntityFramework把要查询的对象转化为SQL命令，如果在数据访问层使用AutoMapper，那么查询数据一定会发生在映射转换之后，而且查询出的数据一定会比转换的数据多，从而产生性能问题。
　　上面的示例我们修改下：
  1. 1     Mapper.CreateMap<Order, OrderConsignee>();
  2. 2     var details = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderConsignee>>(context.Orders).ToList();
复制代码
　　其实这就是EntityFramework看上AutoMapper的原因，也是EntityFramework想要的效果，看下生成的SQL语句：
  1. 1 SELECT
  2. 2     [Extent1].[OrderId] AS [OrderId],
  3. 3     [Extent1].[OrderItemCount] AS [OrderItemCount],
  4. 4     [Extent1].[UserId] AS [UserId],
  5. 5     [Extent1].[ReceiverId] AS [ReceiverId],
  6. 6     [Extent1].[ShopDate] AS [ShopDate],
  7. 7     [Extent1].[OrderDate] AS [OrderDate],
  8. 8     [Extent1].[ConsigneeRealName] AS [ConsigneeRealName],
  9. 9     [Extent1].[ConsigneeName] AS [ConsigneeName],
  10. 10     [Extent1].[ConsigneePhone] AS [ConsigneePhone],
  11. 11     [Extent1].[ConsigneeProvince] AS [ConsigneeProvince],
  12. 12     [Extent1].[ConsigneeAddress] AS [ConsigneeAddress],
  13. 13     [Extent1].[ConsigneeZip] AS [ConsigneeZip],
  14. 14     [Extent1].[ConsigneeTel] AS [ConsigneeTel],
  15. 15     [Extent1].[ConsigneeFax] AS [ConsigneeFax],
  16. 16     [Extent1].[ConsigneeEmail] AS [ConsigneeEmail],
  17. 17     [Extent1].[WhetherCouAndinte] AS [WhetherCouAndinte],
  18. 18     [Extent1].[ParvalueAndInte] AS [ParvalueAndInte],
  19. 19     [Extent1].[PaymentType] AS [PaymentType],
  20. 20     [Extent1].[Payment] AS [Payment],
  21. 21     [Extent1].[Courier] AS [Courier],
  22. 22     [Extent1].[TotalPrice] AS [TotalPrice],
  23. 23     [Extent1].[FactPrice] AS [FactPrice],
  24. 24     [Extent1].[Invoice] AS [Invoice],
  25. 25     [Extent1].[Remark] AS [Remark],
  26. 26     [Extent1].[OrderStatus] AS [OrderStatus],
  27. 27     [Extent1].[SaleUserID] AS [SaleUserID],
  28. 28     [Extent1].[SaleUserType] AS [SaleUserType],
  29. 29     [Extent1].[BusinessmanID] AS [BusinessmanID],
  30. 30     [Extent1].[Carriage] AS [Carriage],
  31. 31     [Extent1].[PaymentStatus] AS [PaymentStatus],
  32. 32     [Extent1].[OgisticsStatus] AS [OgisticsStatus],
  33. 33     [Extent1].[OrderType] AS [OrderType],
  34. 34     [Extent1].[IsOrderNormal] AS [IsOrderNormal]
  35. 35     FROM [dbo].[Orders] AS [Extent1]
复制代码
　　通过上面的SQL语句，会发现，虽然数据访问层代码写的简单了，但是查询的字段并不是我们想要的，也就是说查询发生在映射之前，可以想象如果存在上百万的数据或是上百行，使用AutoMapper进行映射转换是多么的不靠谱，难道EntityFramework和AutoMapper就没有缘分？或者只是EntityFramework的一厢情愿？请看下面。
女人的伟大？

　　在EntityFramework和AutoMapper的相处过程中，虽然出现了某些问题，但其实也并不是EntityFramework的错，错就错在他们生不逢地，通过相处AutoMapper也发现EntityFramework是真心对她好，于是AutoMapper决定要做些改变，为了EntityFramework，也为了他们的将来。
　　EntityFramework和AutoMapper不在一个世界的原因，前面我们也分析过，一个存在于内存中，一个存在于数据访问中，AutoMapper要做的就是去扩展IQueryable表达式（有点嫦娥下凡的意思哈），从而使他们可以存在于一个世界，于是她为了EntityFramework就做了以下工作：
  1. 1     public static class QueryableExtensions
  2. 2     {
  3. 3         public static ProjectionExpression<TSource> Project<TSource>(this IQueryable<TSource> source)
  4. 4         {
  5. 5             return new ProjectionExpression<TSource>(source);
  6. 6         }
  7. 7     }
  8. 8
  9. 9     public class ProjectionExpression<TSource>
  10. 10     {
  11. 11         private static readonly Dictionary<string, Expression> ExpressionCache = new Dictionary<string, Expression>();
  12. 12
  13. 13         private readonly IQueryable<TSource> _source;
  14. 14
  15. 15         public ProjectionExpression(IQueryable<TSource> source)
  16. 16         {
  17. 17             _source = source;
  18. 18         }
  19. 19
  20. 20         public IQueryable<TDest> To<TDest>()
  21. 21         {
  22. 22              var queryExpression = GetCachedExpression<TDest>() ?? BuildExpression<TDest>();
  23. 23
  24. 24             return _source.Select(queryExpression);
  25. 25         }        
  26. 26
  27. 27         private static Expression<Func<TSource, TDest>> GetCachedExpression<TDest>()
  28. 28         {
  29. 29             var key = GetCacheKey<TDest>();
  30. 30
  31. 31             return ExpressionCache.ContainsKey(key) ? ExpressionCache[key] as Expression<Func<TSource, TDest>> : null;
  32. 32         }
  33. 33
  34. 34         private static Expression<Func<TSource, TDest>> BuildExpression<TDest>()
  35. 35         {
  36. 36             var sourceProperties = typeof(TSource).GetProperties();
  37. 37             var destinationProperties = typeof(TDest).GetProperties().Where(dest => dest.CanWrite);
  38. 38             var parameterExpression = Expression.Parameter(typeof(TSource), "src");
  39. 39            
  40. 40             var bindings = destinationProperties
  41. 41                                 .Select(destinationProperty => BuildBinding(parameterExpression, destinationProperty, sourceProperties))
  42. 42                                 .Where(binding => binding != null);
  43. 43
  44. 44             var expression = Expression.Lambda<Func<TSource, TDest>>(Expression.MemberInit(Expression.New(typeof(TDest)), bindings), parameterExpression);
  45. 45
  46. 46             var key = GetCacheKey<TDest>();
  47. 47
  48. 48             ExpressionCache.Add(key, expression);
  49. 49
  50. 50             return expression;
  51. 51         }        
  52. 52
  53. 53         private static MemberAssignment BuildBinding(Expression parameterExpression, MemberInfo destinationProperty, IEnumerable<PropertyInfo> sourceProperties)
  54. 54         {
  55. 55             var sourceProperty = sourceProperties.FirstOrDefault(src => src.Name == destinationProperty.Name);
  56. 56
  57. 57             if (sourceProperty != null)
  58. 58             {
  59. 59                 return Expression.Bind(destinationProperty, Expression.Property(parameterExpression, sourceProperty));
  60. 60             }
  61. 61
  62. 62             var propertyNames = SplitCamelCase(destinationProperty.Name);
  63. 63
  64. 64             if (propertyNames.Length == 2)
  65. 65             {
  66. 66                 sourceProperty = sourceProperties.FirstOrDefault(src => src.Name == propertyNames[0]);
  67. 67
  68. 68                 if (sourceProperty != null)
  69. 69                 {
  70. 70                     var sourceChildProperty = sourceProperty.PropertyType.GetProperties().FirstOrDefault(src => src.Name == propertyNames[1]);
  71. 71
  72. 72                     if (sourceChildProperty != null)
  73. 73                     {
  74. 74                         return Expression.Bind(destinationProperty, Expression.Property(Expression.Property(parameterExpression, sourceProperty), sourceChildProperty));
  75. 75                     }
  76. 76                 }
  77. 77             }
  78. 78
  79. 79             return null;
  80. 80         }
  81. 81
  82. 82         private static string GetCacheKey<TDest>()
  83. 83         {
  84. 84             return string.Concat(typeof(TSource).FullName, typeof(TDest).FullName);
  85. 85         }
  86. 86
  87. 87         private static string[] SplitCamelCase(string input)
  88. 88         {
  89. 89             return Regex.Replace(input, "([A-Z])", " $1", RegexOptions.Compiled).Trim().Split(' ');
  90. 90         }
  91. 91     }   
复制代码
　　修改示例代码：
  1. 1       Mapper.CreateMap<Order, OrderConsignee>();
  2. 2       var details = context.Orders.Project().To<OrderConsignee>();
复制代码
　　通过AutoMapper所做的努力，使得代码更加简化，只要配置一个类型映射，传递目标类型，就可以得到我们想要的转换对象，代码如此简洁，我们再来看下生成SQL代码：
  1. 1 SELECT
  2. 2     [Project1].[OrderId] AS [OrderId],
  3. 3     [Project1].[OrderItemCount] AS [OrderItemCount],
  4. 4     [Project1].[ConsigneeRealName] AS [ConsigneeRealName],
  5. 5     [Project1].[ConsigneeName] AS [ConsigneeName],
  6. 6     [Project1].[ConsigneePhone] AS [ConsigneePhone],
  7. 7     [Project1].[ConsigneeProvince] AS [ConsigneeProvince],
  8. 8     [Project1].[ConsigneeAddress] AS [ConsigneeAddress],
  9. 9     [Project1].[ConsigneeZip] AS [ConsigneeZip],
  10. 10     [Project1].[ConsigneeTel] AS [ConsigneeTel],
  11. 11     [Project1].[ConsigneeFax] AS [ConsigneeFax],
  12. 12     [Project1].[ConsigneeEmail] AS [ConsigneeEmail],
  13. 13     [Project1].[C1] AS [C1],
  14. 14     [Project1].[OrderItemId] AS [OrderItemId],
  15. 15     [Project1].[ProName] AS [ProName],
  16. 16     [Project1].[ProImg] AS [ProImg],
  17. 17     [Project1].[ProPrice] AS [ProPrice],
  18. 18     [Project1].[ProNum] AS [ProNum],
  19. 19     [Project1].[AddTime] AS [AddTime],
  20. 20     [Project1].[ProOtherPara] AS [ProOtherPara],
  21. 21     [Project1].[Order_OrderId] AS [Order_OrderId]
  22. 22     FROM ( SELECT
  23. 23         [Extent1].[OrderId] AS [OrderId],
  24. 24         [Extent1].[OrderItemCount] AS [OrderItemCount],
  25. 25         [Extent1].[ConsigneeRealName] AS [ConsigneeRealName],
  26. 26         [Extent1].[ConsigneeName] AS [ConsigneeName],
  27. 27         [Extent1].[ConsigneePhone] AS [ConsigneePhone],
  28. 28         [Extent1].[ConsigneeProvince] AS [ConsigneeProvince],
  29. 29         [Extent1].[ConsigneeAddress] AS [ConsigneeAddress],
  30. 30         [Extent1].[ConsigneeZip] AS [ConsigneeZip],
  31. 31         [Extent1].[ConsigneeTel] AS [ConsigneeTel],
  32. 32         [Extent1].[ConsigneeFax] AS [ConsigneeFax],
  33. 33         [Extent1].[ConsigneeEmail] AS [ConsigneeEmail],
  34. 34         [Extent2].[OrderItemId] AS [OrderItemId],
  35. 35         [Extent2].[ProName] AS [ProName],
  36. 36         [Extent2].[ProImg] AS [ProImg],
  37. 37         [Extent2].[ProPrice] AS [ProPrice],
  38. 38         [Extent2].[ProNum] AS [ProNum],
  39. 39         [Extent2].[AddTime] AS [AddTime],
  40. 40         [Extent2].[ProOtherPara] AS [ProOtherPara],
  41. 41         [Extent2].[Order_OrderId] AS [Order_OrderId],
  42. 42         CASE WHEN ([Extent2].[OrderItemId] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1]
  43. 43         FROM  [dbo].[Orders] AS [Extent1]
  44. 44         LEFT OUTER JOIN [dbo].[OrderItems] AS [Extent2] ON [Extent1].[OrderId] = [Extent2].[Order_OrderId]
  45. 45     )  AS [Project1]
  46. 46     ORDER BY [Project1].[OrderId] ASC, [Project1].[C1] ASC
复制代码
　　可以看出因为Order和OrderConsignee包含对OrderItems子集的映射关系：
  1. 1         /// <summary>
  2. 2         /// 订单项
  3. 3         /// </summary>
  4. 4         public virtual ICollection<OrderItem> OrderItems { get; set; }
复制代码
　　所以AutoMapper会自动匹配关联子集进行查询，当然也可以在创建映射关系的时候对OrderItems进行忽略：Mapper.CreateMap().ForMember(dest => dest.OrderItems, opt => opt.Ignore()); 排除OrderItems关联因素，从SQL代码可以看出并没有查询多余的字段，也就是我们想要的效果，这所以的一切都归功于AutoMapper，也许如果没有AutoMapper的努力，她和EntityFramework说不准还真不能在一起，女人真是伟大啊。
剧情收尾？

4.jpeg

　　示例代码下载：http://pan.baidu.com/s/1c0h9TNM
　　经过一切风风雨雨，EntityFramework终于和AutoMapper过上了幸福美满的日子，但是看似幸福，但是问题还是不断，有人又提出疑问：

  • http://rogeralsing.com/2013/12/01/why-mapping-dtos-to-entities-using-automapper-and-entityframework-is-horrible/
　　文章的标题用了“horrible”这个单词，翻译为可怕的，难道说EntityFramework和AutoMapper在一起有那么可怕吗？当然这只是针对EntityFramework使用AutoMapper进行CURD操作，但是我相信EntityFramework和AutoMapper会克服重重困难，生死不渝的。我们也会一直关注他们的婚后生活，未完待续。。。
　　如果你也祝福EntityFramework和AutoMapper会永远在一起，那就疯狂的“戳”右下角的“推荐”吧。^_^

        分享到：        QQ空间        新浪微博        腾讯微博        微信        更多
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
高清宁
2025-5-29 17:00:41

0

粉丝关注

13

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫