Use AutoMapper to achieve free conversion between Dto and Model (middle)

Note: The code for this series of articles can be downloaded here.

In the previous article we constructed a complete application scenario, including our Model, Dto and the conversion rules between them. Now you can roll up your sleeves and start our AutoMapper journey.
[2] Implement zero-configuration object mapping in Convention mode
Our AddressDto and Address structures are exactly the same, and the field names are also exactly the same. For such type conversion, AutoMapper provides us with Convention, as its official website says:

Quote

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

What we have to do All you need to do is tell AutoMapper the two types to be mapped (call the Static method CreateMap of the Mapper class and pass in the type to be mapped):

C# code

Mapper.CreateMap();

Then Let AutoMapper take care of everything for us:

C# code

AddressDto dto = new Address Dto

{

Country = "China",

City = "Beijing",

Street = "Dongzhimen Street",

PostCode = "100001"

};

Address address = Mapper.Map(Dto);

address.Country.ShouldEqual("China");

address .City.ShouldEqual(" Beijing");

address.Street.ShouldEqual("Dongzhimen Street");

address.PostCode.ShouldEqual("100001");

If there is an attribute with an empty value in AddressDto, AutoMapper will Set the corresponding properties in Address to empty:

C# code

Address address = Mapper.Map(new AddressDto

                                                                                                                                                                                                                  .City.ShouldBeNull();

address.Street.ShouldBeNull();

address.PostCode.ShouldBeNull();

Even if an empty AddressDto is passed in, AutoMapper will help us get an empty Address object .

C# code

Address address = Mapper.Map(null);

address.ShouldBeNull();

Do not treat this Convention mapping method as a "toy", it is It is still quite powerful when mapping complex types with the same field names.

For example, consider our BookStoreDto to BookStore mapping. The field names of both are exactly the same, but the field types are inconsistent. If we have defined the mapping rules from BookDto to Book, plus the mapping from AddressDto to Address in the Convention mode, we can use "zero configuration" to implement the mapping from BookStoreDto to BookStore:

C# code

IMappingExpression expression = Mapper.CreateMap();

// Define mapping rules from BookDto to Book here

Mapper.CreateMap();

Mapper.C reateMap

Then we can convert BookStoreDto directly:

C# code

BookStoreDto dto = new BookStoreDto

                                  

                           Name = "My Store",  

                           Address = new AddressDto  

                                         {  

                                             City = "Beijing"  

                                         },  

                           Books = new List  

                                       {  

                                           new BookDto {Title = "RESTful Web Service"},  

                                           new BookDto {Title = "Ruby for Rails"},  

                                       }  

                       };  

BookStore bookStore = Mapper.Map(dto);  

bookStore.Name.ShouldEqual("My Store");  

bookStore.Address.City.ShouldEqual("Beijing");  

bookStore.Books.Count.ShouldEqual(2);  

bookStore.Books.First().Title.ShouldEqual("RESTful Web Service");  

bookStore.Books.Last().Title.ShouldEqual("Ruby for Rails");  

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

C#代码  

var map = Mapper.CreateMap();  

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方式，我们可以： 

C#代码  

var map = Mapper.CreateMap();  

map.ConstructUsing(s => new ContactInfo

                            Blog = s.FirstAuthorBlog,

                                                     ​​​We use it in the familiar way:

C# code

BookDto dto = new BookDto

uthorEmail = "matt.rogen@abc.com",

                                                                                                                    .

}; tContactinfo contactinfo = mapper.map & lt; bookdto, contaltinfo & gt; (dto); Fortunately, the Convention or Configuration method that AutoMapper provides us is not "XOR". We can use the two methods in combination to configure mapping rules for fields with different names, while ignoring the configuration for fields with the same name.

For example, for the previously mentioned mapping from AddressDto to Address, if the field Country of AddressDto is not called Country but is called CountryName, then when writing the mapping rule from AddressDto to Address, you only need:

C# code

var map = Mapper. CreateMap();

map.ForMember(d => d.Country, opt => opt.MapFrom(s => s.CountryName));

For City, Street and PostCode There is no need to define any rules, AutoMapper can still help us perform correct mapping.