.NET Core 注入依赖

.NET Core 是一个现代化的、跨平台的框架，提供了构建高性能和可扩展应用程序的工具。依赖注入（Dependency Injection，DI）和中间件（Middleware）是 .NET Core 框架中两个核心的概念，它们在应用程序的架构中扮演着关键的角色。本文将详细探讨这两个概念，并展示如何在 .NET Core 应用程序中有效使用它们。

1. 依赖注入（Dependency Injection）
依赖注入是一种设计模式，用于将对象的依赖关系从外部传递给它，而不是在内部创建这些依赖。这种模式提高了代码的可测试性和可维护性。在 .NET Core 中，依赖注入是框架的内置功能，几乎所有的 .NET Core 应用程序都会用到它。

1.1 依赖注入的类型
在 .NET Core 中，有三种主要的依赖注入生命周期：

瞬态（Transient）：每次请求都会创建一个新的实例。适用于轻量级、无状态的服务。
作用域（Scoped）：在每个请求范围内创建一次实例。适用于需要在单个请求中共享数据的服务。
单例（Singleton）：在应用程序生命周期内只创建一次实例。适用于全局共享的服务，如缓存管理。
1.2 如何配置依赖注入
在 .NET Core 中，通过 Startup 类中的 ConfigureServices 方法来注册依赖关系。例如：

public void ConfigureServices(IServiceCollection services)
{
    // 注册一个瞬态服务，每次请求都会创建一个新的实例
    services.AddTransient<IMyTransientService, MyTransientService>();
    
    // 注册一个作用域服务，在每个请求范围内创建一次实例
    services.AddScoped<IMyScopedService, MyScopedService>();
    
    // 注册一个单例服务，在整个应用程序生命周期内只创建一次实例
    services.AddSingleton<IMySingletonService, MySingletonService>();
}

上面的代码展示了如何注册不同生命周期的服务。

1.3 使用依赖注入

一旦服务被注册，它们就可以通过构造函数注入到控制器或其他服务中：

public class MyController : ControllerBase
{
    private readonly IMyTransientService _transientService;
    private readonly IMyScopedService _scopedService;
    private readonly IMySingletonService _singletonService;

    // 通过构造函数注入服务依赖项
    public MyController(IMyTransientService transientService,
                        IMyScopedService scopedService,
                        IMySingletonService singletonService)
    {
        _transientService = transientService;
        _scopedService = scopedService;
        _singletonService = singletonService;
    }

    // 你可以在控制器的方法中使用注入的服务
    public IActionResult MyAction()
    {
        _transientService.DoWork();
        _scopedService.DoWork();
        _singletonService.DoWork();

        return Ok();
    }
}

2. 中间件（Middleware）
中间件是处理 HTTP 请求和响应的组件链。在 .NET Core 中，每个请求都会通过一系列的中间件，最终返回响应。中间件的顺序非常重要，因为它决定了请求如何被处理。

2.1 中间件的类型
常见的中间件类型包括：

日志记录中间件：记录请求和响应的数据。
身份验证中间件：验证用户身份。
路由中间件：将请求路由到相应的控制器。
2.2 配置中间件
在 Startup 类的 Configure 方法中配置中间件。例如：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // 在开发环境中使用开发者异常页面中间件，以便调试错误
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    // 添加路由中间件，开始处理路由
    app.UseRouting();

    // 添加身份验证中间件，用于处理用户身份验证
    app.UseAuthentication();
    
    // 添加授权中间件，用于处理用户权限验证
    app.UseAuthorization();

    // 配置终结点路由，映射控制器路由
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

上面的代码展示了一个典型的中间件配置，其中包括异常处理、路由、身份验证和授权等中间件。

2.3 自定义中间件

除了使用内置中间件，.NET Core 还允许开发者创建自定义中间件。例如：

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    // 构造函数中注入 RequestDelegate，用于调用下一个中间件
    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    // 中间件的核心方法，处理传入的 HTTP 请求
    public async Task InvokeAsync(HttpContext context)
    {
        // 在请求进入下一个中间件之前的处理逻辑
        // 例如：日志记录、请求修改等
        
        await _next(context); // 调用下一个中间件

        // 在请求返回之前的处理逻辑
        // 例如：修改响应、记录响应等
    }
}

public void Configure(IApplicationBuilder app)
{
    // 在请求处理中添加自定义中间件
    app.UseMiddleware<CustomMiddleware>();
}

这个自定义中间件会在请求进入下一个中间件之前和响应返回之前进行处理。

3. 依赖注入与中间件的结合

在实际开发中，依赖注入和中间件通常会结合使用。中间件可以通过构造函数注入服务，以便在处理请求和响应时使用。例如：

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LoggingMiddleware> _logger;

    // 通过构造函数注入日志服务和下一个中间件委托
    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    // 中间件的核心方法
    public async Task InvokeAsync(HttpContext context)
    {
        // 使用注入的日志服务记录请求信息
        _logger.LogInformation("Processing request: " + context.Request.Path);
        
        await _next(context); // 调用下一个中间件
    }
}