AutoMapper系列2-聚合、解耦

刺骨的言语ヽ痛彻心扉 2022-05-17 12:48 185阅读 0赞

对于某个聚合对象，可能存在嵌套，思路基本是一致的：

#region demo5
        public class OuterSource
        {
            public int Value { get; set; }
            public InnerSource Inner { get; set; }
        }
        public class InnerSource
        {
            public int OtherValue { get; set; }
        }
    
        public class OuterDest
        {
            public int Value { get; set; }
            public InnerDest Inner { get; set; }
        }
        public class InnerDest
        {
            public int OtherValue { get; set; }
        }
        #endregion

#region Nesting
                Mapper.Initialize(cfg =>
                {
                    cfg.CreateMap<OuterSource, OuterDest>();
                    //cfg.CreateMap<InnerSource, InnerDest>();
                });
    
                var source = new OuterSource
                {
                    Value = 5,
                    Inner = new InnerSource { OtherValue = 15 }
                };
    
                //验证类型映射是否正确
                //Mapper.AssertConfigurationIsValid();
    
                //执行映射
                var dest = Mapper.Map<OuterSource, OuterDest>(source);
    
                Console.WriteLine("dest.Value:" + dest.Value);
                Console.WriteLine("dest.Inner is null:" + (dest.Inner == null ? "true" : "false"));
                Console.WriteLine("dest.Inner.OtherValue:" + dest.Inner.OtherValue);
                #endregion

![70][]

关于解耦处理（使得映射的方式更加灵活，可以通过外部配置映射方式）：

#region demo6
        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 CustomResolver : IValueResolver<Source2, Destination2, int>
        {
            int IValueResolver<Source2, Destination2, int>.Resolve(Source2 source, Destination2 destMember, int destination, ResolutionContext context)
            {
                return source.Value1 + source.Value2;
            }
        }
        public class DateTimeTypeConverter : ITypeConverter<string, DateTime>
        {
            DateTime ITypeConverter<string, DateTime>.Convert(string source, DateTime destination, ResolutionContext context)
            {
                try
                {
                    return System.Convert.ToDateTime(source);
                }
                catch
                {
                    return DateTime.MinValue;
                }
            }
        }
        public class TypeTypeConverter : ITypeConverter<string, Type>
        {
            Type ITypeConverter<string, Type>.Convert(string source, Type destination, ResolutionContext context)
            {
                TypeConverter dd = TypeDescriptor.GetConverter(source.GetType());
                dd.CanConvertTo(typeof(Type));
                Type type = Assembly.GetExecutingAssembly().GetType(source);
                return type;
            }
        }
        #endregion

#region
                var source = new Source
                {
                    Value1 = "5",
                    Value2 = "01/18/2018jj",
                    Value3 = "LibStudy.Program"
                };
    
                Mapper.Initialize(cfg =>
                {
                    cfg.CreateMap<string, int>().ConvertUsing(x => Convert.ToInt32(x));
                    cfg.CreateMap<string, DateTime>().ConvertUsing(new DateTimeTypeConverter());
                    cfg.CreateMap<string, Type>().ConvertUsing<TypeTypeConverter>();
                    cfg.CreateMap<Source, Destination>();
                });
    
                //验证类型映射是否正确
                Mapper.AssertConfigurationIsValid();
    
                Destination result = Mapper.Map<Source, Destination>(source);
                Console.WriteLine("result.Value1:" + result.Value1.ToString());
                Console.WriteLine("result.Value2:" + result.Value2.ToString());
                Console.WriteLine("result.Value3:" + result.Value3.ToString());
                #endregion

![70 1][]

#region 解耦映射2
                var source2 = new Source2
                {
                    Value1 = 5,
                    Value2 = 7
                };
                Mapper.Initialize(cfg =>
                {
                    cfg.CreateMap<Source2, Destination2>()
                       //.ForMember(dest => dest.Total, opt => opt.MapFrom(src => src.Value1 + src.Value2));
                       .ForMember(dest => dest.Total, opt => opt.ResolveUsing<CustomResolver>());
                });
    
                var result2 = Mapper.Map<Source2, Destination2>(source2);
                Console.WriteLine("result.Total:" + result2.Total);
                #endregion

![70 2][]

[70]: /images/20220517/1434740a5f8946299e07f0360f6e3d76.png
[70 1]: /images/20220517/7879f73b7cb44c3aa3f50ba0ebbac1f9.png
[70 2]: /images/20220517/8d0c72c78a5e49f9a6d3fbbb3ec8cfaa.png