首页 编程相关 正文
我要发布

AutoMapper详解

编程相关
2025-12-13 0 256

AutoMapper详解

一、AutoMapper详解

1、概述

（1）什么是AutoMapper

简单来说，AutoMapper是以.NET(C#)语言开发的一个轻量的处理一个实体对象到另一个实体对象之间映射关系的组件库。开发人员需要做的是通过AutoMapper配置两个实体对象之间的一些映射关系。就可以直接实现映射关系的复用，提高开发效率，减少重复代码。
官网地址：http://automapper.org/

文档地址：https://docs.automapper.org/en/latest/

（2）为什么要做对象之间的映射

为了降低现代开发框架的复杂度，往往需要做代码分层，分层之后，必然出现不同的数据承载对象VO、BO、Entity ，从设计的角度来说，VO、BO、Entity 的设计思路并不违反 DRY 原则，为了分层清晰、减少耦合，多维护几个类的成本也并不是不能接受的，对于代码重复的问题，我们可以通过继承或者组合来解决。

层与层之间数据对象的转换工作是一个非常常见的情况，最简单的方式就是手动复制。当然，使用数据对象转化工具，可以大大简化繁琐的对象转化工作，AutoMapper就是一种很好的转换工具。

2、快速开始

（1）nuget引入程序集
AutoMapper   基于版本11.0.1演示，Net5
（2）配置映射关系
public  class MyFirstProfile: Profile
{
    public MyFirstProfile()
    {
        CreateMap<Src01, Dest01>();
    }
}
（3）对象转换
//创建配置对象
var configuration = new MapperConfiguration(cfg =>
{ 
    cfg.AddProfile<MyFirstProfile>();
});
//创建映射对象
var mapper = configuration.CreateMapper();//或者var mapper=new Mapper(configuration);
//映射动作，将对象转换成另一个对象
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\", Age = 18 });

3、常用配置

（1）加载Profile配置

可以直接添加对象的映射关系 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src01, Dest01>();
});

将映射关系添加到Profile，再加载Profile，类似于模块化分割业务，让项目结构更加清晰 

var configuration = new MapperConfiguration(cfg =>
{ 
    cfg.AddProfile<MyFirstProfile>();
    //或者cfg.AddProfile(new MyFirstProfile());
});

加载程序集中的所有Profile 

var basePath = AppContext.BaseDirectory;
var assemblys = Assembly.LoadFrom(Path.Combine(basePath, \"Net5.AutoMapper.dll\"));
var configuration = new MapperConfiguration(cfg => cfg.AddMaps(assemblys));
（2）兼容不同的命名方式
  • 作用：Camel命名与Pascal命名的兼容。
  • 配置之后会映射property_name到PropertyName 
var configuration = new MapperConfiguration(cfg =>
{
    cfg.SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
    cfg.DestinationMemberNamingConvention = new PascalCaseNamingConvention();

    cfg.AddProfile<MyFirstProfile>();
});
（3）配置的生效范围

在全局生效 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
    cfg.DestinationMemberNamingConvention = new PascalCaseNamingConvention();

    cfg.AddProfile<MyFirstProfile>();
});

在某个Profile生效 

public  class MyFirstProfile: Profile
{
    public MyFirstProfile()
    {        
        SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
        DestinationMemberNamingConvention = new PascalCaseNamingConvention();

        CreateMap<Src01, Dest01>();
    }
}
（4）映射时替换字符串
var configuration = new MapperConfiguration(cfg =>
{
    cfg.ReplaceMemberName(\"Src\", \"Dest\");
    cfg.CreateMap<Src02, Dest02>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest02>(new Src02() { NameSrc = \"zhangsan\" });

AutoMapper详解

（5）映射时匹配前缀或后缀

RecognizePrefixes匹配前缀，RecognizePostfixes匹配后缀 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.RecognizePrefixes(\"before\");//前缀
    cfg.RecognizePostfixes(\"after\");//后缀
    cfg.CreateMap<Src03,Dest03>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest03>(new Src03() { Nameafter = \"zhangsan\", beforeAge = 18 });

AutoMapper详解

Automapper默认匹配了Get前缀，如果不需要可以清除 

cfg.ClearPrefixes();//清除所有前缀
（6）控制映射字段和属性范围

ShouldMapField设置字段映射范围，ShouldMapProperty设置属性范围 

var configuration = new MapperConfiguration(cfg => {
    cfg.ShouldMapField = fi => false;
    cfg.ShouldMapProperty = pi => pi.GetMethod != null && (pi.GetMethod.IsPublic || pi.GetMethod.IsPrivate);
});
（7）提前编译
var configuration = new MapperConfiguration(cfg => { });
configuration.CompileMappings();

4、映射初级

（1）一些默认行为

类型映射配置之后，集合的映射就自动完成了，集合之间可以相互映射

  • IEnumerable
  • IEnumerable<T>
  • ICollection
  • ICollection<T>
  • IList
  • IList<T>
  • List<T>
  • Arrays

当映射集合时，如果src的成员为null，则dest的成员会new一个默认值，而不是直接复制为null。

如果真要映映射为null，则如下修改。这个功能可以配置成全局的、某个profile的或某个member的。 

cfg.AllowNullCollections = true;

假如某个成员的名称为NameAAA，则名为NameAAA的field，与名为NameAAA的property，与名为GetNameAAA的方法，三者之间可以自动相互映射

AutoMapper支持.NET Framework自带的一些基本的类型转换，对于那些不支持的类型转换，或者特殊处理的转换，需要自己定义TypeConverter

（2）字段相同的会自动映射
var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Dest01, Src01>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\", Age = 18 });

AutoMapper详解

（3）字段不同要手动配置映射

同一个字段的映射，后面的会覆盖前面的，不同的字段，没有做映射的，不会进行赋值 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src02, Dest02>()
    .ForMember(dest => dest.NameDest, opt => opt.MapFrom(src => src.NameSrc));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest02>(new Src02() { NameSrc = \"zhangsan\" });

AutoMapper详解

（4）内部类嵌套类映射

类内部嵌套一个类，需要将嵌套的类也进行映射 

public class SrcOuter
{
    public string OutName { get; set; }
    public int OutAge { get; set; }
    public SrcInner Inner { get; set; }
}
public class SrcInner
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class DestOuter
{
    public string OutName { get; set; }
    public int OutAge { get; set; }
    public DestInner Inner { get; set; }
}
public class DestInner
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcOuter, DestOuter>();
    cfg.CreateMap<SrcInner, DestInner>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestOuter>(new SrcOuter(){OutName = \"zhangsan\",OutAge = 18,Inner = new SrcInner() { Name = \"lisi\", Age = 20 }});

AutoMapper详解

内部类作为一个属性需要配置映射，不能直接在容器类映射内部类的属性，属性类的字段映射还是需要在属性类本身配置 

public class SrcOuterComplex
{
    public string NameSrc { get; set; }
    public int AgeSrc { get; set; }
    public SrcInnerComplex InnerSrc { get; set; }
}
public class SrcInnerComplex
{
    public string NameSrc { get; set; }
    public int AgeSrc { get; set; }
}
public class DestOuterComplex
{
    public string NameDest { get; set; }
    public int AgeDest { get; set; }
    public DestInnerComplex InnerDest { get; set; }
}
public class DestInnerComplex
{
    public string NameDest { get; set; }
    public int AgeDest { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcOuterComplex, DestOuterComplex>()
    .ForMember(dest => dest.NameDest, opt => opt.MapFrom(src => src.NameSrc))
    .ForMember(dest => dest.AgeDest, opt => opt.MapFrom(src => src.AgeSrc))
    //属性类本身作为一个字段需要映射
    .ForMember(dest => dest.InnerDest, opt => opt.MapFrom(src => src.InnerSrc))
    //不能直接在容器类映射内部类的属性
    //.ForMember(dest => dest.InnerDest.NameDest, opt => opt.MapFrom(src => src.InnerSrc.NameSrc))
    ;
    //属性类的字段映射还是需要在属性类本身配置
    cfg.CreateMap<SrcInnerComplex, DestInnerComplex>()
    .ForMember(dest => dest.NameDest, opt => opt.MapFrom(src => src.NameSrc))
    .ForMember(dest => dest.AgeDest, opt => opt.MapFrom(src => src.AgeSrc));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestOuterComplex>(new SrcOuterComplex() { NameSrc = \"zhangsan\", AgeSrc = 18, InnerSrc = new SrcInnerComplex() { NameSrc = \"lisi\", AgeSrc = 20 } });

AutoMapper详解

（5）映射继承和多态

父类映射包含子类映射Include，子类映射包含父类映射IncludeBase，子类如果有多个直接包含所有IncludeAllDerived 

public class SrcParent
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class SrcChild : SrcParent
{
    public string ChildName { get; set; }
    public int ChildAge { get; set; }
}
public class DestParent
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class DestChild: DestParent
{
    public string ChildName { get; set; }
    public int ChildAge { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{
    父类映射包含子类映射Include
    //cfg.CreateMap<SrcParent, DestParent>()
    // .Include<SrcChild, DestChild>();
    //cfg.CreateMap<SrcChild, DestChild>();

    子类映射包含父类映射IncludeBase
    //cfg.CreateMap<SrcParent, DestParent>();
    //cfg.CreateMap<SrcChild, DestChild>()
    //.IncludeBase<SrcParent, DestParent>();

    //子类如果有多个直接包含所有IncludeAllDerived
    cfg.CreateMap<SrcParent, DestParent>().IncludeAllDerived();
    cfg.CreateMap<SrcChild, DestChild>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestChild>(new SrcChild() { Name = \"zhangsan\", ChildName = \"zhangsanchild\", Age = 35, ChildAge = 3 });

AutoMapper详解

（6）构造函数映射

如果dest构造函数的入参名和src的某个member一致，automapper会自动映射 

public class SrcCtor
{
    public string Name { get; set; }
}
public class DestCtor
{
    private string DestName { get; set; }

    public DestCtor(string name)
    { 
        this.DestName = name;
    }
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcCtor, DestCtor>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestCtor>(new SrcCtor() { Name = \"zhangsan\" });

AutoMapper详解

如果dest构造函数的入参名和src的某个member不一致，需要手动配置映射 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcCtor02, DestCtor02>()
    .ForCtorParam(\"destname\", opt => opt.MapFrom(src => src.Name));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestCtor02>(new SrcCtor02() { Name = \"zhangsan\" });

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8lUcpiZK-1654846652910)(http://rc4mudd0q.hd-bkt.clouddn.com/202205121352984.png)]

也可以禁用构造函数映射 

var configuration = new MapperConfiguration(cfg => cfg.DisableConstructorMapping());

也可以配置什么情况下不用构造函数映射 

var configuration = new MapperConfiguration(cfg => cfg.ShouldUseConstructor = ci => !ci.IsPrivate);//不匹配私有构造函数
（7）复杂类映射成扁平类

自动映射

映射时AutoMapper发现，src里没有CustomerName这个成员，则会将dest的CustomerName按照PascalCase的命名方式拆分为独立的单词。所以CustomerName会映射到src的Customer.Name。 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcComplex, DestSimple>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestSimple>(new SrcComplex() { Customer =new Customer() { Name= \"zhangsan\" }});

AutoMapper详解

可以禁用这种自动映射 

cfg.DestinationMemberNamingConvention = new ExactMatchNamingConvention();

可以手工配置映射

IncludeMembers参数的顺序很重要，这也就是dest的Description为“description”而不是“description2”的原因，因为InnerSource的Description属性最先匹配到了Destination的Description属性。

IncludeMembers相当于把子类打平添加到了src里，并进行映射。 

public class SrcComplex02
{
    public string Name { get; set; }
    public InnerSource InnerSource { get; set; }
    public InnerSource02 InnerSource02 { get; set; }
}
public class InnerSource
{
    public string Name { get; set; }
    public string Description { get; set; }
}
public class InnerSource02
{
    public string Name { get; set; }
    public string Description { get; set; }
    public string Title { get; set; }
}
public class DestSimple02
{
    public string Name { get; set; }
    public string Description { get; set; }
    public string Title { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcComplex02, DestSimple02>().IncludeMembers(s => s.InnerSource, s => s.InnerSource02);
    cfg.CreateMap<InnerSource, DestSimple02>();
    cfg.CreateMap<InnerSource02, DestSimple02>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestSimple02>(new SrcComplex02()
{
    Name = \"name\",
    InnerSource = new InnerSource { Description = \"description\" },
    InnerSource02 = new InnerSource02 { Title = \"title\", Description = \"descpripiton2\" }
});

AutoMapper详解

（8）映射反转

ReverseMap一般在CreateMap方法或者ForMember等方法之后，相当于src和dest根据你自己的配置反向映射 

cfg.CreateMap<Order, OrderDto>().ReverseMap();
//等同于以下两句
cfg.CreateMap<Order,OrderDto>();
cfg.CreateMap<OrderDto,Order>();

反向映射可以用ForPath配置 

cfg.CreateMap<Order, OrderDto>()
  .ForMember(d => d.CustomerName, opt => opt.MapFrom(src => src.Customer.Name))
  .ReverseMap()
  .ForPath(s => s.Customer.Name, opt => opt.MapFrom(src => src.CustomerName));

ReverseMap到底能Reverse哪些东西

  • 可以Reverse像PascalCase的命名方式拆分的member，就像CreateMap可以自动处理Customer.Name与CustomerName的映射一样。即：CreateMap不需要额外配置正向就能映射的，那 ReverseMap也可以自动反向映射。
  • opt.MapForm()操作可以被reverse，如CreateMap<Person2, Person>().ForMember(dest => dest.Name2, opt => opt.MapFrom(src => src.Name)).ReverseMap();，当从Person映射到Person2的时候，Name2也可以直接映射到Name上。
  • 不支持opt.Ignore()反向映射，即CreateMap<Person2, Person>().ForMember(dest => dest.Name, opt => opt.Ignore()).ReverseMap()支持Person2->Person时，忽略Name属性，但是反过来不会忽略。
（9）使用特性映射

等同于CreateMap<Order,OrderDto>()，然后配置的时候用AddMaps方法加载程序集 

[AutoMap(typeof(Order))]
public class OrderDto {}

var configuration = new MapperConfiguration(cfg => cfg.AddMaps(\"MyAssembly\"));

还能标记如下特性

  • ReverseMap (bool)
  • ConstructUsingServiceLocator (bool)
  • MaxDepth (int)
  • PreserveReferences (bool)
  • DisableCtorValidation (bool)
  • IncludeAllDerived (bool)
  • TypeConverter (Type)
（10）动态类型到普通类型映射
var configuration = new MapperConfiguration(cfg =>{ });
var mapper = configuration.CreateMapper();
dynamic src = new ExpandoObject();//ExpandoObject对象包含可在运行时动态添加或移除的成员
src.Name = \"zhangsan\";
src.Age = 18;
var dest = mapper.Map<Dest01>(src);

AutoMapper详解

（11）泛型映射

CreateMap不需要传具体的T 

public class SrcGeneric<T>
{
    public T TValue { get; set; }
}
public class DestGeneric<T>
{
    public T TValue { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap(typeof(SrcGeneric<>), typeof(DestGeneric<>));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestGeneric<int>>(new SrcGeneric<int>() { TValue = 18 });

AutoMapper详解

（12）Dictonary到普通类型映射

不需要配置映射关系，配置之后反而无法映射成功 

var configuration = new MapperConfiguration(cfg =>{});
var mapper = configuration.CreateMapper();
Dictionary<string, object> dic = new Dictionary<string, object>();
dic.Add(\"Name\",\"zhangsan\");
dic.Add(\"Age\",18);
var dest = mapper.Map<Dest01>(dic);

AutoMapper详解

5、映射进阶

（1）自定义类型转换

可以直接转换，也可以定义转换器转换 

public class SrcConverter
{
    public string Age { get; set; }
    public string Time { get; set; }
}
public class DestConverter
{
    public int Age { get; set; }
    public DateTime Time { get; set; }
}
public class DateTimeTypeConverter : ITypeConverter<string, DateTime>
{
    public DateTime Convert(string source, DateTime destination, ResolutionContext context)
    {
        return System.Convert.ToDateTime(source);
    }
}

var configuration = new MapperConfiguration(cfg => {
    //可以直接转换
    cfg.CreateMap<string, int>().ConvertUsing(s => Convert.ToInt32(s));
    //也可以定义转换器转换
    cfg.CreateMap<string, DateTime>().ConvertUsing(new DateTimeTypeConverter());
    cfg.CreateMap<SrcConverter, DestConverter>();
});
var src = new SrcConverter
{
    Age = \"5\",
    Time = \"05/12/2022\"
};
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestConverter>(src);

AutoMapper详解

（2）自定义值解析

这种与一般的MapFrom()区别是可以添加更加复杂的逻辑

  • MapFrom<CustomResolver>
  • MapFrom(new CustomResolver()) 
public class SrcResolver
{
    public string Name { get; set; }

    public int Age { get; set; }
}
public class DestResolver
{
    public string Info { get; set; }
}
public class CustomResolver : IValueResolver<SrcResolver, DestResolver, string>
{
    public string Resolve(SrcResolver source, DestResolver destination, string destMember, ResolutionContext context)
    {		
		return $\"{source.Name}--{source.Age}\";
	}
}

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcResolver, DestResolver>()
    //针对的是某一个map的某一个member的两种写法
    //.ForMember(dest => dest.Info, opt => opt.MapFrom<CustomResolver>())
    .ForMember(dest => dest.Info, opt => opt.MapFrom(new CustomResolver()));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestResolver>(new SrcResolver() { Name = \"zhangsan\", Age = 18 });

AutoMapper详解

ITypeConverter、IValueConverter、IValueResolver、IMemberValueResover比较

  • Type converter = Func<TSource, TDestination, TDestination>
  • Value resolver = Func<TSource, TDestination, TDestinationMember>
  • Member value resolver = Func<TSource, TDestination, TSourceMember, TDestinationMember>
  • Value converter = Func<TSourceMember, TDestinationMember>
  • 这四个的使用方式都是使用ConvertUsing()方法，区别是type converter 是针对全局的，其它三个是针对某个member的。 入参出参也不一样。
（3）条件映射

符合某些条件时才映射

Condition方法会在MapFrom方法后判断,PreCondition会在MapFrom前判断 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcCondition, DestCondition>()
    //src.Name.Length>=3&&(src.Name+\"XXX\").Length >= 5 两个条件都满足才映射
    .ForMember(dest => dest.Name, opt => opt.PreCondition(src => src.Name.Length >= 3))
    .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Name + \"XXX\"))
    .ForMember(dest => dest.Name, opt => opt.Condition(src => src.Name.Length >= 5))
    //src.Age <= 15&&src.Age * 3>=30 两个条件都满足才映射
    .ForMember(dest => dest.Age, opt => opt.PreCondition(src => src.Age <= 15))
    .ForMember(dest => dest.Age, opt => opt.MapFrom(src => src.Age * 3))
    .ForMember(dest => dest.Age, opt => opt.Condition(src => src.Age >= 30));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<DestCondition>(new SrcCondition() { Name = \"zhangsan\", Age = 18 });

AutoMapper详解

（4）空值处理

如果src为null的话，就给dest一个默认值 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src01, Dest01>()
    .ForMember(dest => dest.Name, opt => opt.NullSubstitute(\"XXX\"));
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Age = 18 });

AutoMapper详解

（5）类型映射处理

针对某种类型的映射做处理，可以应用到全局、某个Profile、某个Map或某个member 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.ValueTransformers.Add<string>(val => \"fawaikuangtu \"+val + \" !!!\");
    cfg.ValueTransformers.Add<int>(val => val + 2);
    cfg.CreateMap<Src01, Dest01>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\",Age=17 });

AutoMapper详解

（6）映射前后干点事

映射关系配置时配置 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src01, Dest01>()
    //转换前对dest的处理会被转换结果覆盖
    .BeforeMap((src, dest) => { Console.WriteLine($\"转换前处理前{src.Name}--{dest.Name}\"); src.Name = src.Name + \" !!!\"; dest.Name = \"转换前赋值\"; Console.WriteLine($\"转换前处理后{src.Name}--{dest.Name}\"); })
    //转换后对src的处理是没意义的
    .AfterMap((src, dest) => { Console.WriteLine($\"转换后处理前{src.Name}--{dest.Name}\"); dest.Name = \"fawaikuangtu \" + dest.Name; src.Name = \"转换后赋值\"; Console.WriteLine($\"转换后处理后{src.Name}--{dest.Name}\"); });
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\" });

AutoMapper详解

映射关系转换时配置 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src01, Dest01>();                    
});
var mapper = configuration.CreateMapper();
var src = new Src01() { Name = \"zhangsan\" };
var dest = mapper.Map<Src01,Dest01>(src, opt => {
    //转换前dest是null
    opt.BeforeMap((src, dest) => {src.Name = src.Name + \" !!!\"; });
    //转换后对src的处理是没意义的
    opt.AfterMap((src, dest) => {dest.Name = \"fawaikuangtu \" + dest.Name;});
});

AutoMapper详解

（7）忽略某字段的映射

映射时配置忽略字段 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Src01, Dest01>()
    .ForMember(dest => dest.Name, opt => opt.Ignore());
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\",Age=18 });

AutoMapper详解

忽略属性和字段 

var configuration = new MapperConfiguration(cfg =>
{
    cfg.ShouldMapField = fi => false;
    cfg.ShouldMapProperty = fi => false;
    cfg.CreateMap<Src01, Dest01>();
});
var mapper = configuration.CreateMapper();
var dest = mapper.Map<Dest01>(new Src01() { Name = \"zhangsan\", Age = 18 });

AutoMapper详解

（8）多个源映射到一个目标
public class SrcPartA
{
    public string FiledPartA { get; set; }
    public string FiledPartB { get; set; }
}
public class SrcPartB
{
    public string FiledPartC { get; set; }
    public string FiledPartD { get; set; }
}
public class SrcPartC
{
    public string FiledPartE { get; set; }
    public string FiledPartF { get; set; }
}
public class DestCombine
{
    public string FiledA { get; set; }
    public string FiledB { get; set; }
    public string FiledC { get; set; }
    public string FiledD { get; set; }
    public string FiledE { get; set; }
    public string FiledF { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
{                    
    cfg.CreateMap<SrcPartA, DestCombine>()
    .ForMember(dest => dest.FiledA, opt => opt.MapFrom(src => src.FiledPartA))
    .ForMember(dest => dest.FiledB, opt => opt.MapFrom(src => src.FiledPartB));

    cfg.CreateMap<SrcPartB, DestCombine>()
    .ForMember(dest => dest.FiledC, opt => opt.MapFrom(src => src.FiledPartC))
    .ForMember(dest => dest.FiledD, opt => opt.MapFrom(src => src.FiledPartD));

    cfg.CreateMap<SrcPartC, DestCombine>()
    .ForMember(dest => dest.FiledE, opt => opt.MapFrom(src => src.FiledPartE))
    .ForMember(dest => dest.FiledF, opt => opt.MapFrom(src => src.FiledPartF));
});
var mapper = configuration.CreateMapper();
var srcPartA = new SrcPartA() { FiledPartA=\"A\",FiledPartB=\"B\"};
var srcPartB = new SrcPartB() { FiledPartC=\"C\",FiledPartD=\"D\"};
var srcPartC = new SrcPartC() { FiledPartE=\"E\",FiledPartF=\"F\"};
var dest=new DestCombine();
dest=mapper.Map(srcPartA,dest);
dest=mapper.Map(srcPartB,dest);
dest=mapper.Map(srcPartC,dest);

AutoMapper详解

6、性能测试

转换百万对象，耗时414毫秒 

public class SrcPart
{
    public SrcPartA SrcPartA { get; set; }
    public SrcPartB SrcPartB { get; set; }
    public SrcPartC SrcPartC { get; set; }
}

//配置映射关系
var configuration = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<SrcPart, DestCombine>()
    .ForMember(dest => dest.FiledA, opt => opt.MapFrom(src => src.SrcPartA.FiledPartA))
    .ForMember(dest => dest.FiledB, opt => opt.MapFrom(src => src.SrcPartA.FiledPartB))
    .ForMember(dest => dest.FiledC, opt => opt.MapFrom(src => src.SrcPartB.FiledPartC))
    .ForMember(dest => dest.FiledD, opt => opt.MapFrom(src => src.SrcPartB.FiledPartD))
    .ForMember(dest => dest.FiledE, opt => opt.MapFrom(src => src.SrcPartC.FiledPartE))
    .ForMember(dest => dest.FiledF, opt => opt.MapFrom(src => src.SrcPartC.FiledPartF));                    
});
var mapper = configuration.CreateMapper();
//创建数据
List<SrcPart> srcParts = new List<SrcPart>();
for (int i = 0; i < 1000_000; i++)
{
    srcParts.Add(new SrcPart()
    {
        SrcPartA = new SrcPartA() { FiledPartA = \"FiledPartA\" + Guid.NewGuid(), FiledPartB = \"FiledPartA\" + Guid.NewGuid() },
        SrcPartB = new SrcPartB() { FiledPartC = \"FiledPartC\" + Guid.NewGuid(), FiledPartD = \"FiledPartD\" + Guid.NewGuid() },
        SrcPartC = new SrcPartC() { FiledPartE = \"FiledPartE\" + Guid.NewGuid(), FiledPartF = \"FiledPartF\" + Guid.NewGuid() }
    });
}
//转换数据
Stopwatch sw = new Stopwatch();
sw.Start();
List<DestCombine> dest=mapper.Map<List<DestCombine>>(srcParts);
sw.Stop();
Console.WriteLine(\"耗时：\" + sw.ElapsedMilliseconds);
耗时：414

7、扩展IQueryable

（1）概述

这个功能存在的意义是为了解决一些orm框架返回的是IQueryable类型，使用一般的mapper.Map做转换时，会查询出来整行数据，然后再挑选出来某些字段做映射，会降低性能的问题。解决方法是使用ProjectTo

（2）nuget引入程序集
AutoMapper
AutoMapper.EF6
（3）代码实现
public class OrderLine
{
  public int Id { get; set; }
  public int OrderId { get; set; }
  public Item Item { get; set; }
  public decimal Quantity { get; set; }
}
public class Item
{
  public int Id { get; set; }
  public string Name { get; set; }
}
public class OrderLineDTO
{
  public int Id { get; set; }
  public int OrderId { get; set; }
  public string Item { get; set; }
  public decimal Quantity { get; set; }
}

var configuration = new MapperConfiguration(cfg =>
    cfg.CreateMap<OrderLine, OrderLineDTO>()
    .ForMember(dto => dto.Item, conf => conf.MapFrom(ol => ol.Item.Name)));

//这样查Item表的时候，只会select name字段。
public List<OrderLineDTO> GetLinesForOrder(int orderId)
{
  using (var context = new orderEntities())
  {
    return context.OrderLines.Where(ol => ol.OrderId == orderId)
             .ProjectTo<OrderLineDTO>(configuration).ToList();
  }
}

8、集成到Asp.NetCore5框架

（1）nuget引入程序集
AutoMapper
AutoMapper.Extensions.Microsoft.DependencyInjection
（2）创建映射关系
public class OrganizationProfile : Profile
{
    public OrganizationProfile()
    {
        CreateMap<User, UserDto>()
        .ForMember(dst => dst.Name, opt => opt.MapFrom(src => \"fawaikuangtu \" + src.Name));
    }
}
（3）在控制器中注入并使用
public class UserRepository : IUserRepository
{
    public User GetUser()
    {
        return new User() { Name = \"zhangsan\", Age = 18, Sex = \"male\", Password = \"SDF\" };
    }
}
public class UserService : IUserService
{    
    private IUserRepository UserRepositoryCtor { get; set; }
    private IMapper _mapper;
    public UserService(IUserRepository userRepository, IMapper mapper)
    {
        UserRepositoryCtor = userRepository;
        this._mapper = mapper;
    }    
    public string Login(string username, string password)
    {
        UserDto userdto=_mapper.Map<UserDto>(UserRepositoryCtor.GetUser());
        return userdto.Name+\"登录成功\";
    }
}
public class FourthController : Controller
{
    private IUserService _userService;
    public FourthController(IUserService userService)
    {
        this._userService = userService;
    }

    public IActionResult Index()
    {
        object result = this._userService.Login(\"username\", \"password\");
        return View(result);
    }
}
@model String <h2>this is fourth index...</h2> <h2>@Model</h2>
（4）在Startup的ConfigureServices中注册到容器
services.AddAutoMapper(typeof(OrganizationProfile));
services.AddTransient<IUserService, UserService>();
services.AddTransient<IUserRepository, UserRepository>();
（5）运行效果

AutoMapper详解

收藏 (0) 打赏

感谢您的支持，我会继续努力的!

打开微信/支付宝扫一扫，即可进行扫码打赏哦，分享从这里开始，精彩与您同在
点赞 (0)

申明：本文由第三方发布，内容仅代表作者观点，与本网站无关。对本文以及其中全部或者部分内容的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。本网发布或转载文章出于传递更多信息之目的，并不意味着赞同其观点或证实其描述，也不代表本网对其真实性负责。

左子网 编程相关 AutoMapper详解 https://www.zuozi.net/36539.html

vant-list在滚动条触底的时候，没有触发onLoad事件，怎么办？
上一篇： vant-list在滚动条触底的时候，没有触发onLoad事件，怎么办？
C#反射之Assembly.Load，Assembly.LoadFile 与 Assembly.LoadFrom方法介绍
下一篇： C#反射之Assembly.Load，Assembly.LoadFile 与 Assembly.LoadFrom方法介绍
常见问题

发货方式是什么？

  • 1、自动：拍下后，点击（下载）链接即可下载；2、手动：拍下后，联系卖家发放即可或者联系官方找开发者发货。
查看详情

交易周期是多久呢？

  • 1、源码默认交易周期：手动发货商品为1-3天，并且用户付款金额将会进入平台担保直到交易完成或者3-7天即可发放，如遇纠纷无限期延长收款金额直至纠纷解决或者退款！；
查看详情

能退款么？

  • 1、描述：源码描述(含标题)与实际源码不一致的（例：货不对板）； 2、演示：有演示站时，与实际源码小于95%一致的（但描述中有”不保证完全一样、有变化的可能性”类似显著声明的除外）； 3、发货：不发货可无理由退款； 4、安装：免费提供安装服务的源码但卖家不履行的； 5、收费：价格虚标，额外收取其他费用的（但描述中有显著声明或双方交易前有商定的除外）； 6、其他：如质量方面的硬性常规问题BUG等。 注：经核实符合上述任一，均支持退款，但卖家予以积极解决问题则除外。
查看详情

注意事项

  • 1、左子会对双方交易的过程及交易商品的快照进行永久存档，以确保交易的真实、有效、安全！ 2、左子无法对如“永久包更新”、“永久技术支持”等类似交易之后的商家承诺做担保，请买家自行鉴别； 3、在源码同时有网站演示与图片演示，且站演与图演不一致时，默认按图演作为纠纷评判依据（特别声明或有商定除外）； 4、在没有”无任何正当退款依据”的前提下，商品写有”一旦售出，概不支持退款”等类似的声明，视为无效声明； 5、在未拍下前，双方在QQ上所商定的交易内容，亦可成为纠纷评判依据（商定与描述冲突时，商定为准）； 6、因聊天记录可作为纠纷评判依据，故双方联系时，只与对方在左子上所留的QQ、手机号沟通，以防对方不承认自我承诺。 7、虽然交易产生纠纷的几率很小，但一定要保留如聊天记录、手机短信等这样的重要信息，以防产生纠纷时便于左子介入快速处理。
查看详情

相关文章

猜你喜欢
发表评论
暂无评论
官方客服团队

为您解决烦忧 - 24小时在线 专业服务

联系官方团队 在线提交工单
TA的动态
左子网

分享最新WordPress教程共同学习，共同进步，共同成长！

QQ交流群
左子网

QQ交流群

您的支持，是我们最大的动力！ https://qm.qq.com/q/iR7Nj0TrOg
热门文章
热门标签
随机推荐
热门评论
终身VIP会员限时钜惠
首页 源码 菜单 案例 我的