浅析依赖注入框架Autofac的使用

什么是依赖注入

依赖注入（Dependency Injection，DI）是一种设计模式，它可以将组件的依赖关系设计清晰、易于维护、易于测试。依赖注入主要是通过构造函数、属性和接口注入的方式将组件依赖关系解耦。在DI中，组件不再关注如何获取依赖组件，而是将依赖的对象交由其他组件来注入。

Autofac框架简介

Autofac是一个.NET IoC容器，是一种为.NET应用程序提供依赖注入特性的快速、灵活的框架，旨在为开发人员提供一个开放、灵活和可扩展的框架，有利于在.NET应用程序中实现依赖关系解耦。

如何使用Autofac框架

在使用Autofac框架之前，我们需要先安装Autofac NuGet包。

可以使用如下命令进行安装：

Install-Package Autofac

在安装完成后，在.NET应用程序中新增一个名为“Module”的类，实现IModule接口，如下所示：

using Autofac;

public class MyModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        // 注册依赖组件
        builder.RegisterType<MyService>().As<IMyService>().InstancePerDependency();
    }
}

在实现MyModule类（继承自Module）的Load方法中通过builder对象来注册依赖组件。其中，builder对象是Autofac的注册基础，可以通过其方法来注册各种依赖关系。

以上述代码中的注册为例，builder.RegisterType<MyService>()表示将MyService类注册为依赖组件，后面的.As<IMyService>()表示将其作为IMyService接口的实现进行注册。最后，InstancePerDependency()表示每次请求都新建一个实例。

接下来，我们需要在应用程序的启动入口处，也就是Main方法中，使用ContainerBuilder创建一个容器实例，然后通过容器来解析依赖关系。

using Autofac;

static void Main(string[] args)
{
    var builder = new ContainerBuilder();
    // 注册Module
    builder.RegisterModule(new MyModule());
    // 创建容器
    var container = builder.Build();
    // 从容器中获取依赖组件
    var myService = container.Resolve<IMyService>();
    // 使用依赖组件
    myService.DoSomething();
}

在以上代码中，我们首先通过new ContainerBuilder()创建一个容器构建器，然后通过builder.RegisterModule(new MyModule())注册依赖关系。最后，使用builder.Build()方法创建容器实例，并使用container.Resolve<IMyService>()从容器中获取IMyService接口的实例。

我们可以通过调用依赖组件的方法myService.DoSomething()依赖注入中实现DoSomething方法中的代码。

Autofac的使用示例

示例一

下面是一个简单的示例，演示如何在ASP.NET MVC中使用Autofac框架来实现依赖注入。

using Autofac;
using Autofac.Integration.Mvc;
using System.Web.Mvc;

public class MyModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        // 注册依赖组件
        builder.RegisterType<MyService>().As<IMyService>().InstancePerDependency();
    }
}

public class MvcApplication : HttpApplication
{
    protected void Application_Start(object sender, EventArgs e)
    {
        // 创建一个ContainerBuilder对象
        var builder = new ContainerBuilder();

        // 在容器构建器中注册类型
        builder.RegisterModule(new MyModule());

        // 注册MVC控制器类
        builder.RegisterControllers(typeof(MvcApplication).Assembly);

        // 使用Autofac作为MVC应用程序的默认依赖注入容器
        var container = builder.Build();
        DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
    }
}

public class MyController : Controller
{
    private readonly IMyService _myService;

    public MyController(IMyService myService)
    {
        _myService = myService;
    }

    public ActionResult Index()
    {
        // 使用依赖组件
        _myService.DoSomething();
        return View();
    }
}

在以上代码中，实现了MyModule类，定义了MyService的注册信息。在创建了一个ContainerBuilder对象后，通过builder.RegisterModule方法注册MyModule，在注册MVC控制器。

然后，在MVC应用程序中，使用Autofac作为默认的依赖注入容器，将创建一个AutofacDependencyResolver实例。最后，将IMyService接口注入到MyController类的构造函数中，完成依赖关系的注入。

示例二

下面是一个使用Autofac实现AOP的示例，该示例展示了如何在.NET Core中使用Autofac实现AOP。

using Autofac;
using Autofac.Extras.DynamicProxy;
using Castle.DynamicProxy;
using System;

public interface IMyService
{
    void DoSomething();
}

public class MyService : IMyService
{
    public void DoSomething()
    {
        Console.WriteLine("Do some thing.");
    }
}

public class LogInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine($"Invoke method {invocation.Method.Name}");
        invocation.Proceed();
    }
}

public class MyModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        // 注册依赖组件
        builder.RegisterType<MyService>().As<IMyService>()
            .EnableInterfaceInterceptors()
            .InterceptedBy(typeof(LogInterceptor))
            .InstancePerDependency();
        builder.RegisterType<LogInterceptor>().InstancePerDependency();
    }
}

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

        // 注册MyModule
        builder.RegisterModule(new MyModule());

        // 创建容器并获取IMyService组件
        var container = builder.Build();
        var myService = container.Resolve<IMyService>();

        // 调用DoSomething方法
        myService.DoSomething();

        Console.ReadLine();
    }
}

在以上代码中，我们定义了IMyService接口和MyService实现类，在MyService类的DoSomething方法中打印出了“Do some thing.”。

然后，在定义了一个LogInterceptor类，用于拦截IMyService接口的所有方法调用，并在调用方法前打印日志。

接着，我们将LogInterceptor类作为依赖组件，在注册时，通过.EnableInterfaceInterceptors()、.InterceptedBy(typeof(LogInterceptor))实现将LogInterceptor类注入到IMyService接口的实现中，完成AOP。

最后，在Main方法中，我们通过容器获取IMyService的依赖组件，并调用了DoSomething方法。在输出“The service is doing some thing.”字符串后，还会输出如下日志：

Invoke method DoSomething
The service is doing some thing.

以上示例展示了在.NET Core中使用Autofac实现AOP的方式。

结论

Autofac是一个强大、灵活的.NET依赖注入框架，可以应用于各种类型的.NET应用程序。在使用Autofac框架时，我们需要先在应用程序中创建Module类来注册依赖关系，并在应用程序启动时，使用ContainerBuilder创建一个容器实例，然后通过容器来解析依赖关系，使用依赖注入实现组件的解耦和可维护性。