Autofac全面解析系列(版本:3.5) – [使用篇(推荐篇):1.类型注册]

前言

Autofac

Autofac是一套高效的依赖注入框架。

Autofac官方网站:http://autofac.org/

Autofac在Github上的开源项目:https://github.com/autofac/Autofac

Autofac安装:通过VS的Nuget可以很方便的获取。

 

IoC/DI

关于IoC与DI的概念,网上有很多相关的博客,大家可以稍微了解一下,对比一下。

我个人的理解就是按照英文的中文翻译来理解的:

IoC: Inversion of Control 控制反转,将控制权进行反转,将本由自身控制的对象初始化交由外部IoC容器进行初始化;

DI: Dependency Injection 依赖注入,将对象依赖的其他对象,通过注入的方式进行初始化。

 

简单示例

我们先通过一个简单的例子来看看Autofac的基本使用方式以及一些概念:

class Program
{
    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<Class_1>();    //将Class_1注册到Autofac容器中

        IContainer container = builder.Build();
        Class_1 obj = container.Resolve<Class_1>(); //从autofac容器中获取Class_1对象
        Console.WriteLine(obj.Id);

        Console.Write("Press any key to continue...");
        Console.ReadKey();
    }
}
class Class_1
{
    public Guid Id { get; set; }

    public Class_1()
    {
        Id = Guid.NewGuid();
    }
}

上面的代码演示了最简单注册/获取方式。我们先通过ContainerBuilder进行类型注册,然后在后面可以通过IContainer进行获取类型实例。这里我们也明白了一点,类型是需要先进行注册,然后才能够通过Autofac进行获取(后面会谈到一些特殊的配置,但是这也属于另类的注册方式)。

然后我们能知道在Autofac中,先通过ContainerBuilder进行类型注册,然后通过ContainerBuilder的Build方法来获取IContainer类型实例,后面则可以通过该IContainer实例来获取注册类型的实例对象。

 

Autofac类型注册

类型/泛型注册

在简单实例中,我们已经看到了一种注册方式,那就是泛型注册:

builder.RegisterType<Class_1>();

这种注册方式很方便也很简单,比较常用,但是有一个缺点就是,注册的类型必须在当前项目或被当前项目引用,因为使用泛型,必须类型明确。针对这点,还有一种通过Type对象进行注册的方式:

//字符串为类型完全名称
builder.RegisterType(Type.GetType("AutofacBlog.Class_1"));

使用这种方式进行类型注册,被注册的类型可以不是被直接引用,但是注意,类型所在的程序集必须被加载。

这种注册方式,在有插件或类似需要动态加载程序集的情况下比较使用,通过扫描程序集,获取一些满足指定条件的类型,来进行注册。

 

程序集批量注册

类型注册中提到了通过扫描程序集,来获取部分类型进行注册。Autofac对此提供了一个方便的方式,可以直接通过程序集来筛选类型注册:

//获取当前应用程序加载程序集(C/S应用中使用)
var assembly = Assembly.GetExecutingAssembly();
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(assembly); //注册所有程序集类定义的非静态类型

上述代码中,通过RegisterAssemblyTypes方法,将assembly中所有自定义的非静态类型都注册到Autofac中,后面可以使用IContainer对象获取所有该程序集中自定义的类型对象。

这种方式达到了批量的效果,但是通常,我们并不需要把所有的类型都进行注册,所以Autofac提供了几种过滤方式:

builder.RegisterAssemblyTypes(assembly)
    .Where(type => type.Namespace.Equals("IocAutofac.Example")); //条件判断

这种方式相信大家都比较熟悉,Where+lambda的方式来进行条件判断,lambda参数为Type类型,也就是程序集中的type。

builder.RegisterAssemblyTypes(assembly)
    .Except<Program>();  //排除Program类型

这种方式用来排除指定类型的注册,当排除的个例比较少时,会比较适用。Except还有另一种用法,但是用法比较复杂,在此不进行介绍。

builder.RegisterAssemblyTypes(assembly)
    .InNamespace("IocAutofac.Example");  //类型在IocAutofac.Example命名空间中

被注册的类型需要在指定命名空间中。

builder.RegisterAssemblyTypes(assembly)
    .InNamespaceOf<Program>();  //类型在Program所在的命名空间中*/

这种方式与上面一种方式比较相似,也是用来判断命名空间的,这种方式是根据类型来获取命名空间。

 

通过这种方式,我们可以对程序集中的类型进行批量注册,类型/泛型方式在被注册类型较少的情况下还是不错的,但当被注册类型很多的时候,一个一个的手写注册会显得很无力,这时候就是程序集批量注册显威的时候了。

 

Lambda注册

上面讲到的两种方式都是通过类型进行直接注册的,这种注册方式,在获取时,会直接通过构造函数new出对象(关于构造函数的优选选择在后面的博文中将进行说明),不会做更多的操作。有时,我们希望能够在获取对象时能够自动的做更多的事情时,我们可以通过Lambda注册来解决:

builder.Register(cc =>
{
    var clas1 = new Class_1();
    while (clas1.Id.ToString().Contains("a"))
    {
        clas1.Id = Guid.NewGuid();
    }
    return clas1;
});

上述代码,实际注册了Class_1类型,因为最后返回的对象类型为Class_1。

Register方法接收了一个lambda表达式作为参数,在lambda表达式中,我们可以做很多事,包括一些属性注入(后续说明)、方法注入(后续说明)、条件判断等等。

我们在通过Autofac获取Class_1对象时,实际会执行这样的一个表达式。另外,lambda表达式的参数cc的类型是IComponentContext,这里我们可以简单的当做IContainer进行使用。

 

实例注册

var clas1 = new Class_1();
clas1.Id = Guid.Empty;

builder.RegisterInstance(clas1);

通过RegisterInstance进行实例注册,进行实例注册时,我们需要注意,实例注册可以作为一种单例注册的方式,也就是在后面通过Autofac获取Class_1对象时,获取到的是注册时的那个对象。并且,如果一个在某处修改了该对象,其他地方再获取时,获取到的就是修改后的对象。

 

Module注册

在日常开发中,可能不同开发会负责不同的模块进行单独开发。在开发过程中,不同模块不同开发可能都有自己的类型需要注册到autofac中,但是如果每个人在注册时,都去修改一个指定地方的代码,这在进行代码合并时,是令人痛苦的。更好的方式是,每个开发不同的模块都有自己指定的类型注册区域,这样,在代码合并时,会减少很多代码冲突。

对于这种方式,Autofac已经为我们提供了:

class Program
{
    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();

        builder.RegisterModule<ModuleA>();
        //这两种注册方式达到的效果都一样
        builder.RegisterModule(new ModuleB());

        IContainer container = builder.Build();
        Class_1 clas1 = container.Resolve<Class_1>();
        Class_2 clas2 = container.Resolve<Class_2>();
        Console.WriteLine(clas1.Id);
        Console.WriteLine(clas2.ToString());

        Console.Write("Press any key to continue...");
        Console.ReadKey();
    }
}


class ModuleA : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<Class_1>();
    }
}

class ModuleB : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<Class_2>();
    }
}
class Class_2
{

}

上述代码中,有两个继承自Module类的类:ModuleA、ModuleB,这两个类型重写了父类的Load方法,并在load方法中,分别注册了Class_1与Class_2类型。然后在主程序中,通过RegisterModule对Module进行注册。

通过这种方式,不同的开发就可以各自创建一个类继承自Module,然后重写Load方法,在Load方法进行自己的类型注册,最后再进行Module的统一注册。

Module注意说明

实际上,RegisterModule需要的参数,并不是继承自Module类的,而是实现了IModule接口的类,而Module也是实现了IModule接口的。也就是我们也可以写一个实现了IModule接口的类型,然后在RegisterModule时传入。但是一般我们直接去继承Module就好了,这种方式比较简单方便,实现IModule的方式更为复杂,当然,功能也更多,在此就不进行介绍了。

 

程序集Module注册

Module注册,为多人开发提供了一种方便的注册方式,但是我们也可以发现,这种方式,还是会需要手动注册Module,如果Module过多,Module注册代码也会显得多而杂,当然,可以通过人工管理来控制Module的量。但是Autofac还提供了一种更方便的方式,并且,对于类似Orchard的模块开发(子模块与主模块无引用关系,通过程序集加载方式来加载子模块)或是插件开发,我们没办法通过Registerodule来注册无直接引用关系的Module。

对于上述的情况,Autofac提供了很好的方式来解决:

var builder = new ContainerBuilder();
var assembly = Assembly.GetExecutingAssembly();
builder.RegisterAssemblyModules(assembly);

上述代码会注册assembly程序集中所有实现了IModule接口的类型(多层继承也算),这样,我们只需要将取出所有程序集,然后通过RegisterAssemblyModules进行一次性注册,就可以自动注册所有Module了。

RegisterAssemblyModule还可以指定一个泛型类型:

builder.RegisterAssemblyModules<ModuleA>(assembly);

这样注册,是指定只注册assembly程序集中继承自ModuleA的Module。

 

尾述

本篇博文主要讲述Autofac中比较常用也比较好用的注册方式,并没有把所有的注册方式都讲述出来。

个人非常推荐使用Module,每个项目拥有自己的一个Module,这样的一个Module都有固定的未知,便于查找该项目中的注册及依赖关系。

通过本篇博文,可以了解到几种常用的注册方式,以及最简单的对象获取方式,初学者可以简单的试试。

本篇博文讲述的内容可能与大家平时使用autofac的方式不一样,平时使用时还会使用As,但是我个人认为这个不属于单纯注册的内容,所以将这部分放到后面的博文中。

posted @ 2015-11-30 17:38 An.Cup.Of.Coffee 阅读(...) 评论(...) 编辑 收藏
顶部

底部
Copyright ©2016 An.Cup.Of.Coffee