AutoMapper 下面的 Mapper

时间  2019-12-08
标签 automapper 下面 mapper 繁體版
原文   原文链接 
一些orm框架，在用到Entity的时候有一些开源代码用到了automapper（如：nopcommence），将数据对象转成DTO。好比在ORM中，与数据库交互用的Model模型是具备不少属性变量方法神马的。而当咱们与其它系统（或系统中的其它结构）进行数据交互时，出于耦合性考虑或者安全性考虑或者性能考虑（总之就是各类考虑），咱们不但愿直接将这个Model模型传递给它们，这时咱们会建立一个贫血模型来保存数据并传递。神马是贫血模型？贫血模型（DTO，Data Transfer Object）就是说只包含属性神马的，只能保存必须的数据，木有其它任何的多余的方法数据什么的，专门用于数据传递用的类型对象。在这个建立的过程当中，若是咱们手动来进行，就会看到这样的代码：
B b=new B(); b.XXX1=a.XXX1; b.XXX2=a.XXX2; ... ... ... return b;
此时，AutoMapper能够发挥的做用就是根据A的模型和B的模型中的定义，自动将A模型映射为一个全新的B模型。基于访问性的控制或从模型自己上考虑。对外开放的原则是，尽可能下降系统耦合度，不然内部一旦变动外部全部的接口都要跟随发生变动；另外，系统内部的一些数据或方法并不但愿外部能看到或调用。相似的考虑不少，只是举个例子。系统设计的原则是高内聚低耦合，尽可能依赖抽象而不依赖于具体。这里感受automapper就是使数据库实体对一个外部调用实体的转换更简便（不用一个属性一个属性的赋值）。
例如1：数据库里面有用户信息表，供别的系统调用，提供了数据接口。若是直接暴露了数据库层的表结构的话，会对系统自己产生依赖。具体表如今，假定如今由于某种须要，为用户信息增长了十个字段的信息，那么，若是不进行类型映射的话，会致使全部基于此用户数据结构的模块集体挂掉（接口约定变动）。而若是使用了映射的话，咱们能够在内部进行转换，保持原有接口不变并提供新的更全面的接口，这是保证系统的可维护性和可迁移性。
例如2：一个Web应用经过前端收集用户的输入成为Dto，而后将Dto转换成领域模型并持久化到数据库中。相反，当用户请求数据时，咱们又须要作相反的工做：将从数据库中查询出来的领域模型以相反的方式转换成Dto再呈现给用户。使用AutoMapper（一个强大的Object-Object Mapping工具），来实现这个转换。
【一】 应用场景

 先来看看我所”虚拟“的领域模型。这一次我定义了一个书店（BookStore）： 前端

  1. public class BookStore  
  2. {  
  3.     public string Name { get; set; }  
  4.     public List<Book> Books { get; set; }  
  5.     public Address Address { get; set; }  
  6. }  

书店有本身的地址（Address）： 数据库

  1. public class Address  
  2. {  
  3.     public string Country { get; set; }  
  4.     public string City { get; set; }  
  5.     public string Street { get; set; }  
  6.     public string PostCode { get; set; }  
  7. }  

同时书店里放了n本书（Book）： express

  1. public class Book  
  2. {  
  3.     public string Title { get; set; }  
  4.     public string Description { get; set; }  
  5.     public string Language { get; set; }  
  6.     public decimal Price { get; set; }  
  7.     public List<Author> Authors { get; set; }  
  8.     public DateTime? PublishDate { get; set; }  
  9.     public Publisher Publisher { get; set; }  
  10.     public int? Paperback { get; set; }  
  11. }  

每本书都有出版商信息（Publisher）： 安全

  1. public class Publisher  
  2. {  
  3.     public string Name { get; set; }  
  4. }  

每本书能够有最多2个做者的信息（Author）： 数据结构

  1. public class Author  
  2. {  
  3.     public string Name { get; set; }  
  4.     public string Description { get; set; }  
  5.     public ContactInfo ContactInfo { get; set; }  
  6. }  

每一个做者都有本身的联系方式（ContactInfo）： app

  1. public class ContactInfo  
  2. {  
  3.     public string Email { get; set; }  
  4.     public string Blog { get; set; }  
  5.     public string Twitter { get; set; }  
  6. }  

差很少就是这样了，一个有着层级结构的领域模型。  再来看看咱们的Dto结构。  在Dto中咱们有与BookStore对应的BookStoreDto： 框架

  1. public class BookStoreDto  
  2. {  
  3.     public string Name { get; set; }  
  4.     public List<BookDto> Books { get; set; }  
  5.     public AddressDto Address { get; set; }  
  6. }  

其中包含与Address对应的AddressDto： 工具

  1. public class AddressDto  
  2. {  
  3.     public string Country { get; set; }  
  4.     public string City { get; set; }  
  5.     public string Street { get; set; }  
  6.     public string PostCode { get; set; }  
  7. }  

以及与Book相对应的BookDto： 性能

  1. public class BookDto  
  2. {  
  3.     public string Title { get; set; }  
  4.     public string Description { get; set; }  
  5.     public string Language { get; set; }  
  6.     public decimal Price { get; set; }  
  7.     public DateTime? PublishDate { get; set; }  
  8.     public string Publisher { get; set; }  
  9.     public int? Paperback { get; set; }  
  10.     public string FirstAuthorName { get; set; }  
  11.     public string FirstAuthorDescription { get; set; }  
  12.     public string FirstAuthorEmail { get; set; }  
  13.     public string FirstAuthorBlog { get; set; }  
  14.     public string FirstAuthorTwitter { get; set; }  
  15.     public string SecondAuthorName { get; set; }  
  16.     public string SecondAuthorDescription { get; set; }  
  17.     public string SecondAuthorEmail { get; set; }  
  18.     public string SecondAuthorBlog { get; set; }  
  19.     public string SecondAuthorTwitter { get; set; }  
  20. }  

注意到咱们的BookDto”拉平了“整个Book的层级结构，一个BookDto里携带了Book及其全部Author、Publisher等全部模式的数据。this

正好咱们来看一下Dto到Model的映射规则。  （1）BookStoreDto –> BookStore

BookStoreDto中的字段 BookStore中的字段
Name Name
Books Books
Address Address

（2）AddressDto –> Address

AddressDto中的字段 Address中的字段
Country Country
City City
Street Street
PostCode PostCode

（3）BookDto -> Book。  BookDto中的一些基本字段能够直接对应到Book中的字段。

BookDto中的字段 Book中的字段
Title Title
Description Description
Language Language
Price Price
PublishDate PublishDate
Paperback Paperback

 

每本书至多有2个做者，在BookDto中分别使用”First“前缀和”Second“前缀的字段来表示。所以，全部FirstXXX字段都将映射成Book的Authors中的第1个Author对象，而全部SecondXXX字段则将映射成Authors中的第2个Author对象。

BookDto中的字段 Book中的Authors中的第1个Author对象中的字段
FirstAuthorName Name
FirstAuthorDescription Description
FirstAuthorEmail ContactInfo.Email
FirstAuthorBlog ContactInfo.Blog
FirstAuthorTwitter ContactInfo.Twitter

注意上表中的ContactInfo.Email表示对应到Author对象的ContactInfo的Email字段，依次类推。相似的咱们有：

BookDto中的字段 Book中的Authors中的第2个Author对象中的字段
SecondAuthorName Name
SecondAuthorDescription Description
SecondAuthorEmail ContactInfo.Email
SecondAuthorBlog ContactInfo.Blog
SecondAuthorTwitter ContactInfo.Twitter

最后还有Publisher字段，它将对应到一个独立的Publisher对象。

BookDto中的字段 Publisher中的字段
Publisher Name

差很少就是这样了，咱们的需求是要实现这一大坨Dto到另外一大坨的Model之间的数据转换。

【二】以Convention方式实现零配置的对象映射

在上一篇文章中咱们构造出了完整的应用场景，包括咱们的Model、Dto以及它们之间的转换规则。下面就能够卷起袖子，开始咱们的AutoMapper之旅了。

引用
AutoMapper uses a convention-based matching algorithm to match up source to destination values.

咱们要作的只是将要映射的两个类型告诉AutoMapper（调用Mapper类的Static方法CreateMap并传入要映射的类型）： 

  1. Mapper.CreateMap<AddressDto, Address>();  

而后就能够交给AutoMapper帮咱们搞定一切了： 

  1. AddressDto dto = new AddressDto  
  2. {  
  3.     Country = "China",  
  4.     City = "Beijing",  
  5.     Street = "Dongzhimen Street",  
  6.     PostCode = "100001"  
  7. };  
  8. Address address = Mapper.Map<AddressDto,Address>(Dto);  
  9. address.Country.ShouldEqual("China");  
  10. address.City.ShouldEqual("Beijing");  
  11. address.Street.ShouldEqual("Dongzhimen Street");  
  12. address.PostCode.ShouldEqual("100001");  

若是AddressDto中有值为空的属性，AutoMapper在映射的时候会把Address中的相应属性也置为空： 

  1. Address address = Mapper.Map<AddressDto,Address>(new AddressDto  
  2.                                                        {  
  3.                                                            Country = "China"  
  4.                                                        });  
  5. address.City.ShouldBeNull();  
  6. address.Street.ShouldBeNull();  
  7. address.PostCode.ShouldBeNull();  

甚至若是传入一个空的AddressDto，AutoMapper也会帮咱们获得一个空的Address对象。 

  1. Address address = Mapper.Map<AddressDto,Address>(null);  
  2. address.ShouldBeNull();  

千万不要把这种Convention的映射方式当成“玩具”，它在映射具备相同字段名的复杂类型的时候仍是具备至关大的威力的。  例如，考虑咱们的BookStoreDto到BookStore的映射，二者的字段名称彻底相同，只是字段的类型不一致。若是咱们定义好了BookDto到Book的映射规则，再加上上述Convention方式的AddressDto到Address的映射，就能够用“零配置”实现BookStoreDto到BookStore的映射了： 

  1. IMappingExpression<BookDto, Book> expression = Mapper.CreateMap<BookDto,Book>();  
  2. // Define mapping rules from BookDto to Book here  
  3. Mapper.CreateMap<AddressDto, Address>();  
  4. Mapper.CreateMap<BookStoreDto, BookStore>();  

而后咱们就能够直接转换BookStoreDto了： 

  1. BookStoreDto dto = new BookStoreDto  
  2.                        {  
  3.                            Name = "My Store",  
  4.                            Address = new AddressDto  
  5.                                          {  
  6.                                              City = "Beijing"  
  7.                                          },  
  8.                            Books = new List<BookDto>  
  9.                                        {  
  10.                                            new BookDto {Title = "RESTful Web Service"},  
  11.                                            new BookDto {Title = "Ruby for Rails"},  
  12.                                        }  
  13.                        };  
  14. BookStore bookStore = Mapper.Map<BookStoreDto,BookStore>(dto);  
  15. bookStore.Name.ShouldEqual("My Store");  
  16. bookStore.Address.City.ShouldEqual("Beijing");  
  17. bookStore.Books.Count.ShouldEqual(2);  
  18. bookStore.Books.First().Title.ShouldEqual("RESTful Web Service");  
  19. bookStore.Books.Last().Title.ShouldEqual("Ruby for Rails");  

实现BookDto到Book之间的转换（他嵌套了相应的子类型如：Publisher ->ContactInfo,Author）：

  1. var exp = Mapper.CreateMap<BookDto, Book>();
  2. exp.ForMember(bok=> bok.Publisher/*(变量)*/,
  3. (map) => map.MapFrom(dto=>new Publisher(){Name= dto.Publisher/*(DTO的变量)*/}));
通常在咱们写完规则以后一般会调用
  1. //该方法主要用来检查还有那些规则没有写完。 Mapper.AssertConfigurationIsValid();

参见：http://stackoverflow.com/questions/4928487/how-to-automap-thismapping-sub-members

其它的就以此类推。

 

若是要完成 BookStore 到 BookStoreDto 具体的应该如何映射呢  相同的类型与名字就不说了，如BookStore.Name->BookStoreDto.Name AutoMapper会自动去找。

 

而对于List<Book>与List<BookDto>者咱们必须在配置下面代码以前

  1. var exp = Mapper.CreateMap<BookStore, BookStoreDto>();
  2. exp.ForMember(dto => dto.Books, (map) => map.MapFrom(m => m.Books));

告诉AutoMapper，Book与BookDto的映射，最后效果为:

  1. Mapper.CreateMap<Book, BookDto>();
  2. var exp = Mapper.CreateMap<BookStore, BookStoreDto>();
  3. exp.ForMember(dto => dto.Books, (map) => map.MapFrom(m => m.Books));

Address同理。

若是要完成不一样类型之间的转换用AutoMapper，如string到int,string->DateTime,以及A->B之间的类型转换咱们能够参照以下例子：

http://automapper.codeplex.com/wikipage?title=Custom%20Type%20Converters&referringTitle=Home

对于咱们不想要某属性有值咱们能够采用下面的方式。

exp.ForMember(ads => ads.ZipCode, dto => dto.Ignore()); //若是对于不想某属性有值，咱们能够经过Ignore来忽略他，这样在调用AssertConfigurationIsValid时也不会报错.

【三】定义类型间的简单映射规则  前面咱们看了Convention的映射方式，客观的说仍是有不少类型间的映射是没法经过简单的Convention方式来作的，这时候就须要咱们使用Configuration了。好在咱们的Configuration是在代码中以“强类型”的方式来写的，比写繁琐易错的xml方式是要好的多了。  先来看看BookDto到Publisher的映射。  回顾一下前文中定义的规则：BookDto.Publisher -> Publisher.Name。  在AutoMapperzhong,咱们能够这样映射： 

  1. var map = Mapper.CreateMap<BookDto,Publisher>();  
  2. map.ForMember(d => d.Name, opt => opt.MapFrom(s => s.Publisher));  

AutoMapper使用ForMember来指定每个字段的映射规则： 

引用
The each custom member configuration uses an action delegate to configure each member.

还好有强大的lambda表达式，规则的定义简单明了。 
此外，咱们还可使用ConstructUsing的方式一次直接定义好全部字段的映射规则。例如咱们要定义BookDto到第一做者（Author）的ContactInfo的映射，使用ConstructUsing方式，咱们能够： 

  1. var map = Mapper.CreateMap<BookDto,ContactInfo>();  
  2. map.ConstructUsing(s => new ContactInfo  
  3.                                           {  
  4.                                               Blog = s.FirstAuthorBlog,  
  5.                                               Email = s.FirstAuthorEmail,  
  6.                                               Twitter = s.FirstAuthorTwitter  
  7.                                           });  

而后，就能够按照咱们熟悉的方式来使用了： 

  1. BookDto dto = new BookDto  
  2.                         {  
  3.                             FirstAuthorEmail = "matt.rogen@abc.com",  
  4.                             FirstAuthorBlog = "matt.amazon.com",  
  5.                         };  
  6. ContactInfo contactInfo = Mapper.Map<BookDto, ContactInfo>(dto);  

若是须要映射的2个类型有部分字段名称相同，又有部分字段名称不一样呢？还好AutoMapper给咱们提供的Convention或Configuration方式并非“异或的”，咱们能够结合使用两种方式，为名称不一样的字段配置映射规则，而对于名称相同的字段则忽略配置。  例如对于前面提到的AddressDto到Address的映射，假如AddressDto的字段Country不叫Country叫CountryName，那么在写AddressDto到Address的映射规则时，只须要： 

  1. var map = Mapper.CreateMap<AddressDto, Address>();  
  2. map.ForMember(d => d.Country, opt => opt.MapFrom(s => s.CountryName));  

对于City、Street和PostCode无需定义任何规则，AutoMapper仍然能够帮咱们进行正确的映射。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程