如何在ASP.NET Core WebAPI中实现动态模型绑定？

这个需求完全可行，下面提供两种贴合ASP.NET设计理念的实现方案，无需手动处理原始JSON：

方案一：自定义模型绑定器（适配现有控制器结构） #

你之前对IModelBinder的理解有偏差，它完全可以结合运行时参数（比如processorId）动态确定模型类型并完成绑定与验证。

1. 实现自定义ModelBinderProvider #

这个Provider负责根据上下文判断是否使用我们的动态绑定器：

public class DynamicModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        // 仅对controller中声明为object的参数生效，也可自定义标记属性来筛选
        if (context.Metadata.ModelType == typeof(object) && 
            context.ActionContext.RouteData.Values.ContainsKey("processorId"))
        {
            return new BinderTypeModelBinder(typeof(DynamicModelBinder));
        }
        return null;
    }
}

2. 实现动态ModelBinder #

在绑定器中根据processorId获取目标类型，复用ASP.NET内置的绑定逻辑完成反序列化与验证：

public class DynamicModelBinder : IModelBinder
{
    private readonly IServiceProvider _serviceProvider;
    private readonly IProcessorProvider _processorProvider;

    public DynamicModelBinder(IServiceProvider serviceProvider, IProcessorProvider processorProvider)
    {
        _serviceProvider = serviceProvider;
        _processorProvider = processorProvider;
    }

    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (!bindingContext.ActionContext.RouteData.Values.TryGetValue("processorId", out var processorIdObj) ||
            processorIdObj is not string processorId)
        {
            bindingContext.ModelState.AddModelError("", "processorId is required");
            return;
        }

        var processor = _processorProvider.GetProcessor(processorId);
        var targetType = processor.GetModelType();

        // 复用ASP.NET内置的BodyModelBinder处理反序列化和验证
        var bodyBinder = _serviceProvider.GetRequiredService<BodyModelBinder>();
        var newBindingContext = DefaultModelBindingContext.CreateBindingContext(
            bindingContext.ActionContext,
            bindingContext.ValueProvider,
            new EmptyModelMetadataProvider().GetMetadataForType(targetType),
            null,
            bindingContext.FieldName
        );

        await bodyBinder.BindModelAsync(newBindingContext);

        if (newBindingContext.Result.IsModelSet)
        {
            bindingContext.Result = newBindingContext.Result;
        }
        else
        {
            bindingContext.ModelState.AddModelError("", $"Failed to bind model for processor {processorId}");
        }
    }
}

3. 注册绑定器 #

在Program.cs中注册自定义Provider：

builder.Services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new DynamicModelBinderProvider());
});

4. 修改控制器代码 #

现在控制器可以正常接收动态绑定的模型：

[HttpPost("process/{processorId}")]
public IActionResult Process([FromBody] object data, string processorId) 
{
    var processor = _processorProvider.GetProcessor(processorId);
    // data已经是正确类型的实例，且经过ASP.NET内置验证
    var result = processor.Process(data);
    return Ok(result);
}

方案二：动态注册端点（绕过控制器，更底层但仍复用框架能力） #

如果不想用控制器，可以直接在启动时注册动态端点，每个处理器对应一个端点，自动复用框架的模型绑定：

var app = builder.Build();
var processorProvider = app.Services.GetRequiredService<IProcessorProvider>();

// 遍历所有处理器，注册对应端点
foreach (var processor in processorProvider.GetAllProcessors())
{
    var modelType = processor.GetModelType();
    // 用反射创建端点处理委托
    var handler = typeof(ProcessorEndpointHandler)
        .GetMethod(nameof(ProcessorEndpointHandler.Handle))
        .MakeGenericMethod(modelType)
        .CreateDelegate(typeof(Func<HttpContext, Task>), processor);

    app.MapPost($"/process/{processor.Id}", handler);
}

// 通用处理类
public static class ProcessorEndpointHandler
{
    public static async Task Handle<T>(HttpContext context, IProcessor<T> processor)
    {
        var model = await context.Request.ReadFromJsonAsync<T>();
        // 手动触发模型验证（也可注入ModelStateValidator服务实现更贴合框架的验证逻辑）
        var validator = context.RequestServices.GetRequiredService<IValidator<T>>();
        var validationResult = await validator.ValidateAsync(model);
        if (!validationResult.IsValid)
        {
            foreach (var error in validationResult.Errors)
            {
                context.ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
            }
            await context.Response.WriteAsJsonAsync(new ValidationProblemDetails(context.ModelState));
            context.Response.StatusCode = StatusCodes.Status400BadRequest;
            return;
        }

        var result = processor.Process(model);
        await context.Response.WriteAsJsonAsync(result);
    }
}

这种方式完全利用ASP.NET的内置序列化和验证能力，同时实现了动态类型的处理。

内容的提问来源于stack exchange，提问作者superjugy