【反射】——Autofac 类型注册

　　Autofac是.net界一款轻量化的IOC组件，使用Autofac可以帮助完成代码中很多依赖注入工作。在以前文章中，介绍过Autofac的配置过程（http://www.cnblogs.com/Jnw-qianxi/p/3450344.html），在我以往的配置过程中，接口与接口的实现类的注册在一个静态方法RegisterAutofac中实现：

 1 public static void RegisterAutofac()

 2         {

 3             ContainerBuilder builder = new ContainerBuilder();

 4             builder.RegisterControllers(Assembly.GetExecutingAssembly());

 5 

 6             #region IOC注册区域

 7         

 8            

 9             //Admin

10             builder.RegisterType<AdminService>().As<IAdminService>().InstancePerHttpRequest();

11 

12         

13             #endregion

14             // then

15             var container = builder.Build();

16             DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

17           

18         }

　　　 随着系统开发的进行，IOC注册区域中会不断添加新的注册，不同区域，不同模块的类型注册都会在这进行（数据仓储层，业务逻辑层，基础设施层等等不同层次的类型注册都要在此方法中进行），同时系统不同开发人员都需要维护该方法，这样带来

RegisterAutofac方法所在类的臃肿，且不符合类的职责单一原则。

　　为此我想到，能否根据注册类型，将IOC注册区域部分提取到不同的类中实现，将如这些类拥有一个共同的接口，不是就可以根据接口反射出获取这些类了吗？
　　
首先，定义反射类。用于获取继承接口的类型

 1  public class ContainerTypeFinder : ITypeFinder

 2     {

 3 

 4         public IList<Assembly> GetAssemblies()

 5         {

 6             //由于注册文件可能分布在不同类库，为此我们获取所有程序集，而不是当前程序集

 7             return AppDomain.CurrentDomain.GetAssemblies();

 8 

 9         }

10 

11         public IEnumerable<Type> FindClassesOfType(Type assignTypeFrom)

12         {

13             var list = new List<Type>();

14             foreach (var item in GetAssemblies())

15             {

16                 var typesToRegister = item.GetTypes()

17               .Where(type => !String.IsNullOrEmpty(type.Namespace))

18               .Where(type => type.GetInterface(assignTypeFrom.Name) == assignTypeFrom)

19              ;

20                 if (typesToRegister.Count() > 0)

21                 {

22                     list.AddRange(typesToRegister);

23                 }

24             }

25             return list;

26         }

27     }

　　然后，就是将IOC注册区域移除到类当中

 1  public interface IDependencyRegistrar

 2     {

 3         void Register(ContainerBuilder builder);

 4 

 5         int Order { get; }

 6     }

 7 

 8 

 9  public class DependencyRegistrar : IDependencyRegistrar

10     {

11         public void Register(ContainerBuilder builder)

12         {

13             builder.RegisterType<EfRepository<Core.Domain.Customer.Customer>>().As<IRepository<Core.Domain.Customer.Customer>>().InstancePerHttpRequest();

14         }

15 

16         public int Order

17         {

18             get { return 1; }

19         }

20     }

　　IDependencyRegistrar就是我们上面所说的接口，ContainerTypeFinder类当中的FindClassesOfType（）方法会搜寻所有实现该接口的类。实现的注册工作在Register()方法中完成。
接着，封装一个方法完成所有的Autofac注册工作，同时便于在Global中调用：

 1 public static void InitContainer() 

 2         {

 3             //autofac 容器

 4             ContainerBuilder builder = new ContainerBuilder();

 5             //注册所有控制器

 6             builder.RegisterControllers(_typeFinder.GetAssemblies().ToArray());

 7 

 8             #region 反射 核心

 9             //通过反射得到继承IDependencyRegistrar该接口的类成员

10             var types = _typeFinder.FindClassesOfType(typeof(IDependencyRegistrar));

11             var drInstances = new List<IDependencyRegistrar>();

12             //创建实例

13             foreach (var drType in types)

14                 drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));

15             //sort

16             drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();

17             //执行Register方法

18             foreach (var dependencyRegistrar in drInstances)

19                 dependencyRegistrar.Register(builder);

20             #endregion

21 

22             //then

23            var container = builder.Build();

24            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

最后在Global文件Application_Start()方法中调用上述方法

 1 ContainerManager.InitContainer(); 

---