AutoMapper 基本使用
假如两个如下类型：
public class TestA { public int A { get; set; } public string B { get; set; } // 剩下 99 个字段省略 } public class TestB { public int A { get; set; } public string B { get; set; } // 剩下 99 个字段省略 }
我们可以通过 AutoMapper 快速将 TestA 中所有字段的值复制一份到 TestB 中。
创建 TestA 到 TestB 的映射配置：
MapperConfiguration configuration = new MapperConfiguration(cfg => { // TestA -> TestB cfg.CreateMap<TestA, TestB>(); });
创建映射器：
IMapper mapper = configuration.CreateMapper();
使用 .Map() 方法将 TestA 中字段的值复制到 TestB 中。
TestA a = new TestA(); TestB b = mapper.Map<TestB>(a);
映射配置
上面我们用 cfg.CreateMap<TestA, TestB>(); 创建了 TestA 到 TestB 的映射，在不配置的情况下，AutoMapper 默认会映射所有字段。
当然，我们可以在 MapperConfiguration 中，为每个字段定义映射逻辑。
MapperConfiguration 的构造函数定义如下：
public MapperConfiguration(Action<IMapperConfigurationExpression> configure);
这个 IMapperConfigurationExpression 是一个链式函数，可以为映射中的每个字段定义逻辑。
将上面的模型类修改为如下代码：
public class TestA { public int A { get; set; } public string B { get; set; } public string Id { get; set; } } public class TestB { public int A { get; set; } public string B { get; set; } public Guid Id { get; set; } }
创建映射表达式如下：
MapperConfiguration configuration = new MapperConfiguration(cfg => { // TestA -> TestB cfg.CreateMap<TestA, TestB>() // 左边是 TestB 的字段，右边是为字段赋值的逻辑 .ForMember(b => b.A, cf => cf.MapFrom(a => a.A)) .ForMember(b => b.B, cf => cf.MapFrom(a => a.B)) .ForMember(b => b.Id, cf => cf.MapFrom(a => Guid.Parse(a.Id))); });
.ForMember() 方法用于创建一个字段的映射逻辑，有两个表达式 ({表达式} , {表达式2})，其中表达式1代表 TestB 映射的字段；表达式2代表这个字段的值从何处来。
表达式2有常用几种映射来源：
.MapFrom()从 TestA 取得；.AllowNull()设置空值；.Condition()有条件地映射；.ConvertUsing()类型转换；
这里笔者演示一下 .ConvertUsing() 的使用方法：
cfg.CreateMap<string, Guid>().ConvertUsing(typeof(GuidConverter));
这样可以将 string 转换为 Guid，其中 GuidConverter 是 .NET 自带的转换器，我们也可以自定义转换器。
当然，即使不定义转换器，string 默认也可以转换成 Guid，因为 AutoMapper 比较机智。
对于其它内容，这里不再赘述，有兴趣可查阅文档。
映射检查
假如 TestA 有的字段 TestB 没有，则不复制；TestB 有的字段 TestA 中没有，则此字段不做处理(初始化值)。
默认情况，TestA 跟 TestB 中的字段不太一致的话，可能有些地方容易造成忽略，开发者可以使用检查器去检查。
只需要在定义 MapperConfiguration 以及映射关系后，调用：
configuration.AssertConfigurationIsValid();
这个检查方法，只应在 Debug 下使用。
当映射没有被覆盖时
你可以在 TestB 中增加一个 D 字段，然后启动程序，会提示：
AutoMapper.AutoMapperConfigurationException
因为 TestB 中的 D 字段，没有相应的映射。这样，当我们在编写映射关系时，就可以避免漏值的情况。
性能
刚使用 AutoMapper 时，大家可能会在想 AutoMapper 的原理，反射？性能如何？
这里我们写一个示例用 BenchmarkDotNet 测试一下。
定义 TestA：
public class TestB { public int A { get; set; } public string B { get; set; } public int C { get; set; } public string D { get; set; } public int E { get; set; } public string F { get; set; } public int G { get; set; } public string H { get; set; } }
定义 TestB 的属性同上。
[SimpleJob(runtimeMoniker: RuntimeMoniker.NetCoreApp31)] public class Test { private static readonly MapperConfiguration configuration = new MapperConfiguration(cfg => { cfg.CreateMap<TestA, TestB>(); }); private static readonly IMapper mapper = configuration.CreateMapper(); private readonly TestA a = new TestA { A = 1, B = "aaa", C = 1, D = "aaa", E = 1, F = "aaa", G = 1, H = "aaa", }; [Benchmark] public TestB Get1() { return new TestB { A = a.A, B = a.B, C = a.C, D = a.D, E = a.E, F = a.F, G = a.G, H = a.H }; } [Benchmark] public TestB Get2() { return mapper.Map<TestB>(a); } [Benchmark] public TestA Get3() { return mapper.Map<TestA>(a); } }
测试结果如下：
BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042 Intel Core i7-3740QM CPU 2.70GHz (Ivy Bridge), 1 CPU, 8 logical and 4 physical cores .NET Core SDK=5.0.200-preview.20601.7 [Host] : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT .NET Core 3.1 : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT Job=.NET Core 3.1 Runtime=.NET Core 3.1 | Method | Mean | Error | StdDev | |------- |----------:|---------:|---------:| | Get1 | 16.01 ns | 0.321 ns | 0.284 ns | | Get2 | 204.63 ns | 3.009 ns | 2.349 ns | | Get3 | 182.53 ns | 2.215 ns | 2.072 ns | Outliers Test.Get1: .NET Core 3.1 -> 1 outlier was removed (25.93 ns) Test.Get2: .NET Core 3.1 -> 3 outliers were removed (259.39 ns..320.99 ns)
可以看到，性能相差了 10 倍。
在提高灵活性等情况下，会牺牲一些性能，主要不是大量计算的情况下，并不会有太大性能问题。
Profile 配置
除了 MapperConfiguration 外，我们还可以使用继承 Profile 的方式定义映射配置，实现更小粒度的控制以及模块化，ABP 框架中正是推荐了 AutoMapper 的此种方式，配合模块化。
示例如下：
public class MyProfile : Profile { public MyProfile() { // 这里就不赘述了 base.CreateMap<TestA, TestB>().ForMember(... ...); } }
如果我们使用 ABP，那么每个模块都可以定义一个 Profiles 文件夹，在里面定义一些 Profile 规则。
一种映射定义一个 Profile 类？这样太浪费空间了；一个模块定义一个 Profile 类？这样太杂了。不同的程序有自己的架构，按照项目架构选择 Profile 的粒度就好。
依赖注入
AutoMapper 依赖注入很简单，前面我们学会了 Profile 定义配置映射，这样我们就可用很方便地使用依赖注入框架处理映射。
①
我们在 ASP.NET Core 的 StartUp 或者 ConsoleApp 的 IServiceCollection 中，注入：
services.AddAutoMapper(assembly1, assembly2 /*, ...*/);
AutoMapper 会自动扫描 程序集(Assembly) 中类型，把继承了 Profile 的类型提取出来。
②
如果你想更小粒度地控制 AutoMapper ，则可以使用：
services.AddAutoMapper(type1, type2 /*, ...*/);
.AddAutoMapper() 注册的 AutoMapper 的生命周期为 transient。
③
如果你不喜欢 Profile ，那么还可以继续使用前面的 MapperConfiguration，示例代码如下：
MapperConfiguration configuration = new MapperConfiguration(cfg => { cfg.CreateMap<TestA, TestB>(); }); services.AddAutoMapper(configuration);
之后我们可以通过依赖注入使用 AutoMapper，使用形式是 IMapper 类型：
public class HomeController { private readonly IMapper _mapper; public HomeController(IMapper mapper) { _mapper = mapper; } }
IMapper 有一个 .ProjectTo<>() 方法，可以帮助处理 IQueryable 查询。
List<TestA> a = new List<TestA>(); ... ... _ = mapper.ProjectTo<TestB>(a.AsQueryable()).ToArray();
或者：
_ = a.AsQueryable().ProjectTo<TestB>(configuration).ToArray();
还可以配置 EFCore 使用：
_ = _context.TestA.ProjectTo<TestB>(configuration).ToArray(); _ = _context.TestA.ProjectTo<TestB>(mapper.ConfigurationProvider).ToArray();
表达式与 DTO
AutoMapper 有着不少拓展，这里笔者介绍一下 AutoMapper.Extensions.ExpressionMapping，在 Nuget 里面可以搜索到。
AutoMapper.Extensions.ExpressionMapping 这个拓展实现了大量的表达式树查询，这个库实现了 IMapper 拓展。
假如：
public class DataDBContext : DbContext { public DbSet<TestA> TestA { get; set; } } ... ... DataDBContext data = ... ...
配置：
private static readonly MapperConfiguration configuration = new MapperConfiguration(cfg => { cfg.AddExpressionMapping(); cfg.CreateMap<TestA, TestB>(); });
假如，你要实现过滤功能：
// It's of no use Expression<Func<TestA, bool>> filter = item => item.A > 0; var f = mapper.MapExpression<Expression<Func<TestA, bool>>>(filter); var someA = data.AsQueryable().Where(f); // data is _context or conllection
当然，这段代码没有任何用处。
你可以实现自定义的拓展方法、表达式树，更加便利地对 DTO 进行操作。
下面是示例：
public static class Test { // It's of no use //public static TB ToType<TA, TB>(this TA a, IMapper mapper, Expression<Func<TA, TB>> func) //{ // //Func<TA, TB> f1 = mapper.MapExpression<Expression<Func<TA, TB>>>(func).Compile(); // //TB result = f1(a); // return mapper.MapExpression<Expression<Func<TA, TB>>>(func).Compile()(a); //} public static IEnumerable<TB> ToType<TA, TB>(this IEnumerable<TA> list, IMapper mapper, Expression<Func<TA, TB>> func) { var one = mapper.MapExpression<Expression<Func<TA, TB>>>(func).Compile(); List<TB> bList = new List<TB>(); foreach (var item in list) { bList.Add(one(item)); } return bList; } }
当你查询时，可以这样使用这个拓展：
_ = _context.TestA.ToArray().ToType(mapper, item => mapper.Map<TestB>(item));
