C#技术栈入门到精通系列18——映射框架AutoMapper

阅读目录

1、介绍
2、快速入门
3、功能应用
　　3.1、配置
　　3.2、自定义映射属性配对
　　3.3、条件映射
　　3.4、自定义映射前后事件
　　3.5、自定义类型转换
　　3.6、自定义值解析器
　　3.7、值转换器
　　3.8、泛型映射
　　3.9、枚举映射
4、参考

返回系列文章目录 

 

案例代码下载

 1、介绍

　　AutoMapper 是一个简单的小库，基于命名约定的对象到对象的映射工具。只要2个对象的属性具有相同名字（或者符合它规定的命名约定），AutoMapper就可以替我们自动在2个对象间进行属性值的映射。如果有不符合约定的属性，或者需要自定义映射行为，就需要我们事先告诉AutoMapper，所以在使用 Map(src,dest)进行映射之前，必须使用 CreateMap() 进行配置。注意：将源映射到目标时，AutoMapper 将忽略空引用异常，可以通过自定义解析器来更改这种设置。       

 

2、快速入门

　　使用之前需要Nuget引入  AutoMapper 11.0.0 ，分别创建源对象UserInfo和目标对象UserInfoDto，建立映射关系后把源对象映射成目标对象。注意：经验法则是一个应用程序域AppDomian只需要一个AutoMapper配置对象  MapperConfiguration  实例，并且应该在启动初期进行实例化。   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GettingStarted
{
    public class UserInfo
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public bool Sex { get; set; }
        public decimal Salary { get; set; } //薪水

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GettingStarted
{
    public class UserInfoDto
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public bool Sex { get; set; }
        public override string ToString()
        {
            return string.Join(",", this.GetType().GetProperties().Select(p => p.Name).ToArray());
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GettingStarted
{
    public class GettingStartedMain
    {
        public static void Test1()
        {
            //1、创建映射规则
            var config = new MapperConfiguration(cfg => cfg.CreateMap<UserInfo, UserInfoDto>());
            var mapper = config.CreateMapper();//或者：var mapper = new Mapper(config);
            //2、把对象映射成需要的对象
            var userInfo = new UserInfo { Name = "BigBox777", Age = 18, Sex = true, Salary = 1.00m };
            UserInfoDto userInfoDto = mapper.Map<UserInfoDto>(userInfo);
            Console.WriteLine(userInfoDto.ToString());
        }
    }
}

 

3、功能应用

3.1、配置

　　通常会新建一个配置类用来存放AutoMapper映射配置，下面例子是新建一个AutoMapperProfile类来存放AutoMapper的配置关系，注意：①AutoMapperProfile类必须继承Profile。②经验法则是一个应用程序域AppDomian只需要一个AutoMapper配置对象  MapperConfiguration 实例，并且应该在启动初期进行实例化。      

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    public class Student
    {
        public string Name { get; set; }
        public string StudentNumber { get; set; }
        public double Stature { get; set; } //身高
        public int ChemistryAchievement { get; set; }
        public int MathematicsAchievement { get; set; }
        public int EnglishAchievement { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    public class StudentDto
    {
        public string Name { get; set; }
        public string StudentNumber { get; set; }
        public int ChemistryAchievement { get; set; }
        public override string ToString()
        {
            return string.Join(",", this.GetType().GetProperties().Select(p => p.Name).ToArray());
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class AutoMapperConfigurationMain
    {
        public static void Test1()
        {
            //扫描读取配置类
            var config = new MapperConfiguration(
                cfg => cfg.AddProfile<AutoMapperProfile>());
            var mapper = config.CreateMapper();
            var student = new Student()
            {
                Name = "BigBox777",
                StudentNumber = "668",
                Stature = 198,
                ChemistryAchievement = 100,
                MathematicsAchievement = 100,
                EnglishAchievement = 100,
            };
            StudentDto studentDto = mapper.Map<StudentDto>(student);
            Console.WriteLine(studentDto.ToString());
        }

    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class AutoMapperConfigurationMain
    {
        public static void Test2()
        {
            //AutoMapper 将扫描指定的程序集以查找从 Profile 继承的类并将它们添加到配置中 
            var configuration1 = new MapperConfiguration(cfg => 
                cfg.AddMaps(myAssembly));

            var configuration2 = new MapperConfiguration(cfg =>
                cfg.AddMaps(new[] { "Foo.UI", "Foo.Core" }));

            // Or marker types for assemblies:
            var configuration = new MapperConfiguration(cfg =>
                cfg.AddMaps(new[] { typeof(HomeController), typeof(Entity)});

        }
    }
}

 

3.2、自定义映射属性配对

　　上面的例子都是源类和目标类的字段属性完全一样的情况下的简单映射，本节来介绍通过配置基类  Profile  手动配置源类和目标类映射关系。主要会用到  禁用构造函数映射public void DisableConstructorMapping() 、 清除源属性字段前缀public void ClearPrefixes() 、 替换源字符串public void ReplaceMemberName(string original, string newValue) 、 去除源属性前缀public void RecognizePrefixes(params string[] prefixes) 、 去除源属性后缀public void RecognizePostfixes(params string[] postfixes) 、 去除目标属性前缀public void RecognizeDestinationPrefixes(params string[] prefixes) 、 去除目标属性后缀public void RecognizeDestinationPostfixes(params string[] postfixes) 、 全局忽略源属性public void AddGlobalIgnore(string propertyNameStartingWith) 、  包和源扩展方法public void IncludeSourceExtensionMethods(Type type) 。

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class NamingConventionsProfile:Profile
    {
        public NamingConventionsProfile()
        {
            //建立属性字段对应关系: property_name -> PropertyName
            SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
            DestinationMemberNamingConvention = new PascalCaseNamingConvention();
            CreateMap<Source, Dest>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    public class ReplacingCharactersProfile: Profile
    {
        public ReplacingCharactersProfile()
        {
            //属性匹配之间的字符替换
            ReplaceMemberName("Ä", "A");
            ReplaceMemberName("í", "i");
            ReplaceMemberName("Airlina", "Airline");
            CreateMap<Source, Destination>();
        }
        public class Source
        {
            public int Value { get; set; }
            public int Ävíator { get; set; }
            public int SubAirlinaFlight { get; set; }
        }
        public class Destination
        {
            public int Value { get; set; }
            public int Aviator { get; set; }
            public int SubAirlineFlight { get; set; }
        }
    }

}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class RecognizingPreProfile:Profile
    {
        public RecognizingPreProfile()
        {
            //去除源属性中的frm
            RecognizePrefixes("frm");
            CreateMap<Source, Dest>();
        }
        public class Source
        {
            public int frmValue { get; set; }
            public int frmValue2 { get; set; }
        }
        public class Dest
        {
            public int Value { get; set; }
            public int Value2 { get; set; }
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class RecognizingPostfixesProfile:Profile
    {
        //目标属性后加Dto
        public RecognizingPostfixesProfile()
        {
            RecognizeDestinationPostfixes("Dto");
            CreateMap<Source, Dest>();
        }
        public class Source
        {
            public int Value { get; set; }
            public int Value2 { get; set; }
        }
        public class Dest
        {
            public int ValueDto { get; set; }
            public int Value2Dto { get; set; }
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class GlobalPropertyFieldFilteringProfile:Profile
    {
        //全局属性字段过滤
        public GlobalPropertyFieldFilteringProfile()
        {
            //不映射任何字段
            ShouldMapField = fi => false;
            //映射Public、Private的所有带Getter器的属性
            ShouldMapProperty = pi =>
                pi.GetMethod != null && (pi.GetMethod.IsPublic || pi.GetMethod.IsPrivate);
            CreateMap<Student, StudentDto>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class ConfiguringVisibilityProfile:Profile
    {
        //配置可见性（默认情况下，AutoMapper 只识别公共成员。它可以映射到私有设置器，
        //但如果整个属性是私有/内部的，它将跳过内部/私有方法和属性。要指示 AutoMapper 
        //识别具有其他可见性的成员，请覆盖默认过滤器 ShouldMapField 和/或 ShouldMapProperty ）
        public ConfiguringVisibilityProfile()
        {
            ShouldMapProperty = p => p.GetMethod.IsPublic || p.GetMethod.IsAssembly;
            CreateMap<Student, StudentDto>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class ConfigurationCompilationProfile:Profile
    {
        //配置编译：因为表达式编译可能会占用一些资源，所以 AutoMapper 会在第一个映射上
        //延迟编译类型映射计划。然而，这种行为并不总是可取的，所以你可以告诉 AutoMapper 
        //直接编译它的映射
        public ConfigurationCompilationProfile()
        {
            CreateMap<Student,StudentDto>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.AutoMapperConfiguration
{
    internal class AutoMapperConfigurationMain
    {
        public static void Test5()
        {
            var config = new MapperConfiguration(
                   cfg => cfg.AddProfile<ConfigurationCompilationProfile>());
            config.CompileMappings();
            var mapper = config.CreateMapper();
            var student = new Student()
            {
                Name = "BigBox777",
                StudentNumber = "668",
                Stature = 198,
                ChemistryAchievement = 100,
                MathematicsAchievement = 100,
                EnglishAchievement = 100,
            };
            StudentDto studentDto = mapper.Map<StudentDto>(student);
            Console.WriteLine(studentDto.ToString());
            
        }
    }
}

 

 3.3、条件映射

　　在满足一定条件才允许发生映射，举例：源类型是int，对应的目标类型是uint，需要源int的属性值大于等于0才能映射，不满足条件时用属性的默认值填充。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.ConditionalMapping
{
    public class Source
    {
        public int Number { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.ConditionalMapping
{
    public class Dest
    {
        public uint Number { get; set; }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.ConditionalMapping
{
    internal class ConditionalMappingProfile:Profile
    {
        //转换之前，源Number属性值大于等于0才能转换，不符合条件时用默认值
        public ConditionalMappingProfile()
        {
            CreateMap<Source, Dest>().ForMember(
                dest => dest.Number,
                opt => opt.PreCondition(src => src.Number >= 0));
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.ConditionalMapping
{
    internal class ConditionalMappingMain
    {
        public static void Test1()
        {
            var config = new MapperConfiguration(cfg => cfg.AddProfile<ConditionalMappingProfile>());
            var mapper = config.CreateMapper();
            var source = new Source { Number = 3 };
            var result = mapper.Map<Dest>(source);
        }
    }
}

 

3.4、自定义映射前后事件

 　　我们可以在映射发生之前和映射发生之后定义部分事件操作。看下面的例子

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class Source
    {
        public string Number1 { get; set; }
        public int Number2 { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class Dest
    {
        public string Number1 { get; set; }
        public int Number2 { get; set; }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class BeforeAfterMapActionProfile:Profile
    {
        //定义映射之前和之后的动作
        public BeforeAfterMapActionProfile()
        {
            CreateMap<Source, Dest>()
                .BeforeMap((src, dest) => { src.Number2++;})
                .AfterMap((src, dest) => { 
                    src.Number1 = "BigBox777" + src.Number1;
                    dest.Number1 = dest.Number1 + "BigBox777";
                    dest.Number2--;
                });
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class BeforeAfterMapActionMain
    {
        //方式1：配置文件里定义映射前后的动作
        public static void Test1()
        {
            var config = new MapperConfiguration(src=>src.AddProfile<BeforeAfterMapActionProfile>());
            var mapper = config.CreateMapper();
            var source = new Source { Number1 = "真棒", Number2 = 8 };
            var result = mapper.Map<Dest>(source);
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class UsingIMappingActionProfile:Profile
    {
        public UsingIMappingActionProfile()
        {
            CreateMap<Source, Dest>().AfterMap<NameMappingAction>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    //Source=》Dest定义映射动作
    internal class NameMappingAction : IMappingAction<Source, Dest>
    {
        public void Process(Source source, Dest destination, ResolutionContext context)
        {
            source.Number1 = "BigBox777" + source.Number1;
            destination.Number1= destination.Number1 + "BigBox777";
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.BeforeAfterMapAction
{
    internal class BeforeAfterMapActionMain
    {
        //方式2：新增一个动作类，继承接口IMappingAction
        public static void Test2()
        {
            var config = new MapperConfiguration(src => src.AddProfile<UsingIMappingActionProfile>());
            var mapper = config.CreateMapper();
            var source = new Source { Number1 = "真棒", Number2 = 8 };
            var result = mapper.Map<Dest>(source);
        }
    }
}

 

 需要注意在 Asp.Net Core 和 AutoMapper.Extensions.Microsoft.DependencyInjection 项目中，不能将依赖注入到Profile类中，但可以在 IMappingAction 实现中进行。

public class SetTraceIdentifierAction : IMappingAction<SomeModel, SomeOtherModel>
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public SetTraceIdentifierAction(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
    }

    public void Process(SomeModel source, SomeOtherModel destination, ResolutionContext context)
    {
        destination.TraceIdentifier = _httpContextAccessor.HttpContext.TraceIdentifier;
    }
}

public class SomeProfile : Profile
{
    public SomeProfile()
    {
        CreateMap<SomeModel, SomeOtherModel>()
            .AfterMap<SetTraceIdentifierAction>();
    }
}

 

3.5、自定义类型转换器

　　有时需要完全控制一种类型到另一种类型的转换。这通常是当一种类型看起来与另一种完全不同时，已经存在转换函数，并且您希望从“更宽松”的类型转换为更强的类型，下面例子，使用自定义了类型转换器，自定义转换器需要继承泛型接口  public interface ITypeConverter<in TSource, TDestination>  。注意：自定义类型转换器是全局的，只要 AutoMapper 在任何映射类型上找到源/目标对，就可以使用它们。    

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    public class Source
    {
        public string Value1 { get; set; }
        public string Value2 { get; set; }
        public string Value3 { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    public class Dest
    {
        public int Value1 { get; set; }
        public DateTime Value2 { get; set; }
        public Type Value3 { get; set; }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    //自己写的类型转换器：string=>DateTime
    public class DateTimeTypeConverter : ITypeConverter<string, DateTime>
    {
        public DateTime Convert(string source, DateTime destination, ResolutionContext context)
        {
            destination = DateTime.Parse(source);
            return destination;
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    //自定义类型转换器：string=》Type
    internal class TypeConverter : ITypeConverter<string, Type>
    {
        public Type Convert(string source, Type destination, ResolutionContext context)
        {
            destination=source.GetType();
            return destination;
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    internal class CustomTypeConvertersProfile:Profile
    {
        public CustomTypeConvertersProfile()
        {
            //用现成的转换器
            CreateMap<string,int>().ConvertUsing(str=>Convert.ToInt32(str));
            //自己写一个类型转换器
            CreateMap<string, DateTime>().ConvertUsing(new DateTimeTypeConverter());
            //自己写的类型转换器
            CreateMap<string,Type>().ConvertUsing<TypeConverter>();
            CreateMap<Source, Dest>();
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomTypeConverters
{
    internal class CustomTypeConvertersMain
    {
        public static void Test1()
        {
            var config = new MapperConfiguration(cfg => 
                cfg.AddProfile<CustomTypeConvertersProfile>());
            var mapper = config.CreateMapper();
            var source = new Source { Value1 = "872", Value2 = "2000-1-1", Value3 = "China" };
            var dest = mapper.Map<Dest>(source);
        }
    }
}

 

3.6、自定义值解析器

 　　有时候目标类型的某属性需要通过源类型的多个属性进行特殊计算处理得到，这个时候就需要使用自定义解析器了。自定值解析器 CustomTotalResolver 需要继承接口  public interface IValueResolver<in TSource, in TDestination, TDestMember> ，最后在配置类里配置当解析特定目标成员时使用这个自定义值解析器。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomValueResolvers
{
    public class Source
    {
        public int Value1 { get; set; }
        public int Value2 { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomValueResolvers
{
    public class Dest
    {
        public int Total { get; set; }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomValueResolvers
{
    //自定义值解析器需要继承IValueResolver接口
    public class CustomTotalResolver : IValueResolver<Source, Dest, int>
    {
        public int Resolve(Source source, Dest destination, int destMember, ResolutionContext context)
        {
            return source.Value1 + source.Value2;
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomValueResolvers
{
    internal class CustomValueResolversProfile:Profile
    {
        public CustomValueResolversProfile()
        {
            //指明解析Dest的Total属性时使用解析器CustomTotalResolver
            CreateMap<Source, Dest>().
                ForMember(dest => dest.Total, opt => opt.MapFrom<CustomTotalResolver>());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.CustomValueResolvers
{
    internal class CustomValueResolversMain
    {
        public static void Test1()
        {
            var config = new AutoMapper.MapperConfiguration(cfg => cfg.AddProfile<CustomValueResolversProfile>());
            var mapper = config.CreateMapper();
            var source = new Source { Value1 = 123, Value2 = 234 };
            var dest = mapper.Map<Dest>(source);
        }
    }
}

 

上面的案例我们只向 AutoMapper 提供了自定义解析器的类型，所以映射引擎将使用反射来创建值解析器的实例。如果我们不希望 AutoMapper 使用反射来创建实例，我们可以直接提供它：

//直接提供解析器实例
CreateMap<Source, Dest>().ForMember(dest => dest.Total, opt => opt.MapFrom(new CustomTotalResolver()));

 

默认情况下，AutoMapper 将源对象传递给解析器。这限制了解析器的可重用性，因为解析器与源类型耦合。但是，如果我们提供跨多种类型的通用解析器，我们配置 AutoMapper 以重定向提供给解析器的源值，并使用不同的解析器接口，以便我们的解析器可以使用源/目标成员：

var configuration = new MapperConfiguration(cfg => {
cfg.CreateMap<Source, Destination>()
    .ForMember(dest => dest.Total,
        opt => opt.MapFrom<CustomResolver, decimal>(src => src.SubTotal));
cfg.CreateMap<OtherSource, OtherDest>()
    .ForMember(dest => dest.OtherTotal,
        opt => opt.MapFrom<CustomResolver, decimal>(src => src.OtherSubTotal));
});

public class CustomResolver : IMemberValueResolver<object, object, decimal, decimal> {
    public decimal Resolve(object source, object destination, decimal sourceMember, decimal destinationMember, ResolutionContext context) {
// logic here
    }
}

 

配置解析器的是给mapper传输键值对

//配置类里配置键值对
CreateMap<Source, Dest>()
    .ForMember(dest => dest.Foo, opt => opt.MapFrom((src, dest, destMember, context) => context.Items["Foo"]));





//mapper创建的时候提取键值对
mapper.Map<Source, Dest>(src, opt => opt.Items["Foo"] = "Bar");

 

3.7、值转换器

　　值转换器是类型转换器和值解析器之间的交叉。类型转换器是全局作用域的，因此任何时候在任何映射中从一个类型映射Foo到另一个类型Bar时，都会使用类型转换器。值转换器的范围为单个映射，并接收源对象和目标对象以解析为映射到目标成员的值。值转换器也可以接收源成员。

 

3.8、泛型映射

　　automapper支持泛型映射，看下面例子。注意：automapper支持从共有的映射列表中自动把源类转换为目标类，如果映射列表没有就需要我们自己写类型转换器，否则就会报错。    

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GenericsMap
{
    internal class Source<T>
    {
        public T Value { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GenericsMap
{
    internal class Dest<T>
    {
        public T Value { get; set; }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GenericsMap
{
    internal class GenericsMapProfile:Profile
    {
        public GenericsMapProfile()
        {
            CreateMap(typeof(Source<>),typeof(Dest<>));
            ////如果映射列表没有对应的类型转换支持，需要我们自定义转换器Converter<,>
            //CreateMap(typeof(Source<>), typeof(Dest<>)).ConvertUsing(typeof(Converter<,>));
        }
    }
}

using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.GenericsMap
{
    internal class GenericsMapMain
    {
        public static void Test1()
        {
            var config = new MapperConfiguration(cfg => cfg.AddProfile<GenericsMapProfile>());
            var mapper = config.CreateMapper();
            //如果automapper的转换列表支持的话，automapper会自动转换，如果不支持会报错。
            var dest = mapper.Map<Source<int>, Dest<string>>(new Source<int>() { Value = 123 });
        }
    }
}

 

3.9、枚举映射

 　　内置枚举器不可配置，只能替换，AutoMapper 在单独的包  AutoMapper.Extensions.EnumMapping 2.0.1  中支持基于约定的枚举值映射。对于方法CreateMap，这个库提供了 ConvertUsingEnumMapping() 。此方法添加从源到目标枚举值的所有默认映射。可以使用 MapValue() 改变一些映射，方法可多次使用。默认枚举值是按值 MapByValue() 映射的，也可以通过名称 MapByName() 调用映射 。

　　注意：①默认情况，如果两个枚举类型具有相同的值(或按名称或按值)，包 AutoMapper.Extensions.EnumMapping 会将所有值从 Source 类型映射到 Dest 类型。如果启用了  EnumMappingValidation ，则所有没有 Target 等效项的 Source 枚举值都将引发异常。②如果配置了 .ReverseMap() 将支持从 Dest 类型映射到 Source 类型，注意反向映射的时候可能出现多个 Dest 值对应一个 Source 值，这会出现覆盖。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.EnumMapping
{
    internal enum EnumSource
    {
        Default = 0,
        First = 1,
        Second = 2
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.EnumMapping
{
    internal enum EnumDest
    {
        Default = 0,
        Second = 2
    }
}

using AutoMapper;
using AutoMapper.Extensions.EnumMapping;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.EnumMapping
{
    internal class EnumMappingProfile :Profile
    {
        public EnumMappingProfile()
        {
            //需要Nuget引用AutoMapper.Extensions.EnumMapping 2.0.1
            CreateMap<EnumSource, EnumDest>()
                .ConvertUsingEnumMapping(opt=> opt.MapValue(EnumSource.First,EnumDest.Second))
                .ReverseMap(); //支持上面opt.MapValue(EnumSource.First,EnumDest.Second)的反向映射
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Demo18_AutoMapper.EnumMapping
{
    internal class EnumMappingMain
    {
        public static void Test1()
        {
            var config = new AutoMapper.MapperConfiguration(cfg => cfg.AddProfile<EnumMappingProfile>());
            var mapper = config.CreateMapper();
            var dest = mapper.Map<EnumDest>(EnumSource.First);
            //反向映射,这里出现EnumDest.Second会映射到EnumSource.First和EnumSource.Second，
            //会出现覆盖现象，EnumSource.Second覆盖了EnumSource.First
            var source =mapper.Map<EnumSource>(EnumDest.Second);
        }
    }
}

 

AutoMapper有个工具来验证类型映射。看下面例子：

public class MappingConfigurationsTests
{
    [Fact]
    public void WhenProfilesAreConfigured_ItShouldNotThrowException()
    {
        // Arrange
        var config = new MapperConfiguration(configuration =>
        {
            configuration.EnableEnumMappingValidation();

            configuration.AddMaps(typeof(AssemblyInfo).GetTypeInfo().Assembly);
        });
        
        // Assert
        config.AssertConfigurationIsValid();
    }
}

 

4、参考

官方帮助文档　　https://github.com/AutoMapper/AutoMapper/tree/master/docs　　

tkbSimplest的博客 https://www.cnblogs.com/farb/p/4932692.html