ASP.NET Core中的中间件工厂是什么？如何使用？-C#.Net教程-PHP中文网

中间件工厂通过实现IMiddlewareFactory接口，允许自定义中间件创建逻辑，解决传统UseMiddleware无法处理非DI参数、复杂依赖解析和生命周期控制的问题。

asp.net core中的中间件工厂是什么？如何使用？

在ASP.NET Core中，中间件工厂（Middleware Factory）本质上是一个负责创建和管理中间件实例的机制。它允许你对中间件的实例化过程拥有更精细的控制，尤其是在常规的

app.UseMiddleware<T>

登录后复制

方法无法满足复杂依赖注入需求，或者你需要向中间件的构造函数传递一些非DI容器直接提供的参数时，中间件工厂就显得尤为重要。简单来说，它提供了一个钩子，让你能在中间件被添加到请求管道之前，自定义它的创建逻辑。

解决方案

当我们谈论ASP.NET Core的中间件时，最常见的做法莫过于直接调用

app.UseMiddleware<MyMiddleware>()

登录后复制

。这种方式非常便捷，框架会自动尝试通过依赖注入（DI）容器来解析

MyMiddleware

登录后复制

的构造函数参数。这在大多数情况下都工作得很好，尤其是当你的中间件只依赖于其他已注册的服务（比如

ILogger

登录后复制

、

DbContext

登录后复制

等）时。

然而，这种“约定大于配置”的便利性在某些特定场景下会遇到瓶颈。比如，你的中间件构造函数需要一个

string

登录后复制

类型的参数，而这个

string

登录后复制

又不是从DI容器中解析出来的，而是需要在运行时动态提供，或者依赖于其他复杂的逻辑。又或者，你希望中间件的生命周期管理更加灵活，不只是简单的单例或作用域。这时，

IMiddlewareFactory

登录后复制

就登场了。

IMiddlewareFactory

登录后复制

是一个接口，它定义了两个方法：

Create(Type middlewareType)

登录后复制

和

Release(IMiddleware middleware)

登录后复制

。当你注册并使用自定义的

IMiddlewareFactory

登录后复制

时，框架在需要创建某个中间件实例时，会调用你的

Create

登录后复制

方法。这意味着，你可以在这个方法中完全控制中间件的实例化过程，包括：

手动解析依赖： 你可以从
```
IServiceProvider
```
登录后复制
中手动获取需要的服务。
传递自定义参数： 你可以向中间件的构造函数传递任何你想要的自定义值。
自定义生命周期： 虽然
```
IMiddlewareFactory
```
登录后复制
本身是单例的，但你可以在
```
Create
```
登录后复制
和
```
Release
```
登录后复制
方法中实现更复杂的中间件实例生命周期管理（尽管通常不推荐过度复杂化）。

通过这种方式，

IMiddlewareFactory

登录后复制

提供了一个强大的扩展点，让你能够打破

UseMiddleware<T>

登录后复制

的默认限制，以更灵活的方式构建和集成中间件。

为什么我需要中间件工厂？它解决了哪些常见痛点？

说实话，我第一次接触到中间件工厂这个概念时，觉得它有点“高级”，因为大部分时候

UseMiddleware<T>

登录后复制

已经够用了。但当你真的遇到那些“棘手”的依赖问题，比如你的中间件需要一个每次请求都不同的服务实例，或者构造函数参数并非都是DI容器能直接提供的，那它简直就是救星。

它主要解决了以下几个痛点：

慧中标AI标书

慧中标AI标书是一款AI智能辅助写标书工具。

120

查看详情

非DI可解析的构造函数参数： 想象一下，你的中间件需要一个配置字符串，这个字符串不是通过
```
IOptions<T>
```
登录后复制
获取的，而是直接从某个动态源或硬编码提供。
```
UseMiddleware<T>
```
登录后复制
无法直接处理这种场景，因为它期望所有构造函数参数都能从DI容器中找到。中间件工厂允许你在
```
Create
```
登录后复制
方法中手动构造中间件实例，并传入这些自定义参数。
复杂的依赖解析逻辑： 有时候，一个服务可能需要根据请求上下文或某些条件来动态选择实现。在中间件工厂中，你可以在
```
Create
```
登录后复制
方法内部编写更复杂的逻辑，根据运行时情况从
```
IServiceProvider
```
登录后复制
中获取不同的服务实例，或者甚至手动创建并注入这些依赖。
中间件的“瞬时”或自定义生命周期： 默认情况下，ASP.NET Core中间件实例的生命周期通常是单例的（如果构造函数没有
```
RequestDelegate next
```
登录后复制
参数），或者在管道中被创建一次并重用。如果你需要每个请求都创建一个全新的中间件实例，并且这个实例有复杂的构造逻辑，中间件工厂可以让你在
```
Create
```
登录后复制
方法中每次都返回一个新实例，并在
```
Release
```
登录后复制
方法中处理其清理。
避免在
InvokeAsync
登录后复制
中过多地使用
context.RequestServices
登录后复制
：虽然你可以在
```
InvokeAsync
```
登录后复制
方法中通过
```
context.RequestServices.GetService<T>()
```
登录后复制
来获取服务，但这有时会让代码显得不够清晰，且可能隐藏了中间件的实际依赖。通过中间件工厂，你可以在构造时就注入所有必要的依赖，保持
```
InvokeAsync
```
登录后复制
的简洁和专注于业务逻辑。

在我看来，它更像是一种“逃生舱”，当常规的DI机制无法满足你的特殊中间件需求时，它提供了一个强大且灵活的备用方案。

如何自定义实现和注册一个中间件工厂？

实现和注册一个自定义的中间件工厂需要几个步骤。我们将通过一个具体的例子来展示，假设我们有一个中间件

MyCustomMiddleware

登录后复制

，它需要一个自定义的字符串消息和一个从DI容器中解析的服务

IMyService

登录后复制

。

1. 定义服务接口和实现： 首先，我们定义一个简单的服务，用于演示DI。

public interface IMyService
{
    string GetData();
}

public class MyService : IMyService
{
    private readonly Guid _instanceId = Guid.NewGuid(); // 用于观察实例生命周期
    public string GetData() => $"Data from MyService (Instance: {_instanceId})";
}

登录后复制

2. 定义自定义中间件： 这个中间件会接收

IMyService

登录后复制

和一个自定义

string

登录后复制

消息。注意，它的构造函数不包含

RequestDelegate next

登录后复制

，因为

next

登录后复制

会作为参数传递给

InvokeAsync

登录后复制

方法。

using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

public class MyCustomMiddleware : IMiddleware
{
    private readonly IMyService _myService;
    private readonly string _message;

    // 构造函数只接受需要注入的服务，以及工厂提供的自定义参数
    public MyCustomMiddleware(IMyService myService, string message)
    {
        _myService = myService;
        _message = message;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        await context.Response.WriteAsync($"Middleware Message: {_message}\n");
        await context.Response.WriteAsync($"Service Data: {_myService.GetData()}\n");
        await next(context); // 调用管道中的下一个中间件
    }
}

登录后复制

3. 实现

IMiddlewareFactory

登录后复制

接口： 这是核心部分。我们将在这里定义如何创建

MyCustomMiddleware

登录后复制

的实例。

using Microsoft.AspNetCore.Http;
using System;
using Microsoft.Extensions.DependencyInjection; // 用于 GetRequiredService

public class MyCustomMiddlewareFactory : IMiddlewareFactory
{
    private readonly IServiceProvider _serviceProvider;

    public MyCustomMiddlewareFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IMiddleware Create(Type middlewareType)
    {
        if (middlewareType == typeof(MyCustomMiddleware))
        {
            // 从DI容器中解析 IMyService
            var myService = _serviceProvider.GetRequiredService<IMyService>();
            // 创建 MyCustomMiddleware 实例，并传入自定义的字符串参数
            return new MyCustomMiddleware(myService, "Hello from custom factory!");
        }
        // 对于其他中间件类型，如果这个工厂不负责创建，可以返回 null
        // 这样框架会尝试使用其他已注册的工厂或默认机制来创建。
        return null;
    }

    public void Release(IMiddleware middleware)
    {
        // 如果中间件实现了 IDisposable 接口，可以在这里进行资源释放
        (middleware as IDisposable)?.Dispose();
    }
}

登录后复制

4. 在

Startup.cs

登录后复制

中注册和使用： 最后一步是将我们的服务和自定义中间件工厂注册到DI容器中，并在请求管道中使用中间件。

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 注册我们的服务
        services.AddTransient<IMyService, MyService>();

        // 注册自定义的中间件工厂
        // 注意：IMiddlewareFactory 通常注册为单例。
        // 如果你注册了自定义的 IMiddlewareFactory，它会优先于框架默认的工厂。
        // 你的工厂需要能处理你希望它处理的中间件类型，或者返回 null 让框架回退到默认行为。
        services.AddSingleton<IMiddlewareFactory, MyCustomMiddlewareFactory>();

        // 这里不需要注册 MyCustomMiddleware 本身，因为它是由工厂创建的。
        // 如果 MyCustomMiddleware 有其他构造函数，并且你想让 DI 容器处理，那才需要注册。
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        // ... 其他中间件 ...

        // 使用 UseMiddleware<T> 来引用我们的中间件。
        // 框架会发现我们注册了 MyCustomMiddlewareFactory，
        // 进而调用它的 Create 方法来创建 MyCustomMiddleware 实例。
        app.UseMiddleware<MyCustomMiddleware>();

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Hello from endpoint!\n");
            });
        });
    }
}

登录后复制

运行这个应用，当你访问根路径时，你会看到

MyCustomMiddleware

登录后复制

打印出的消息和

IMyService

登录后复制

的数据，证明我们的自定义工厂成功地创建了中间件并注入了所需的依赖和自定义参数。

中间件工厂与传统中间件注入方式有何不同？何时选择哪种方式？

中间件工厂和传统的

app.UseMiddleware<T>()

登录后复制

方式在表面上看起来都是将中间件加入管道，但它们在幕后的工作机制以及适用场景上有着显著的区别。

传统

app.UseMiddleware<T>()

登录后复制

方式：

工作机制： 当你调用
```
app.UseMiddleware<T>()
```
登录后复制
时，ASP.NET Core会尝试通过其内置的DI容器来解析
```
T
```
登录后复制
的构造函数。如果
```
T
```
登录后复制
的构造函数包含
```
RequestDelegate next
```
登录后复制
参数，它通常会被视为一个“管道中间件”，框架会在管道初始化时创建它的一个实例（或重用现有实例），并将管道中的下一个
```
RequestDelegate
```
登录后复制
传递给它。如果
```
T
```
登录后复制
的构造函数不包含
```
RequestDelegate next
```
登录后复制
，它会被视为一个“服务中间件”，框架会尝试从DI容器中解析它的所有依赖。
优点： 简洁、方便、易于理解和使用。对于大多数只依赖于DI容器中已注册服务的中间件来说，这是首选方式。
缺点： 灵活性有限。无法直接向中间件构造函数传递非DI可