Blazor Server控制器：如何将POST体JSON解析为方法参数？

你想要的效果完全可以实现，不用为每个方法单独创建模型，下面提供两种实用方案：

方案一：自定义模型绑定器（推荐） #

ASP.NET Core支持自定义模型绑定逻辑，我们可以编写一个绑定器，自动把POST的JSON体解析后映射到方法的单个参数上，和GET请求的参数使用方式一致。

1. 编写自定义模型绑定器 #

public class JsonBodyToParamsBinder : IModelBinder
{
    private readonly IJsonOptions _jsonOptions;

    public JsonBodyToParamsBinder(IJsonOptions jsonOptions)
    {
        _jsonOptions = jsonOptions;
    }

    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        // 读取请求体内容
        var request = bindingContext.HttpContext.Request;
        request.EnableBuffering();
        using var reader = new StreamReader(request.Body, leaveOpen: true);
        var jsonBody = await reader.ReadToEndAsync();
        request.Body.Position = 0; // 重置流位置，避免后续逻辑读不到内容

        if (string.IsNullOrEmpty(jsonBody))
        {
            bindingContext.Result = ModelBindingResult.Failed();
            return;
        }

        // 把JSON转成键值对字典
        var jsonDict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
            jsonBody,
            _jsonOptions.JsonSerializerOptions);

        if (jsonDict == null)
        {
            bindingContext.Result = ModelBindingResult.Failed();
            return;
        }

        // 匹配当前参数，从字典取值并转换类型
        var parameter = bindingContext.ParameterInfo;
        if (jsonDict.TryGetValue(parameter.Name, out var value))
        {
            try
            {
                var convertedValue = value.Deserialize(parameter.ParameterType, _jsonOptions.JsonSerializerOptions);
                bindingContext.Result = ModelBindingResult.Success(convertedValue);
            }
            catch
            {
                bindingContext.ModelState.TryAddModelError(parameter.Name, $"无法将值 {value} 转换为 {parameter.ParameterType.Name} 类型");
                bindingContext.Result = ModelBindingResult.Failed();
            }
        }
        else
        {
            // 参数不存在时，判断是否为可选参数
            if (parameter.IsOptional || parameter.HasDefaultValue)
            {
                bindingContext.Result = ModelBindingResult.Success(parameter.DefaultValue);
            }
            else
            {
                bindingContext.ModelState.TryAddModelError(parameter.Name, $"请求体中缺少参数 {parameter.Name}");
                bindingContext.Result = ModelBindingResult.Failed();
            }
        }
    }
}

2. 编写绑定器提供器 #

这个类用来告诉ASP.NET Core什么时候使用我们的自定义绑定器：

public class JsonBodyToParamsBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        // 只给简单类型（非复杂对象）的[FromBody]参数用这个绑定器
        if (!context.Metadata.IsComplexType && context.BindingInfo.BindingSource == BindingSource.Body)
        {
            var jsonOptions = context.Services.GetRequiredService<IJsonOptions>();
            return new JsonBodyToParamsBinder(jsonOptions);
        }

        return null;
    }
}

3. 在项目中注册绑定器 #

在Program.cs（ASP.NET Core 6+）里添加注册逻辑：

builder.Services.AddControllers(options =>
{
    // 把自定义绑定器放在最前面，优先使用
    options.ModelBinderProviders.Insert(0, new JsonBodyToParamsBinderProvider());
});

4. 控制器方法中使用 #

给每个参数加上[FromBody]特性即可，直接使用参数：

public class AppServiceController : Controller
{
    [HttpPost]
    public ApiMethodResponse TestPost([FromBody] string p1, [FromBody] int p2, [FromBody] double p3)
    {
        // 直接用p1、p2、p3，已经自动从JSON体映射好了
        return new ApiMethodResponse();
    }
}

方案二：全局ActionFilter解析 #

如果不想给每个参数加特性，可以用ActionFilter全局处理，提前解析JSON体并给参数赋值。

1. 编写自定义ActionFilter #

public class BindJsonBodyToParamsFilter : IActionFilter
{
    private readonly IJsonOptions _jsonOptions;

    public BindJsonBodyToParamsFilter(IJsonOptions jsonOptions)
    {
        _jsonOptions = jsonOptions;
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        var request = context.HttpContext.Request;
        // 判断是JSON类型的POST请求，且当前没有已绑定的参数
        if (request.ContentType != null && request.ContentType.Contains("application/json") && context.ActionArguments.Count == 0)
        {
            request.EnableBuffering();
            using var reader = new StreamReader(request.Body, leaveOpen: true);
            var jsonBody = reader.ReadToEnd();
            request.Body.Position = 0;

            if (!string.IsNullOrEmpty(jsonBody))
            {
                var jsonDict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                    jsonBody,
                    _jsonOptions.JsonSerializerOptions);

                if (jsonDict != null)
                {
                    // 遍历方法参数，从字典取值并转换类型
                    foreach (var parameter in context.ActionDescriptor.Parameters)
                    {
                        if (jsonDict.TryGetValue(parameter.Name, out var value))
                        {
                            try
                            {
                                var convertedValue = value.Deserialize(parameter.ParameterType, _jsonOptions.JsonSerializerOptions);
                                context.ActionArguments[parameter.Name] = convertedValue;
                            }
                            catch
                            {
                                context.ModelState.AddModelError(parameter.Name, $"参数 {parameter.Name} 类型转换失败");
                            }
                        }
                        else if (!parameter.IsOptional && !parameter.HasDefaultValue)
                        {
                            context.ModelState.AddModelError(parameter.Name, $"缺少必填参数 {parameter.Name}");
                        }
                    }
                }
            }
        }
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        // 无需处理后续逻辑
    }
}

2. 注册过滤器 #

同样在Program.cs里注册：

builder.Services.AddControllers(options =>
{
    options.Filters.Add<BindJsonBodyToParamsFilter>();
});

3. 控制器方法直接用参数 #

不需要加任何特性，直接定义参数即可：

public class AppServiceController : Controller
{
    [HttpPost]
    public ApiMethodResponse TestPost(string p1, int p2, double p3)
    {
        // 直接使用参数，过滤器已经帮你完成了JSON到参数的映射
        return new ApiMethodResponse();
    }
}

注意事项 #

• 两种方案都支持自动类型转换，比如JSON里的字符串"2"可以转成int类型的2；如果需要忽略大小写匹配参数名，可以修改JsonSerializerOptions的PropertyNameCaseInsensitive为true
• 可选参数即使JSON里没有对应字段，也会使用参数的默认值
• 方案一更贴合ASP.NET Core的原生绑定逻辑，推荐使用；方案二适合全局统一处理所有POST方法的参数映射

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