详解C#中的依赖注入和IoC容器

什么是依赖注入

依赖注入（Dependency Injection，简称DI）是一种设计模式，用于减少代码间的耦合关系。在依赖注入中，对象依赖不会被硬编码进对象中，而是由外部的实体注入依赖关系。

在实际开发中，依赖通常指的是对象和组件需要的其他对象或组件。依赖注入可以让代码的设计更加灵活，易于维护和扩展。

IoC容器

在依赖注入的代码实现中，我们通常使用IoC容器来管理依赖注入的对象。IoC是Inversion of Control的缩写，即控制反转。

在传统的编程模式中，我们通过代码控制对象的创建、初始化和销毁等一系列操作。而在IoC模式中，这些操作都交给了IoC容器来管理。

IoC容器通常具有以下特点：

• 自动创建和管理对象实例。
• 自动注入依赖关系。
• 管理对象的生命周期。

目前常见的IoC容器有很多，如Autofac、Unity、Castle Windsor等，每个IoC容器都有其自己的优缺点和使用方式。

依赖注入的使用

下面是一个简单的依赖注入示例，我们使用Autofac作为IoC容器。

首先，我们定义一个接口ILogger：

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

然后，我们创建一个实现ILogger接口的类FileLogger：

public class FileLogger : ILogger
{
    public void Log(string message)
    {
        // 实现写入文件的逻辑
    }
}

我们现在有一个类UserService，它依赖于ILogger：

public class UserService
{
    private readonly ILogger logger;

    public UserService(ILogger logger)
    {
        this.logger = logger;
    }

    public void SaveUser(User user)
    {
        // 保存User对象的逻辑
        logger.Log("User Saved.");
    }
}

现在，我们需要使用Autofac容器来完成依赖注入。首先，我们需要在程序中安装Autofac：

PM> Install-Package Autofac

然后，我们可以使用以下代码来实现依赖注入：

var builder = new ContainerBuilder();
builder.RegisterType<FileLogger>().As<ILogger>();
builder.RegisterType<UserService>();
var container = builder.Build();

// 从容器中获取UserService类型实例
var userService = container.Resolve<UserService>();

在这个示例中，我们使用RegisterType方法注册了ILogger（FileLogger实现类）和UserService类型，并且将ILogger注册成As方法中定义的“服务”类型，以便在UserService的构造函数中进行注入。

最后，我们通过container.Resolve方法获取UserService类型的实例，IoC容器将会自动注入依赖的ILogger对象。

依赖注入的优点

• 代码耦合度低，易于维护和扩展。
• 依赖关系明确，易于测试。
• 代码可读性更高，业务逻辑更清晰。

示例一：使用依赖注入和IoC容器注入数据库连接

首先，我们定义一个接口IDatabaseConnection：

public interface IDatabaseConnection
{
    SqlConnection GetConnection();
}

然后，我们创建一个实现IDatabaseConnection接口的类DatabaseConnection：

public class DatabaseConnection : IDatabaseConnection
{
    private readonly string connectionString;

    public DatabaseConnection(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public SqlConnection GetConnection()
    {
        return new SqlConnection(connectionString);
    }
}

我们现在有一个类SqlUserService，它依赖于SqlConnection：

public class SqlUserService
{
    private readonly SqlConnection connection;

    public SqlUserService(SqlConnection connection)
    {
        this.connection = connection;
    }

    public IEnumerable<User> GetUsers()
    {
        // 从数据库获取用户的逻辑
    }

    public void SaveUser(User user)
    {
        // 保存User对象的逻辑
    }
}

现在，我们需要使用Autofac容器来完成依赖注入。首先，我们需要在程序中安装Autofac：

PM> Install-Package Autofac

然后，我们可以使用以下代码来实现依赖注入：

var builder = new ContainerBuilder();
builder.RegisterType<DatabaseConnection>()
       .As<IDatabaseConnection>()
       .WithParameter("connectionString", @"Data Source=(local)\SQLEXPRESS;Initial Catalog=TestDB;Integrated Security=True");

builder.RegisterType<SqlUserService>();

var container = builder.Build();

using(var scope = container.BeginLifetimeScope())
{
    var userService = scope.Resolve<SqlUserService>();
}

在这个示例中，我们使用RegisterType方法注册了IDatabaseConnection（DatabaseConnection实现类）和SqlUserService类型，并且将IDatabaseConnection注册成As方法中定义的“服务”类型，以便在SqlUserService的构造函数中进行注入。

最后，我们通过scope.Resolve方法获取SqlUserService类型的实例，IoC容器将会自动注入依赖的SqlConnection对象。

示例二：使用依赖注入和IoC容器注入配置文件

首先，我们定义一个接口IConfiguration：

public interface IConfiguration
{
    string GetValue(string key);
}

然后，我们创建一个实现IConfiguration接口的类AppSettingsConfiguration：

public class AppSettingsConfiguration : IConfiguration
{
    public string GetValue(string key)
    {
        return ConfigurationManager.AppSettings[key];
    }
}

我们现在有一个类MyClass，它依赖于IConfiguration：

public class MyClass
{
    private readonly IConfiguration config;

    public MyClass(IConfiguration config)
    {
        this.config = config;
    }

    public void DoSomething()
    {
        string value = config.GetValue("MyKey");
        Console.WriteLine(value);
    }
}

现在，我们需要使用Autofac容器来完成依赖注入。首先，我们需要在程序中安装Autofac：

PM> Install-Package Autofac

然后，我们可以使用以下代码来实现依赖注入：

var builder = new ContainerBuilder();
builder.RegisterType<AppSettingsConfiguration>()
       .As<IConfiguration>();

builder.RegisterType<MyClass>();

var container = builder.Build();

using(var scope = container.BeginLifetimeScope())
{
    var myClass = scope.Resolve<MyClass>();
    myClass.DoSomething();
}

在这个示例中，我们使用RegisterType方法注册了IConfiguration（AppSettingsConfiguration实现类）和MyClass类型，并且将IConfiguration注册成As方法中定义的“服务”类型，以便在MyClass的构造函数中进行注入。

最后，我们通过scope.Resolve方法获取MyClass类型的实例，IoC容器将会自动注入依赖的IConfiguration对象。

总结

本文简要介绍了依赖注入以及IoC容器的概念，并且通过两个示例详细讲解了如何在C#中使用依赖注入和IoC容器实现代码的灵活、易于维护和扩展等优点。虽然示例中我们使用的是Autofac，但是基本上所有的IoC容器都具有统一的原理和使用方式。