ASP.NET Core中的中间件依赖注入是什么？如何实现？

月夜之吻

发布时间：2025-09-11 08:42:01

528人浏览过

来源于php中文网

原创

ASP.NET Core中间件依赖注入通过构造函数注入服务，提升灵活性与可测试性，支持日志、配置、数据库等服务的注入。推荐使用构造函数注入，将服务声明在中间件构造函数中，由DI容器自动解析，如ILogger、IOptions<T>等；避免手动通过context.RequestServices获取服务，以减少冗余代码并便于单元测试。可通过IOptions<T>注入配置类实现外部配置，最佳实践包括保持中间件简洁、避免直接访问数据库、不使用静态变量，并优先使用构造函数注入而非ActivatorUtilities.CreateInstance或工厂模式，以确保代码清晰、可维护。

asp.net core中的中间件依赖注入是什么？如何实现？

ASP.NET Core中的中间件依赖注入，简单来说，就是让你的中间件也能像Controller那样，通过构造函数注入各种服务，从而获得更大的灵活性和可测试性。它允许你将配置、日志、数据库上下文等服务注入到你的中间件中，而不用手动去解析

HttpContext.RequestServices

，让代码更干净、更易于维护。

解决方案：

实现ASP.NET Core中间件的依赖注入，主要有以下几种方式：

构造函数注入 (Constructor Injection): 这是最常见也是推荐的方式。你需要在中间件的构造函数中声明你需要的服务，ASP.NET Core的依赖注入容器会自动解析这些服务并传递给你的中间件。

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

    public MyMiddleware(RequestDelegate next, ILogger<MyMiddleware> logger)
    {
        _next = next ?? throw new ArgumentNullException(nameof(next));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("MyMiddleware executing...");
        await _next(context); // 调用管道中的下一个中间件
    }
}

public static class MyMiddlewareExtensions
{
    public static IApplicationBuilder UseMyMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<MyMiddleware>();
    }
}

在这个例子中，

ILogger<MyMiddleware>

就是通过构造函数注入的。需要注意的是，

RequestDelegate next

必须作为构造函数的第一个参数，这是ASP.NET Core中间件的约定。

使用
```
ActivatorUtilities.CreateInstance
```
手动解析: 虽然不推荐，但在某些特殊情况下，你可能需要手动创建中间件实例。
```
ActivatorUtilities.CreateInstance
```
可以从DI容器中解析依赖并创建对象。
```
app.Use(async (context, next) =>
{
    var logger = context.RequestServices.GetService<ILogger<MyMiddleware>>(); // 不推荐，应该使用构造函数注入
    // ...
    await next();
});
```
这种方式的缺点是，你需要在每个中间件中使用
```
context.RequestServices
```
手动获取服务，代码比较冗余，而且测试起来也比较麻烦。

工厂模式 (Factory Pattern): 对于更复杂的场景，你可以使用工厂模式来创建中间件。这允许你控制中间件的创建过程，并可以根据不同的条件创建不同的中间件实例。

public interface IMyMiddlewareFactory
{
    IMyMiddleware Create(HttpContext context);
}

public interface IMyMiddleware
{
    Task InvokeAsync(HttpContext context);
}

public class MyMiddlewareFactory : IMyMiddlewareFactory
{
    private readonly ILogger<MyMiddleware> _logger;

    public MyMiddlewareFactory(ILogger<MyMiddleware> logger)
    {
        _logger = logger;
    }

    public IMyMiddleware Create(HttpContext context)
    {
        return new MyMiddleware(context, _logger);
    }
}

public class MyMiddleware : IMyMiddleware
{
    private readonly HttpContext _context;
    private readonly ILogger<MyMiddleware> _logger;

    public MyMiddleware(HttpContext context, ILogger<MyMiddleware> logger)
    {
        _context = context;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("MyMiddleware executing...");
        await context.Response.WriteAsync("Hello from MyMiddleware!");
    }
}

// 在 Startup.cs 中注册
services.AddScoped<IMyMiddlewareFactory, MyMiddlewareFactory>();

// 在管道中使用
app.Use(async (context, next) =>
{
    var factory = context.RequestServices.GetRequiredService<IMyMiddlewareFactory>();
    var middleware = factory.Create(context);
    await middleware.InvokeAsync(context);
    await next();
});

这种方式比较复杂，但提供了更大的灵活性。

MusicLM

谷歌平台的AI作曲工具，用文字生成音乐

下载

为什么中间件需要依赖注入？它解决了什么问题？

依赖注入使得中间件的配置更加灵活，并简化了单元测试。想象一下，如果你的中间件需要访问数据库，但你没有使用依赖注入，你可能需要在中间件内部硬编码数据库连接字符串，这使得代码难以维护和测试。使用依赖注入，你可以将数据库上下文注入到中间件中，并在单元测试中使用Mock对象来模拟数据库访问。

如何处理中间件中的配置信息？

通常，中间件的配置信息可以通过

IOptions<T>

接口注入。首先，你需要创建一个配置类，然后将配置类注册到DI容器中，最后，在中间件的构造函数中注入

IOptions<T>

。

// 配置类
public class MyMiddlewareOptions
{
    public string Message { get; set; } = "Hello from MyMiddleware!";
}

// 在 Startup.cs 中注册
services.Configure<MyMiddlewareOptions>(Configuration.GetSection("MyMiddleware"));

// 在中间件中使用
public class MyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IOptions<MyMiddlewareOptions> _options;

    public MyMiddleware(RequestDelegate next, IOptions<MyMiddlewareOptions> options)
    {
        _next = next ?? throw new ArgumentNullException(nameof(next));
        _options = options ?? throw new ArgumentNullException(nameof(options));
    }

    public async Task InvokeAsync(HttpContext context)
    {
        await context.Response.WriteAsync(_options.Value.Message);
        await _next(context);
    }
}

这样，你就可以通过