.NET CORE 中使用AutoMapper进行对象映射

1、NuGet安装

AutoMapper、AutoMapper.Extensions.Microsoft.DependencyInjection

2、新建以下几个文件

a：IProfile

namespace DTO.config
{
    public interface IProfile
    {
    }
}

b：MapperRegister

namespace DTO.config
{
    public static class MapperRegister
    {
        public static Type[] MapType()
        {
            var allIem = Assembly
               .GetEntryAssembly()
               .GetReferencedAssemblies()
               .Select(Assembly.Load)
               .SelectMany(y => y.DefinedTypes)
               .Where(type =>
                typeof(IProfile).GetTypeInfo().IsAssignableFrom(type.AsType()));
            List<Type> allList = new List<Type>();
            foreach (var typeinfo in allIem)
            {
                var type = typeinfo.AsType();
                allList.Add(type);
            }
            Type[] alltypes = allList.ToArray();
            return alltypes;
        }
    }
}

c：ConfigProfile

namespace DTO.config
{
    public class ConfigProfile : Profile, IProfile
    {
        public ConfigProfile()
        {
            Init();

            //单独添加映射
            //CreateMap<SysAdminDto, SysAdmin>();
            //CreateMap<SysAdmin, SysAdminDto>();

        }

        public static bool HasImplementedRawGeneric([NotNull] Type type, [NotNull] Type generic)
        {
            if (type == null || generic == null) return false;
            var isTheRawGenericType = type.GetInterfaces().Any(IsTheRawGenericType);
            if (isTheRawGenericType) return true;
            while (type != null && type != typeof(object))
            {
                isTheRawGenericType = IsTheRawGenericType(type);
                if (isTheRawGenericType) return true;
                type = type.BaseType;
            }
            return false;
            bool IsTheRawGenericType(Type test)
                => generic == (test.IsGenericType ? test.GetGenericTypeDefinition() : test);
        }

        //初始化映射，所有实现IDto接口的类
        void Init()
        {
            var nn = typeof(IDto<>).FullName;
            var types = typeof(IDto<>).Assembly.GetTypes()//获取命名空间的所有类
                .Where(t => HasImplementedRawGeneric(t, typeof(IDto<>)))//所有实现IDto泛型接口的类
                .Where(t => t.IsClass);//只选择类（排除接口自己）

            foreach (var dtoType in types)
            {
                var interFaces = dtoType.GetInterfaces();
                if (interFaces.Count() > 0)
                {
                    var otherType = interFaces[0].GetGenericArguments()[0];
                    var dtoMp = CreateMap(dtoType, otherType);
                    var otherMp = CreateMap(otherType, dtoType);

                    foreach (var prop in dtoType.GetProperties())
                    {
                        var attr = prop.GetCustomAttribute<MapFeildAttribute>();
                        if (attr != null)
                        {
                            dtoMp.ForMember(attr.name, x => x.MapFrom(prop.Name));
                            otherMp.ForMember(prop.Name, x => x.MapFrom(attr.name));
                        }
                    }
                }
            }
        }
    }
}

d：AutoMapperHelper

namespace DTO
{
    public static class AutoMapperHelper
    {
        private static IServiceProvider ServiceProvider;
        public static void UseStateAutoMapper(this IApplicationBuilder applicationBuilder)
        {
            ServiceProvider = applicationBuilder.ApplicationServices;
        }

        public static TDestination Map<TDestination>(object source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();
            return mapper.Map<TDestination>(source);
        }

        public static TDestination Map<TSource, TDestination>(TSource source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();

            return mapper.Map<TSource, TDestination>(source);
        }

        public static TDestination MapTo<TSource, TDestination>(this TSource source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();
            return mapper.Map<TSource, TDestination>(source);
        }

        public static TDestination MapTo<TDestination>(this object source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();
            return mapper.Map<TDestination>(source);
        }

        public static List<TDestination> MapToList<TDestination>(this IEnumerable source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();
            return mapper.Map<List<TDestination>>(source);
        }


        public static List<TDestination> MapToList<TSource, TDestination>(this IEnumerable<TSource> source)
        {
            var mapper = ServiceProvider.GetRequiredService<IMapper>();
            return mapper.Map<List<TDestination>>(source);
        }
    }
}

e：IDto

namespace DTO
{
    public interface IDto<T> where T : class, new()
    {
    }
}

f：MapFeildAttribute

namespace DTO.attribute
{
    [AttributeUsage(AttributeTargets.Property)]
    public class MapFeildAttribute : Attribute
    {
        public string name;
        public MapFeildAttribute(string name)
        {
            this.name = name;
        }
    }
}

3、系统配置

 public void ConfigureServices(IServiceCollection services)
        {           
            //注册automapper
            services.AddAutoMapper(MapperRegister.MapType());
        }

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {           
            //automapper
            app.UseStateAutoMapper();
        }

4、使用

namespace DTO
{
    //继承接口IDto，并传入泛型映射的实体类
    public class SysAdminDto : IDto<SysAdmin>
    {        
        public int id { get; set; }
       //使用注解MapFeild指定映射的字段，不指定则默认为字段名相同
        [MapFeild("role_type")]
        public int RoleType { get; set; } = 0;
        
        public int action_auth { get; set; } = 0;
        
    }
}

var sysAdmins= rBase.IQueryable<SysAdmin>().ToList();
var sysAdminDtos = list.MapToList<SysAdminDto>();

借鉴了很多网友的代码，仅此记录一下