.net Core中使用AutoMapper

第一种：只引用AutoMapper包写一个AutoMapperExtension的扩展方法

废话不多说扩展方法代码如下

/// <summary>
    /// AutoMapper扩展
    /// </summary>
    public static class AutoMapperExtension
    {
        /// <summary>
        /// 类型映射
        /// </summary>
        /// <typeparam name="TDestination">映射后的对象</typeparam>
        /// <param name="obj">要映射的对象</param>
        /// <returns></returns>
        public static TDestination MapTo<TDestination>(this object obj) where TDestination : class
        {
            if (obj == null) return default(TDestination);
            var config = new MapperConfiguration(cfg => cfg.CreateMap<TDestination, object>());
            var mapper = config.CreateMapper();
            return mapper.Map<TDestination>(obj);
        }

        /// <summary>
        /// 集合列表类型映射
        /// </summary>
        /// <typeparam name="TDestination">目标对象类型</typeparam>
        /// <param name="source">数据源</param>
        /// <returns></returns>
        public static List<TDestination> MapTo<TDestination>(this IEnumerable<TDestination> source) where TDestination : class
        {
            if (source == null) return default(List<TDestination>);

            var config = new MapperConfiguration(cfg => cfg.CreateMap(source.GetType(), typeof(TDestination)));
            var mapper = config.CreateMapper();
            return mapper.Map<List<TDestination>>(source);
        }

        /// <summary>
        /// 集合列表类型映射
        /// </summary>
        /// <typeparam name="TSource">数据源类型</typeparam>
        /// <typeparam name="TDestination">目标对象类型</typeparam>
        /// <param name="source">数据源</param>
        /// <returns></returns>
        public static List<TDestination> MapTo<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);
        }

        /// <summary>
        /// 集合列表类型映射
        /// </summary>
        /// <typeparam name="TSource">数据源类型</typeparam>
        /// <typeparam name="TDestination">目标对象类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="configure">自定义配置</param>
        /// <returns></returns>
        public static List<TDestination> MapTo<TSource, TDestination>(this IEnumerable<TSource> source, Action<IMapperConfigurationExpression> configure)
            where TDestination : class
            where TSource : class
        {
            if (source == null) return new List<TDestination>();

            var config = new MapperConfiguration(configure);
            var mapper = config.CreateMapper();
            return mapper.Map<List<TDestination>>(source);
        }

        /// <summary>
        /// 类型映射
        /// </summary>
        /// <typeparam name="TSource">数据源类型</typeparam>
        /// <typeparam name="TDestination">目标对象类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="destination">目标对象</param>
        /// <returns></returns>
        public static TDestination MapTo<TSource, TDestination>(this TSource source, TDestination destination)
            where TSource : class
            where TDestination : class
        {
            if (source == null) return destination;

            var config = new MapperConfiguration(cfg => cfg.CreateMap<TSource, TDestination>());
            var mapper = config.CreateMapper();
            return mapper.Map<TSource, TDestination>(source, destination);
        }

        /// <summary>
        /// 类型映射,默认字段名字一一对应
        /// </summary>
        /// <typeparam name="TDestination">转化之后的model，可以理解为viewmodel</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>());
            var mapper = config.CreateMapper();
            return mapper.Map<TDestination>(source);
        }

    }

使用AutoMapper推荐这个AutoMapperExtension.MapTo<TSource, TDestination>(this TSource source);方法

 class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student
            {
                Id=5,
                Name="张三",
                Email="146855"
            };
            StudentView model = AutoMapperExtension.MapTo<Student,StudentView>(student);
            bool b = model is null;
            Console.WriteLine(b);
            Console.ReadKey();
        }
    }

    public class Student
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public string Email { get; set; }

    }
    public class StudentView
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public string Email { get; set; }
        public string ClassName { get; set; }

    }

结果如下student转化studentView成功

第二种：写一个配置类懒得写直接参考下面的文章，麻烦一点

文章来自https://www.cnblogs.com/chenxi001/archive/2019/11/05/11800943.html

在我们的项目中慢慢的要把数据库的实体模型和视图模型进行分离，防止被人拿到我们表字段。在学校的时候自己只是有将很多数据库模型，写成一个视图模型返回到前台。

 首先我们把这两个包引入项目中去。

然后我们创建一个转换配置类，这个类要继承 Profile 将我们需要转换的类写到我们构造函数里面去，这里要注意我们左边的UserEntity是要将这个类型的数据转换成UserModel

当然这个可以反过来，但是你转换的关系一定要正确，左为要转换的数据类型，右边是转换后的数据类型。（我已经帮你们测试了，关系不对乱转报错。）

在Startup 写入注入这个配置

 

下面我们创建两个类

这个是我们平常中数据库表实体

这是我们的视图模型

 这个里要注意，在转化的时候只有名字相同的字段才会成功附上对应的值。（大小写可以不管，但是在项目中要做到一致，我上面没有一致是测试一下。）

然后就是使用了

我们只要在使用的地方，注入进来了，就可以使用了。

这个是单个实体的转换

 简写方法，直接写要转成什么类型就可以了，但是转换的配置类法不变。

 当然我们还有集合的转换了