封装一个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[], type[]).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);
         }
     }