封装一个Automapper单例

  public class DataModule : IModule
    {
        public void Configure(IMapperConfigurationExpression cfg)
        {
            //cfg.CreateMap<ApproveAtcPo, ApproveAtcVo>().ReverseMap();
       
        }
    }

         /// <summary>
        /// 注册需要转换的类型
        /// </summary>
        private PoMapper()
        {
            AutoMapper.Mapper.Initialize(cfg =>
            {
                //多模块注册方式
                new DataModule().Configure(cfg);
                new AliasModule().Configure(cfg); 
            });
        }

    public class MapperTool
    {
        private static volatile MapperTool mapper = null;
        private static object syncRoot = new Object();
        public static readonly List<Type> typeList = null;
        /// <summary>
        /// 注册需要转换的类型
        /// </summary>
        private MapperTool()
        {
            Mapper.Initialize(cfg =>
            {
                //指定不同属性映射demo
                //cfg.CreateMap<auth_userVo, t_auth_user>()
                //   .ReverseMap()
                //   .ForMember(dest => dest.id, opt => opt.MapFrom(src => src.rid))
                //   .ForMember(dest => dest.update, opt => opt.MapFrom(src => src.create));
             
            });
            //验证是否所有字段都转换了
            //Mapper.Configuration.AssertConfigurationIsValid();
        }

        private MapperTool(List<Type[]> TypeList)
        {
            Mapper.Initialize(cfg =>
            {
                foreach (var type in TypeList)
                {
                    cfg.CreateMap(type[0], type[1]).ReverseMap();
                }
            });
        }


        /// <summary>
        /// 初始化注册Mapper
        /// </summary>
        public static MapperTool Instance
        {
            get
            {
                if (mapper == null)
                {
                    lock (syncRoot)
                    {
                        if (mapper == null)
                        {
                            mapper = new MapperTool();
                        }

                    }
                }
                return mapper;
            }
        }

        /// <summary>
        /// 传入需要转换的对象
        /// </summary>
        /// <typeparam name="F">需要转换的对象类型</typeparam>
        /// <typeparam name="T">转换目标对象类型</typeparam>
        /// <param name="f">需要转换的对象</param>
        /// <returns>目标对象</returns>
        public T Map<F, T>(F f)
            where F : new()
            where T : new()
        {
            return Mapper.Map<F, T>(f);
        }
    }