发布：2021/7/2 14:32:27作者：管理员 来源：本站 浏览次数：1785

AutoMapper入门教程

    NuGet安装
        使用示例
            基础模型转换
            反向映射转换
            自定义映射规则
            是否可以为空设置

参考材料：AutoMapper官方网站，github，官方教程
NuGet安装

废话少说，直接上图：
在这里插入图片描述
在这里插入图片描述
目前最新的版本是8.0.0 由于8.0要求 .net freamwork 4.6+ ，而现有项目都是4.5 所以这里直接安装的7.0.1 ， AutoMapper.Data选择的是2.0.0 这个后面是用来实现IDataReader转List的，这里不再多说 后面还会有详细介绍。
使用示例
基础模型转换

 public class DevicewareDto
    {
        public string DeviceNumber { get; set; }
        public string SIMCCID { get; set; }
    }
     public class Deviceware
    {
        public string DeviceNumber { get; set; }
        public string SIMCCID { get; set; }
    }
    //注册映射关系：
    Mapper.Initialize(cfg =>
        {
            cfg.CreateMap<Deviceware, DevicewareDto>();
        });

        var deviceware= new Deviceware();
        deviceware.DeviceNumber = "hhhhh";
        deviceware.SIMCCID = "jjjjjj";
        var devicewareDto= Mapper.Map<DevicewareDto>(fffff);
        //结果：
       //  devicewareDto.DeviceNumber = "hhhhh";
       // devicewareDto.SIMCCID = "jjjjjj";

   

反向映射转换

    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; }
    }
    
 Mapper.Initialize(cfg =>
            {
                cfg.CreateMap<Order, OrderDto>()
                   .ReverseMap();
            });

            var customer = new Customer
            {
                Name = "Bob"
            };

            var order = new Order
            {
                Customer = customer,
                Total = 15.8m
            };

            var orderDto = Mapper.Map<Order, OrderDto>(order);

            orderDto.CustomerName = "Joe";

            Order ddd = Mapper.Map<OrderDto, Order>(orderDto, order);

   

自定义映射规则



    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 double Value3 { get; set; }
    }

    public class DateTimeTypeConverter : ITypeConverter<string, DateTime>
    {
        public DateTime Convert(string source, DateTime destination, ResolutionContext context)
        {
            return System.Convert.ToDateTime(source);
        }
    }
    
    Mapper.Initialize(cfg =>
        {
            cfg.CreateMap<string, int>().ConvertUsing(s => Convert.ToInt32(s));
            cfg.CreateMap<string, DateTime>().ConvertUsing(new DateTimeTypeConverter());
            cfg.CreateMap<Source, Destination>();
        });
        Mapper.AssertConfigurationIsValid();

        var source = new Source
        {
            Value1 = "5",
            Value2 = "01/01/2000",
            Value3 = "1.222"
        };

            Destination result = Mapper.Map<Source, Destination>(source);
写法也有不同，如果在转换的时候有逻辑或者判断可以直接使用 void ConvertUsing(Func<TSource, TDestination> mappingFunction);
 比如  cfg.CreateMap<string, int>().ConvertUsing(s => Convert.ToInt32(s));
 这里也可以使用
  cfg.CreateMap<string, int>().ConvertUsing(s => {
                    int res=0;
                    if (int.TryParse(s, out res))
                    {
                        return res;
                    }
                    else
                    {
                        return 0;
                    }
                });

   

当然自定义规则也可以将多个源属性值进行操作之后映射到某一个目标属性上

比如：

  public class Source
    {
        public int Value1 { get; set; }
        public int Value2 { get; set; }
    }

    public class Destination
    {
        public int Total { get; set; }
    }

    public class CustomResolver : IValueResolver<Source, Destination, int>
    {
        public int Resolve(Source source, Destination destination, int member, ResolutionContext context)
        {
            Destination dd = new Destination();
            dd.Total = source.Value1 + source.Value2;
            return dd.Total;
        }
    }
    
   Mapper.Initialize(cfg => cfg.CreateMap<Source, Destination>()
               .ForMember(dest => dest.Total, opt => opt.ResolveUsing<CustomResolver>()));
   Mapper.AssertConfigurationIsValid();

   var source = new Source
   {
       Value1 = 5,
       Value2 = 7
   };

  var result = Mapper.Map<Source, Destination>(source);
 
也可以操作单个值：
    public class CustomResolverV2 : IMemberValueResolver<object, object, int, int>
    {
        public int Resolve(object source, object destination, int sourceMember, int destinationMember, ResolutionContext context)
        {
            return sourceMember * 2;
        }
    }
    
 //初始化映射规则，
  Mapper.Initialize(cfg =>
     cfg.CreateMap<Source, Destination>()
     .ForMember(dest => dest.Total, opt => opt.ResolveUsing<CustomResolverV2, int>(src => src.Value1)));

     var dddddd = new Source
     {
         Value1 = 5,
         Value2 = 7
     };
     var ddddd = Mapper.Map<Source, Destination>(dddddd);

   

是否可以为空设置

    public class Source
    {
        public string Value { get; set; }
    }

    public class Dest
    {
        public string Value { get; set; }
    }
    
 var config = new MapperConfiguration(cfg => cfg.CreateMap<Source, Dest>()
    .ForMember(destination => destination.Value, opt => opt.NullSubstitute("Other Value")));
    
        var source = new Source { Value = null };
        var mapper = config.CreateMapper();
        
        var dest = mapper.Map<Source, Dest>(source);
        
        source.Value = "Not null";
       dest = mapper.Map<Source, Dest>(source);