摘要

依赖注入（Dependency Injection，简称DI）是一种设计模式，用于实现控制反转（Inversion of Control，简称IoC），以减少代码之间的耦合。在C#中，Autofac 是一个流行的IoC容器，它提供了一个强大的方式来管理对象的创建和它们的依赖关系。

正文

nuget 安装 Autofac

基础使用

首先，我们从一个简单的例子开始，介绍如何在一个控制台应用程序中使用Autofac。

假设我们有一个ILogger接口和一个ConsoleLogger实现：

C#
public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

我们还有一个Application类，它依赖于ILogger：

C#
public class Application
{
    private readonly ILogger _logger;

    public Application(ILogger logger)
    {
        _logger = logger;
    }

    public void Run()
    {
        _logger.Log("Application is running.");
    }
}

我们使用Autofac来设置依赖注入：

C#
using Autofac;

class Program
{
    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<ConsoleLogger>().As<ILogger>();
        builder.RegisterType<Application>();

        var container = builder.Build();

        using (var scope = container.BeginLifetimeScope())
        {
            var app = scope.Resolve<Application>();
            app.Run();
        }
    }
}

在这个基本示例中，我们创建了一个ContainerBuilder，然后注册了ConsoleLogger作为ILogger的实现，并注册了Application类。最后，我们通过调用Resolve<Application>()来解析Application的实例，并运行它。

场景1：属性注入

有时候我们希望通过属性来注入依赖，而不是通过构造函数。Autofac 支持属性注入，这里是一个例子：

C#
public class SomeService
{
    public ILogger Logger { get; set; }
}

C#
static void Main(string[] args)
{
    var builder=new ContainerBuilder();
    builder.RegisterType<ConsoleLogger>().As<ILogger>();
    builder.RegisterType<SomeService>().PropertiesAutowired();


    var container=builder.Build();

    using (var scope=container.BeginLifetimeScope())
    {
        var service=scope.Resolve<SomeService>();
        service.Logger.Log("属性注入");
    }
}

在这个例子中，我们通过调用.PropertiesAutowired()来告诉Autofac，它应该尝试自动注入SomeService的属性。

场景2：模块化注册

在大型应用程序中，我们可能希望将注册逻辑模块化。Autofac 允许我们通过创建模块来做到这一点。例如：

C#
public class LoggingModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<ConsoleLogger>().As<ILogger>();
    }
}

C#
static void Main(string[] args)
{
    var builder = new ContainerBuilder();
    builder.RegisterModule<LoggingModule>();
    builder.RegisterType<Application>();

    var container = builder.Build();

    using (var scope=container.BeginLifetimeScope())
    {
        var service=scope.Resolve<Application>();
        service.Run();
    }
}

在这里，我们创建了一个LoggingModule，它注册了ConsoleLogger作为ILogger的实现。然后我们在ContainerBuilder中注册这个模块。

场景3：使用Lambda表达式注册

Autofac 允许使用Lambda表达式来注册服务，这提供了更大的灵活性。例如：

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

    builder.Register(c => new ConsoleLogger()).As<ILogger>();

    builder.Register(c =>
    {
        var logger = c.Resolve<ILogger>();
        return new Application(logger);
    });

    var container = builder.Build();

    using (var scope=container.BeginLifetimeScope())
    {
        var service=scope.Resolve<Application>();
        service.Run();
    }
}

场景4：生命周期管理

Autofac 提供了多种生命周期管理选项，如单例（Singleton）、每次请求（InstancePerLifetimeScope）等。例如：

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

    builder.RegisterType<ConsoleLogger>().As<ILogger>().SingleInstance();
    builder.RegisterType<Application>().InstancePerLifetimeScope();


    var container = builder.Build();

    using (var scope=container.BeginLifetimeScope())
    {
        var service=scope.Resolve<Application>();
        service.Run();
    }
}

Autofac 是一个功能强大的依赖注入容器，它提供了许多高级特性来帮助你管理对象的生命周期和依赖关系。通过使用Autofac，你可以让你的应用程序更加模块化，更容易测试和维护。上述例子只是介绍了Autofac的一小部分功能。随着你对Autofac的深入学习，你会发现更多高级用法，以适应更复杂的场景和需求。