.Net -- AutoMapper简单使用

哈丨吅

已于 2022-03-02 16:17:03 修改

阅读量2.6k

点赞数 2

分类专栏： C# 文章标签： .net Automapper 对象映射反射表达式目录树

于 2021-12-17 18:10:23 首次发布

本文链接：https://blog.csdn.net/a549742320/article/details/122001883

版权

C# 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

1. Nuget安装AutoMapper

AutoMapper是一个强大的对象映射工具，可以很方便的实现实体和实体之间的转换

2. 封装方法

//使用AutoMapper可以很方便的实现实体和实体之间的转换，它是一个强大的对象映射工具。
    /// <summary>
    /// AutoMapper扩展帮助类
    /// </summary>
    public static class AutoMapperHelper
    {
        /// <summary>
        ///  类型映射,默认字段名字一一对应
        /// </summary>
        /// <typeparam name="TDestination">转化之后的实体</typeparam>
        /// <typeparam name="TSource">要被转化的实体，Entity</typeparam>
        /// <param name="source">可以使用这个扩展方法的类型，任何引用类型</param>
        /// <returns>转化之后的实体</returns>
        public static TDestination MapTo<TSource,TDestination>(this TSource source)
            where TDestination : class
            where TSource : class
        {
            if (source == null)
            {
                return default(TDestination);
            }
            //创建映射关系
            var config = new MapperConfiguration(cfg => cfg.CreateMap<TSource, TDestination>());
            //基于config生成mapper
            var mapper = config.CreateMapper();
            //执行转换
            return mapper.Map<TDestination>(source);
        }

        /// <summary>
        /// 集合列表类型映射,默认字段名字一一对应
        /// </summary>
        /// <typeparam name="TDestination">转化之后的实体</typeparam>
        /// <typeparam name="TSource">要被转化的实体，Entity</typeparam>
        /// <param name="source">可以使用这个扩展方法的类型，任何引用类型</param>
        /// <returns>转化之后的实体列表</returns>
        public static IEnumerable<TDestination> MapToList<TSource, TDestination>(this IEnumerable<TSource> source)
            where TDestination : class
            where TSource : class
        {
            if (source == null)
            {
                return new List<TDestination>();
            }
            var config = new MapperConfiguration(cfg => cfg.CreateMap<TSource, TDestination>());
            var mapper = config.CreateMapper();
            return mapper.Map<List<TDestination>>(source);
        }
    }

3. 简单的示例类型

public class ViewModelA
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }

    public class ViewModelB
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }

    public class ViewModelC
    {
        public int Key { get; set; }
        public string Tag { get; set; }
        public int Age { get; set; }
    }

4. 应用

            //automapper测试
            ViewModelA viewModelA = new ViewModelA
            {
                ID = 2,
                Name = "Kilter"
            };
            ViewModelB viewModelB= viewModelA.MapTo<ViewModelA,ViewModelB>();
            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(viewModelB));

            //两个实体的属性名字没有全部对应的  单独处理
            MapperConfiguration config = new MapperConfiguration(cfg=>cfg.CreateMap<ViewModelA,ViewModelC>()
            .ForMember(d=>d.Key,opt=>opt.MapFrom(s=>s.ID))    //指定属性一一对应
            .ForMember(d=>d.Age,opt=>opt.Ignore())   //忽略该字段，不给该字段赋值
            .ForMember(d=>d.Tag,opt=>opt.MapFrom(s=>s.ID+"qwer"+s.Name))  //可以随意组合赋值
            );
            IMapper mapper = config.CreateMapper();
            ViewModelC viewModelC = mapper.Map<ViewModelC>(viewModelA);
            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(viewModelC));

            //列表映射
            ViewModelA modelA = new ViewModelA
            {
                ID = 3,
                Name = "taidi"
            };
            List<ViewModelA> modelAs = new List<ViewModelA>() { viewModelA, modelA };
            var modelB= modelAs.MapToList<ViewModelA, ViewModelB>();
            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(modelB));

5. 输出

6. 对象映射其他方式

6.1 反射实现

public static class ObjectMapperHelper
    {
        public static TDestination MapToByReflection<TSource, TDestination>(this TSource tIn)
        {
            TDestination tOut = Activator.CreateInstance<TDestination>();
            foreach (var itemOut in tOut.GetType().GetProperties())
            {
                foreach (var itemIn in tIn.GetType().GetProperties())
                {
                    if (itemOut.Name.Equals(itemIn.Name))
                    {
                        itemOut.SetValue(tOut, itemIn.GetValue(tIn));
                        break;
                    }
                }
            }
            foreach (var itemOut in tOut.GetType().GetFields())
            {
                foreach (var itemIn in tIn.GetType().GetFields())
                {
                    if (itemOut.Name.Equals(itemIn.Name))
                    {
                        itemOut.SetValue(tOut, itemIn.GetValue(tIn));
                        break;
                    }
                }
            }
            return tOut;
        }

    }

6.2 序列化实现

public static class ObjectMapperHelper
    {
        public static TDestination MapToByJsonserialize<TSource, TDestination>(this TSource tIn)
        {
            return Newtonsoft.Json.JsonConvert.DeserializeObject<TDestination>(Newtonsoft.Json.JsonConvert.SerializeObject(tIn));
        }
    }

6.3 表达式目录树实现

public static class ExpressionGenericMapperHelper
    {
        /// <summary>
        /// 表达式目录树实现对象映射    扩展方法
        /// </summary>
        /// <typeparam name="TSource">要被转化的实体</typeparam>
        /// <typeparam name="TDestination">转化之后的实体</typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static TDestination ExpressionMapTo<TSource, TDestination>(this TSource source)
        {
            //参数表达式
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TSource), "P");
            //创建绑定列表   绑定用于对新创建对象的成员进行初始化
            List<MemberBinding> memberBindingList = new List<MemberBinding>();
            //把TSource的属性值绑定到TDestination的属性进行初始化
            foreach (var item in typeof(TDestination).GetProperties())
            {
                MemberExpression property = Expression.Property(parameterExpression, typeof(TSource).GetProperty(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            //把TSource的字段值绑定到TDestination的字段进行初始化
            foreach (var item in typeof(TDestination).GetFields())
            {
                MemberExpression field = Expression.Field(parameterExpression, typeof(TSource).GetField(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, field);
                memberBindingList.Add(memberBinding);
            }
            //初始化新对象
            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TDestination)), memberBindingList.ToArray());
            //创建表达式目录树
            Expression<Func<TSource, TDestination>> expression = Expression.Lambda<Func<TSource, TDestination>>(memberInitExpression, new ParameterExpression[]
            {
                parameterExpression
            });
            //从表达式目录树生成委托
            Func<TSource, TDestination> _func = expression.Compile();
            //调用
            return _func.Invoke(source);
        }
    }