【C#依赖注入】：避开这些常见陷阱，提升代码质量

# 1. C#依赖注入的原理和优势

依赖注入（Dependency Injection，简称DI）是现代软件开发中一种广泛采用的设计模式，它有助于提升代码的可测试性、可维护性和可扩展性。本章将介绍依赖注入的基本原理，以及它在C#应用程序中的优势。

## 依赖注入的基础

依赖注入意味着将一个类的依赖传递给它，而不是让类自己创建依赖。这种模式使得类之间不再紧密耦合，依赖关系变得清晰，为单元测试和替换实现提供了便利。

### 依赖注入的三大核心原则

- **单一职责原则**：一个类应该只有一个引起变化的原因，即一个类只负责一项任务。
- **依赖倒置原则**：高层次模块不应该依赖低层次模块，两者都应该依赖抽象。
- **控制反转（IoC）**：依赖对象的创建和维护的责任转移到外部容器，也就是IoC容器。

### C#中依赖注入的优势

- **解耦**：依赖注入有助于减少类之间的依赖，使得代码结构更为清晰。
- **可测试性**：依赖可以通过模拟对象进行替换，从而简化单元测试。
- **灵活性和可配置性**：可以在应用程序外部配置依赖关系，增强了程序的可配置性。

// 示例代码：C#中的依赖注入示例
public class ServiceA {}
public class ServiceB
{
    private readonly ServiceA _serviceA;
    public ServiceB(ServiceA serviceA)
    {
        _serviceA = serviceA ?? throw new ArgumentNullException(nameof(serviceA));
    }
}

// 注入依赖
var builder = new ServiceCollection()
    .AddTransient<ServiceA>()
    .AddTransient<ServiceB>()
    .BuildServiceProvider();

var serviceB = builder.GetService<ServiceB>(); // ServiceA 被注入到 ServiceB 中

在这个例子中，我们创建了两个服务（ServiceA 和 ServiceB），并通过构造函数注入的方式将 ServiceA 依赖到 ServiceB 中。通过这样的方式，我们可以利用 .NET Core 的内置依赖注入容器轻松地管理和配置依赖关系。

在下一章，我们将深入探讨如何在 .NET Core 中使用依赖注入容器，并解释如何注册和解析服务，以及管理服务的作用域和生命周期。

# 2. C#依赖注入的基本实现

依赖注入（Dependency Injection, DI）是面向对象编程中的一种设计模式，它实现了控制反转（Inversion of Control, IoC）原则。通过依赖注入，我们可以实现更松散耦合的代码结构，提高系统的可维护性和可测试性。在.NET Core中，依赖注入是内置支持的，它提供了一个高效的容器来管理依赖关系和服务生命周期。在本章节中，我们将深入了解依赖注入在C#中的实现原理，并探讨如何在.NET Core项目中运用这一强大的特性。

### 2.1 依赖注入的理论基础

#### 2.1.1 依赖倒置原则

依赖倒置原则是面向对象设计的五大原则之一，它主张高层模块不应该依赖于低层模块，而两者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。简单来说，这一原则鼓励我们在软件设计中使用抽象层，从而减少不同部分之间的依赖性。

在依赖注入的上下文中，这意味着我们应该依赖于抽象（比如接口）而不是具体的实现。这样做的好处是，我们可以在运行时用不同的实现来替换依赖项，而无需更改调用代码，从而提高了代码的灵活性和可扩展性。

#### 2.1.2 控制反转（IoC）概念

控制反转是依赖注入的基石，它是一种设计模式，通过这种模式将对象的创建和依赖关系的维护从代码的主体部分转移到外部容器。通过这种方式，我们不是在对象内部创建依赖，而是由外部容器负责“注入”这些依赖项。

依赖注入是实现控制反转的一种方式。通过依赖注入，我们实现了如下目标：

- 低耦合：依赖关系由外部管理，使得系统中各个模块之间相互独立。
- 可测试性：更容易实现单元测试，因为依赖项可以轻松替换为测试替身（mocks）或存根（stubs）。
- 可配置性：可以在不更改代码的情况下改变程序的行为，通过配置文件或代码中的修改即可实现。

### 2.2 使用.NET Core内置依赖注入容器

.NET Core提供了对依赖注入的内置支持，这是一个功能强大的容器，可用于注册服务、解析依赖关系，并管理服务的生命周期。使用.NET Core内置的依赖注入容器，可以极大地简化服务的管理，并使得整个应用程序的依赖关系更加清晰。

#### 2.2.1 容器的注册与解析

.NET Core的`IServiceCollection`接口提供了注册服务的方法，这些服务将在整个应用程序中可用。`IServiceProvider`用于解析这些服务。注册服务通常在`Startup.cs`文件的`ConfigureServices`方法中完成，而解析服务则在需要的地方通过构造函数注入或属性注入实现。

下面是一个简单的示例，演示了如何在.NET Core项目中注册和解析服务：

public void ConfigureServices(IServiceCollection services)
{
    // 注册服务
    services.AddSingleton<IMessageService, DefaultMessageService>();
}

public class SomeService
{
    private readonly IMessageService _messageService;

    // 构造函数注入
    public SomeService(IMessageService messageService)
    {
        _messageService = messageService ?? throw new ArgumentNullException(nameof(messageService));
    }

    public void DoWork()
    {
        _messageService.ShowMessage("Hello, DI!");
    }
}

#### 2.2.2 作用域和生命周期管理

.NET Core支持三种类型的服务生命周期管理：

- Singleton：单例模式，整个应用程序生命周期中只有一个实例。
- Scoped：作用域内单例，每次请求（HTTP请求或作用域开始时）创建一个实例。
- Transient：瞬时生命周期，每次解析时都会创建一个新实例。

正确地管理服务的生命周期对于资源管理和应用性能至关重要。以下是一个配置服务生命周期的示例：

public void ConfigureServices(IServiceCollection services)
{
    // Singleton生命周期
    services.AddSingleton<IMessageService, DefaultMessageService>();
    // Scoped生命周期
    services.AddScoped<DbContext, MyDbContext>();
    // Transient生命周期
    services.AddTransient<IEmailSender, SmtpEmailSender>();
}

### 2.3 实践技巧：创建自定义服务

在使用.NET Core的依赖注入容器时，我们可能会需要创建一些具有特定生命周期管理或在解析时需要额外初始化的自定义服务。了解如何在这些场景中实现自定义服务对于构建健壮的应用程序至关重要。

#### 2.3.1 实现IDisposable接口

在.NET Core中，当服务实现`IDisposable`接口时，依赖注入容器会负责调用`Dispose`方法来释放资源。这对于那些需要显式清理资源的服务来说非常重要，比如数据库连接、文件句柄等。

以下是如何实现一个需要释放资源的自定义服务的示例：

public class DatabaseService : IDisposable
{
    private bool _disposed = false;
    private SqlConnection _connection;

    public DatabaseService(string connectionString)
    {
        _connection = new SqlConnection(connectionString);
    }

    public void DoWork()
    {
        if (_connection.State != ConnectionState.Open)
            _connection.Open();
        // 执行数据库操作...
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _connection?.Dispose();
            }
            _disposed = true;
        }
    }
}

#### 2.3.2 服务的延时加载

有时候我们希望服务仅在首次使用时才被创建，这称为延时加载（Lazy Loading）。这有助于延迟资源消耗，直到真正需要时。在.NET Core中，可以通过`Lazy<T>`类来实现这一点。

例如，我们有一个数据库上下文类`MyDbContext`，它比较耗费资源。我们可能不希望在应用程序启动时就加载它，而是仅在真正需要时才创建。

public class MyService
{
    private readonly Lazy<MyDbContext> _lazyContext;

    public MyService(Lazy<MyDbContext> lazyContext)
    {
        _lazyContext = lazyContext ?? throw new ArgumentNullException(nameof(lazyContext));
    }

    public void DoWork()
    {
        using (var context = _lazyContext.Value)
        {
            // 执行数据库操作...
        }
    }
}

在`Startup.cs`中，服务可以这样注册：

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<MyDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddTransient<MyService>();
    services.AddSingleton(new Lazy<MyDbContext>(() => new MyDbContext()));
}

在.NET Core的依赖注入容器中，这些基础概念和实践技巧是实现服务的组织、管理和维护的关键。通过这些实践，开发者可以构建出更加可扩展、高效和易于测试的.NET Core应用程序。

# 3. C#依赖注入的高级技巧

## 3.1 面向切面编程（AOP）与依赖注入

面向切面编程（Aspect-Oriented Programming, AOP）是一种编程范式，旨在将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，以提高模块化。AOP在依赖注入的上下文中，可以用来管理非功能性需求，如日志记录、安全性和事务管理。

### 3.1.1 拦截器和通知的概念

拦截器和通知是AOP中的核心概念。拦截器是一种特殊类型的拦截器，它在