原文:
AutoMapper 使用总结1
初识AutoMapper
在开始本篇文章之前，先来思考一个问题：一个项目分多层架构，如显示层、业务逻辑层、服务层、数据访问层。层与层访问需要数据载体，也就是类。如果多层通用一个类，一则会暴露出每层的字段，二者会使类字段很多，而且会出现很多冗余字段，这种方式是不可取的；如果每层都使用不同的类，则层与层调用时，一个字段一个字段的赋值又会很麻烦。针对第二种情况，可以使用AutoMapper来帮助我们实现类字段的赋值及转换。
AutoMapper是一个对象映射器，它可以将一个一种类型的对象转换为另一种类型的对象。AutoMapper提供了映射规则及操作方法，使我们不用过多配置就可以映射两个类。
安装AutoMapper
通过Nuget安装AutoMapper，本次使用版本为6.2.2。
AutoMapper配置
初始化
先创建两个类用于映射：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
class
ProductEntity
{
public
string
Name {
get
;
set
; }
public
decimal
Amount {
get
;
set
; }
}
public
class
ProductDTO
{
public
string
Name {
get
;
set
; }
public
decimal
Amount {
get
;
set
; }
}
|
Automapper可以使用静态类和实例方法来创建映射，下面分别使用这两种方式来实现 ProductEntity -> ProductDTO的映射。
- 使用静态方式
|
1
2
|
Mapper.Initialize(cfg => cfg.CreateMap<ProductEntity, ProductDTO>());
var
productDTO = Mapper.Map<ProductDTO>(productEntity);
|
- 使用实例方法
|
1
2
3
|
MapperConfiguration configuration =
new
MapperConfiguration(cfg => cfg.CreateMap<ProductEntity, ProductDTO>());
var
mapper = configuration.CreateMapper();
var
productDTO = mapper.Map<ProductDTO>(productEntity);
|
完整的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[TestMethod]
public
void
TestInitialization()
{
var
productEntity =
new
ProductEntity()
{
Name =
"Product"
+ DateTime.Now.Ticks,
Amount = 10
};
Mapper.Initialize(cfg => cfg.CreateMap<ProductEntity, ProductDTO>());
var
productDTO = Mapper.Map<ProductDTO>(productEntity);
Assert.IsNotNull(productDTO);
Assert.IsNotNull(productDTO.Name);
Assert.IsTrue(productDTO.Amount > 0);
}
|
Profiles设置
除了使用以上两总方式类配置映射关系，也可以使用Profie配置来实现映射关系。
创建自定义的Profile需要继承Profile类：
|
1
2
3
4
5
6
7
8
|
public
class
MyProfile : Profile
{
public
MyProfile()
{
CreateMap<ProductEntity, ProductDTO>();
// Other mapping configurations
}
}
|
完成例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[TestMethod]
public
void
TestProfile()
{
var
productEntity =
new
ProductEntity()
{
Name =
"Product"
+ DateTime.Now.Ticks,
Amount = 10
};
var
configuration =
new
MapperConfiguration(cfg => cfg.AddProfile<MyProfile>());
var
productDTO = configuration.CreateMapper().Map<ProductDTO>(productEntity);
Assert.IsNotNull(productDTO);
Assert.IsNotNull(productDTO.Name);
Assert.IsTrue(productDTO.Amount > 0);
}
|
除了使用AddProfile，也可以使用AddProfiles添加多个配置；同样，可以同时使用Mapper和Profile，也可以添加多个配置：
|
1
2
3
4
5
|
var
configuration =
new
MapperConfiguration(cfg =>
{
cfg.AddProfile<MyProfile>();
cfg.CreateMap<ProductEntity, ProductDTO>();
});
|
扁平化映射
AutoMapper先映射名字一致的字段，如果没有，则会尝试使用以下规则来映射：
- 目标中字段去掉前缀“Get”后的部分
- 分割目标字段(根据Pascal命名方式)为单个单词
先创建用到的映射类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public
class
Product
{
public
Supplier Supplier {
get
;
set
; }
public
string
Name {
get
;
set
; }
public
decimal
GetAmount()
{
return
10;
}
}
public
class
Supplier
{
public
string
Name {
get
;
set
; }
}
public
class
ProductDTO
{
public
string
SupplierName {
get
;
set
; }
public
decimal
Amount {
get
;
set
; }
}
|
AutoMapper会自动实现Product.Supplier.Name -> ProductDTO.SupplierName, Product.GetTotal -> ProductDTO.Total的映射。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
[TestMethod]
public
void
TestFalttening()
{
var
supplier =
new
Supplier()
{
Name =
"Supplier"
+ DateTime.Now.Ticks
};
var
product =
new
Product()
{
Supplier = supplier,
Name =
"Product"
+ DateTime.Now.Ticks
};
Mapper.Initialize(cfg => cfg.CreateMap<Product, ProductDTO>());
var
productDTO = Mapper.Map<ProductDTO>(product);
Assert.IsNotNull(productDTO);
Assert.IsNotNull(productDTO.SupplierName);
Assert.IsTrue(productDTO.Amount > 0);
}
|
集合验证
AutoMapper除了可以映射单个对象外，也可以映射集合对象。AutoMapper源集合类型支持以下几种：
- IEnumerable
- IEnumerable<T>
- ICollection
- ICollection<T>
- IList
- IList<T>
- List<T>
- Arrays
简单类型映射：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public
class
Source
{
public
int
Value {
get
;
set
; }
}
public
class
Destination
{
public
int
Value {
get
;
set
; }
}
[TestMethod]
public
void
TestCollectionSimple()
{
Mapper.Initialize(cfg => cfg.CreateMap<Source, Destination>());
var
sources =
new
[]
{
new
Source {Value = 1},
new
Source {Value = 2},
new
Source {Value = 3}
};
IEnumerable<Destination> ienumerableDest = Mapper.Map<Source[], IEnumerable<Destination>>(sources);
ICollection<Destination> icollectionDest = Mapper.Map<Source[], ICollection<Destination>>(sources);
IList<Destination> ilistDest = Mapper.Map<Source[], IList<Destination>>(sources);
List<Destination> listDest = Mapper.Map<Source[], List<Destination>>(sources);
Destination[] arrayDest = Mapper.Map<Source[], Destination[]>(sources);
}
|
复杂对象映射：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public
class
Order
{
private
IList<OrderLine> _lineItems =
new
List<OrderLine>();
public
OrderLine[] LineItems {
get
{
return
_lineItems.ToArray(); } }
public
void
AddLineItem(OrderLine orderLine)
{
_lineItems.Add(orderLine);
}
}
public
class
OrderLine
{
public
int
Quantity {
get
;
set
; }
}
public
class
OrderDTO
{
public
OrderLineDTO[] LineItems {
get
;
set
; }
}
public
class
OrderLineDTO
{
public
int
Quantity {
get
;
set
; }
}
[TestMethod]
public
void
TestCollectionNested()
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap<Order, OrderDTO>();
cfg.CreateMap<OrderLine, OrderLineDTO>();
});
var
order =
new
Order();
order.AddLineItem(
new
OrderLine {Quantity = 10});
order.AddLineItem(
new
OrderLine {Quantity = 20});
order.AddLineItem(
new
OrderLine {Quantity = 30});
var
orderDTO = Mapper.Map<OrderDTO>(order);
Assert.IsNotNull(orderDTO);
Assert.IsNotNull(orderDTO.LineItems);
Assert.IsTrue(orderDTO.LineItems.Length > 0);
}
|
投影及条件映射
投影(指定字段)
除了以上使用的自动映射规则，AutoMapper还可以指定映射方式。下面使用ForMemeber指定字段的映射，将一个时间值拆分映射到日期、时、分：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public
class
Calendar
{
public
DateTime CalendarDate {
get
;
set
; }
public
string
Title {
get
;
set
; }
}
public
class
CalendarModel
{
public
DateTime Date {
get
;
set
; }
public
int
Hour {
get
;
set
; }
public
int
Minute {
get
;
set
; }
public
string
Title {
get
;
set
; }
}
[TestMethod]
public
void
TestProjection()
{
var
calendar =
new
Calendar()
{
Title =
"2018年日历"
,
CalendarDate =
new
DateTime(2018, 1, 1, 11, 59, 59)
};
Mapper.Initialize(cfg => cfg
.CreateMap<Calendar, CalendarModel>()
.ForMember(dest => dest.Date, opt => opt.MapFrom(src =>src.CalendarDate.Date))
.ForMember(dest => dest.Hour, opt => opt.MapFrom(src => src.CalendarDate.Hour))
.ForMember(dest => dest.Minute, opt => opt.MapFrom(src => src.CalendarDate.Minute)));
var
calendarModel = Mapper.Map<CalendarModel>(calendar);
Assert.AreEqual(calendarModel.Date.Ticks,
new
DateTime(2018, 1, 1).Ticks);
Assert.AreEqual(calendarModel.Hour, 11);
Assert.AreEqual(calendarModel.Minute, 59);
}
|
条件映射
有些情况下，我们会考虑添加映射条件，比如，某个值不符合条件时，不允许映射。针对这种情况可以使用ForMember中的Condition：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public
class
Source
{
public
int
Value {
get
;
set
; }
}
public
class
Destination
{
public
uint
Value {
get
;
set
; }
}
[TestMethod]
public
void
TestConditionByCondition()
{
var
source =
new
Source()
{
Value = 3
};
//如果Source.Value > 0, 则执行映射；否则，映射失败
Mapper.Initialize(cfg => cfg
.CreateMap<Source, Destination>()
.ForMember(dest => dest.Value, opt => opt.Condition(src => src.Value > 0)));
var
destation = Mapper.Map<Destination>(source);
//如果不符合条件，则抛出异常
Assert.IsTrue(destation.Value.Equals(3));
}
|
如果要映射的类符合一定的规则，而且有很多，针对每个类都创建一个CreaterMapper会很麻烦。可以使用AddConditionalObjectMapper指定对象映射规则，这样就不用每个映射关系都添加一个CreateMapper。另外，也可以使用AddMemberConfiguration指定字段的映射规则，比如字段的前后缀：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public
class
Product
{
public
string
Name {
get
;
set
; }
public
int
Count {
get
;
set
; }
}
public
class
ProductModel
{
public
string
NameModel {
get
;
set
; }
public
int
CountMod {
get
;
set
; }
}
[TestMethod]
public
void
TestConditionByConfiguration()
{
var
product =
new
Product()
{
Name =
"Product"
+ DateTime.Now.Ticks,
Count = 10
};
var
config =
new
MapperConfiguration(cfg =>
{
//对象映射规则: 通过以下配置，可以映射所有”目标对象的名称“等于“源对象名称+Model”的类，而不用单个添加CreateMapper映射
cfg.AddConditionalObjectMapper().Where((s, d) => d.Name == s.Name +
"Model"
);
//字段映射规则: 通过以下配置，可以映射“源字段”与“目标字段+Model或Mod”的字段
cfg.AddMemberConfiguration().AddName<PrePostfixName>(_ => _.AddStrings(p => p.DestinationPostfixes,
"Model"
,
"Mod"
));
});
var
mapper = config.CreateMapper();
var
productModel = mapper.Map<ProductModel>(product);
Assert.IsTrue(productModel.CountMod == 10);
}
|
需要注意的一点是，添加了以上配置，如果目标对象中有字段没有映射到，则会抛出异常。
值转换
如果配置了值转换，AutoMapper会将修改转换后的值以符合配置的规则。比如，配置目标对象中的值添加符号“@@”：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public
class
Source
{
public
string
Name {
get
;
set
; }
}
public
class
Destination
{
public
string
Name {
get
;
set
; }
}
[TestMethod]
public
void
TestValueTransfer()
{
var
source =
new
Source()
{
Name =
"Bob"
};
Mapper.Initialize(cfg =>
{
cfg.CreateMap<Source, Destination>();
cfg.ValueTransformers.Add<
string
>(val =>
string
.Format(
"@{0}@"
, val));
});
var
destation = Mapper.Map<Destination>(source);
Assert.AreEqual(
"@Bob@"
, destation.Name);
}
|
空值替换
如果要映射的值为Null，则可以使用NullSubstitute指定Null值的替换值：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public
class
Source
{
public
string
Name {
get
;
set
; }
}
public
class
Destination
{
public
string
Name {
get
;
set
; }
}
[TestMethod]
public
void
TestValueTransfer()
{
var
source =
new
Source()
{
};
Mapper.Initialize(cfg =>
{
cfg.CreateMap<Source, Destination>()
.ForMember(dest => dest.Name, opt => opt.NullSubstitute(
"其他值"
));
});
var
destation = Mapper.Map<Destination>(source);
Assert.AreEqual(
"其他值"
, destation.Name);
}
|
配置验证及设置
配置了映射，但是如何确定是否映射成功或者是否有字段没有映射呢？可以添加Mapper.AssertConfigurationIsValid();来验证是否映射成功。默认情况下，目标对象中的字段都被映射到后，AssertConfigurationIsValid才会返回True。也就是说，源对象必须包含所有目标对象，这样在大多数情况下不是我们想要的，我们可以使用下面的方法来指定验证规则：
- 指定单个字段不验证
- 指定整个Map验证规则
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
public
class
Product
{
public
string
Name {
get
;
set
; }
public
int
Amount {
get
;
set
; }
}
public
class
ProductModel
{
public
string
Name {
get
;
set
; }
public
int
Amount {
get
;
set
; }
public
string
ViewName {
get
;
set
; }
}
public
class
ProductDTO
{
public
string
Name {
get
;
set
; }
public
int
Amount {
get
;
set
; }
public
string
ViewName {
get
;
set
; }
}
[TestMethod]
public
void
TestValidation()
{
var
product =
new
Product()
{
Name =
"Product"
+ DateTime.Now.Ticks,
Amount = 10
};
Mapper.Initialize(cfg =>
{
//1. 指定字段映射方式
cfg.CreateMap<Product, ProductModel>()
.ForMember(dest => dest.ViewName, opt => opt.Ignore());
//如果不添加此设置，会抛出异常
//2. 指定整个对象映射方式
//MemberList:
// Source: 检查源对象所有字段映射成功
// Destination：检查目标对象所有字段映射成功
// None: 跳过验证
cfg.CreateMap<Product, ProductDTO>(MemberList.Source);
});
var
productModel = Mapper.Map<ProductModel>(product);
var
productDTO = Mapper.Map<ProductDTO>(product);
//验证映射是否成功
Mapper.AssertConfigurationIsValid();
}
|
设置转换前后行为
有的时候你可能会在创建映射前后对数据做一些处理，AutoMapper就提供了这种方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
public
class
Source
{
public
string
Name {
get
;
set
; }
public
int
Value {
get
;
set
; }
}
public
class
Destination
{
public
string
Name {
get
;
set
; }
public
int
Value {
get
;
set
; }
}
[TestMethod]
public
void
TestBeforeOrAfter()
{
var
source =
new
Source()
{
Name =
"Product"
+ DateTime.Now.Ticks,
};
Mapper.Initialize(cfg =>
{
cfg.CreateMap<Source, Destination>()
.BeforeMap((src, dest) => src.Value = src.Value + 10)
.AfterMap((src, dest) => dest.Name =
"Pobin"
);
});
var
productModel = Mapper.Map<Destination>(source);
Assert.AreEqual(
"Pobin"
, productModel.Name);
}
|
反向映射
从6.1.0开始，AutoMapper通过调用Reverse可以实现反向映射。反向映射根据初始化时创建的正向映射规则来做反向映射：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public
class
Order
{
public
decimal
Total {
get
;
set
; }
public
Customer Customer {
get
;
set
; }
}
public
class
Customer
{
public
string
Name {
get
;
set
; }
}
public
class
OrderDTO
{
public
decimal
Total {
get
;
set
; }
public
string
CustomerName {
get
;
set
; }
}
[TestMethod]
public
void
TestReverseMapping()
{
var
customer =
new
Customer
{
Name =
"Tom"
};
var
order =
new
Order
{
Customer = customer,
Total = 20
};
Mapper.Initialize(cfg => {
cfg.CreateMap<Order, OrderDTO>()
.ForMember(dest => dest.CustomerName, opt => opt.MapFrom(src => src.Customer.Name))
//正向映射规则
.ReverseMap();
//设置反向映射
});
//正向映射
var
orderDTO = Mapper.Map<OrderDTO>(order);
//反向映射：使用ReverseMap,不用再创建OrderDTO -> Order的映射，而且还能保留正向的映射规则
var
orderConverted = Mapper.Map<Order>(orderDTO);
Assert.IsNotNull(orderConverted.Customer);
Assert.AreEqual(
"Tom"
, orderConverted.Customer.Name);
}
|
如果反向映射中不想使用原先的映射规则，也可以取消掉：
|
1
2
3
4
5
6
|
Mapper.Initialize(cfg => {
cfg.CreateMap<Order, OrderDTO>()
.ForMember(dest => dest.CustomerName, opt => opt.MapFrom(src => src.Customer.Name))
//正向映射规则
.ReverseMap()
.ForPath(src => src.Customer.Name, opt => opt.Ignore());
//设置反向映射
});
|
自定义转换器
有些情况下目标字段类型和源字段类型不一致，可以通过类型转换器实现映射，类型转换器有三种实现方式：
|
1
2
3
|
void
ConvertUsing(Func<TSource, TDestination> mappingFunction);
void
ConvertUsing(ITypeConverter<TSource, TDestination> converter);
void
ConvertUsing<TTypeConverter>()
where
TTypeConverter : ITypeConverter<TSource, TDestination>;
|
下面通过一个例子来演示下以上三种类型转换器的使用方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
namespace
AutoMapperSummary
{
[TestClass]
public
class
CustomerTypeConvert
{
public
class
Source
{
public
string
Value1 {
get
;
set
; }
public
string
Value2 {
get
;
set
; }
public
string
Value3 {
get
;
set
; }
}
public
class
Destination
{
public
int
Value1 {
get
;
set
; }
public
DateTime Value2 {
get
;
set
; }
public
Type Value3 {
get
;
set
; }
}
public
class
DateTimeTypeConverter : ITypeConverter<
string
, DateTime>
{
public
DateTime Convert(
string
source, DateTime destination, ResolutionContext context)
{
return
System.Convert.ToDateTime(source);
}
}
public
class
TypeTypeConverter : ITypeConverter<
string
, Type>
{
public
Type Convert(
string
source, Type destination, ResolutionContext context)
{
return
Assembly.GetExecutingAssembly().GetType(source);
}
}
[TestMethod]
public
void
TestTypeConvert()
{
var
config =
new
MapperConfiguration(cfg =>
{
cfg.CreateMap<
string
,
int
>().ConvertUsing((
string
s) => Convert.ToInt32(s));
cfg.CreateMap<
string
, DateTime>().ConvertUsing(
new
DateTimeTypeConverter());
cfg.CreateMap<
string
, Type>().ConvertUsing<TypeTypeConverter>();
cfg.CreateMap<Source, Destination>();
});
config.AssertConfigurationIsValid();
//验证映射是否成功
var
source =
new
Source
{
Value1 =
"20"
,
Value2 =
"2018/1/1"
,
Value3 =
"AutoMapperSummary.CustomerTypeConvert+Destination"
};
var
mapper = config.CreateMapper();
var
destination = mapper.Map<Source, Destination>(source);
Assert.AreEqual(
typeof
(Destination), destination.Value3);
}
}
}
|
自定义解析器
使用AutoMapper的自带解析规则，我们可以很方便的实现对象的映射。比如：源/目标字段名称一致，“Get/get + 源字段“与"目标字段"一致等。除了这些简单的映射，还可以使用ForMember指定字段映射。但是，某些情况下，解析规则会很复杂，使用自带的解析规则无法实现。这时可以自定义解析规则，可以通过以下三种方式使用自定义的解析器：
|
1
2
3
|
ResolveUsing<TValueResolver>
ResolveUsing(
typeof
(CustomValueResolver))
ResolveUsing(aValueResolverInstance)
|
下面通过一个例子来演示如何使用自定义解析器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
public
class
Source
{
public
string
FirstName {
get
;
set
; }
public
string
LastName {
get
;
set
; }
}
public
class
Destination
{
public
string
Name {
get
;
set
; }
}
/// <summary>
/// 自定义解析器: 组合姓名
/// </summary>
public
class
CustomResolver : IValueResolver<Source, Destination,
string
>
{
public
string
Resolve(Source source, Destination destination,
string
destMember, ResolutionContext context)
{
if
(source !=
null
&& !
string
.IsNullOrEmpty(source.FirstName) && !
string
.IsNullOrEmpty(source.LastName))
{
return
string
.Format(
"{0} {1}"
, source.FirstName, source.LastName);
}
return
string
.Empty;
}
}
[TestMethod]
public
void
TestResolver()
{
Mapper.Initialize(cfg =>
cfg.CreateMap<Source, Destination>()
.ForMember(dest => dest.Name, opt => opt.ResolveUsing<CustomResolver>()));
Mapper.AssertConfigurationIsValid();
var
source =
new
Source
{
FirstName =
"Michael"
,
LastName =
"Jackson"
};
var
destination = Mapper.Map<Source, Destination>(source);
Assert.AreEqual(
"Michael Jackson"
, destination.Name);
}
|
AutoMapper封装
AutoMapper功能很强大，自定义配置支持也非常好，但是真正项目中使用时却很少用到这么多功能，而且一般都会对AutoMapper进一步封装使用。一方面使用起来方面，另外一方面也可以使代码统一。下面的只是做一个简单的封装，还需要结合实际项目使用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
/// <summary>
/// AutoMapper帮助类
/// </summary>
public
class
AutoMapperManager
{
private
static
readonly
MapperConfigurationExpression MapperConfiguration =
new
MapperConfigurationExpression();
static
AutoMapperManager()
{
}
private
AutoMapperManager()
{
AutoMapper.Mapper.Initialize(MapperConfiguration);
}
public
static
AutoMapperManager Instance {
get
; } =
new
AutoMapperManager();
/// <summary>
/// 添加映射关系
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
public
void
AddMap<TSource, TDestination>()
where
TSource :
class
,
new
()
where
TDestination :
class
,
new
()
{
MapperConfiguration.CreateMap<TSource, TDestination>();
}
/// <summary>
/// 获取映射值
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public
TDestination Map<TDestination>(
object
source)
where
TDestination :
class
,
new
()
{
if
(source ==
null
)
{
return
default
(TDestination);
}
return
Mapper.Map<TDestination>(source);
}
/// <summary>
/// 获取集合映射值
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public
IEnumerable<TDestination> Map<TDestination>(IEnumerable source)
where
TDestination :
class
,
new
()
{
if
(source ==
null
)
{
return
default
(IEnumerable<TDestination>);
}
return
Mapper.Map<IEnumerable<TDestination>>(source);
}
/// <summary>
/// 获取映射值
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public
TDestination Map<TSource, TDestination>(TSource source)
where
TSource :
class
,
new
()
where
TDestination :
class
,
new
()
{
if
(source ==
null
)
{
return
default
(TDestination);
}
return
Mapper.Map<TSource, TDestination>(source);
}
/// <summary>
/// 获取集合映射值
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public
IEnumerable<TDestination> Map<TSource, TDestination>(IEnumerable<TSource> source)
where
TSource :
class
,
new
()
where
TDestination :
class
,
new
()
{
if
(source ==
null
)
{
return
default
(IEnumerable<TDestination>);
}
return
Mapper.Map<IEnumerable<TSource>, IEnumerable<TDestination>>(source);
}
/// <summary>
/// 读取DataReader内容
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="reader"></param>
/// <returns></returns>
public
IEnumerable<TDestination> Map<TDestination>(IDataReader reader)
{
if
(reader ==
null
)
{
return
new
List<TDestination>();
}
var
result = Mapper.Map<IEnumerable<TDestination>>(reader);
if
(!reader.IsClosed)
{
reader.Close();
}
return
result;
}
}
|
总结
本篇文章列举了AutoMapper的基本使用方式，更多的使用可以参考官方文档：http://automapper.readthedocs.io/en/latest/index.html
