如何阻止ASP.NET Web API模型绑定中整数赋值给布尔参数？

这个问题我之前处理过——ASP.NET Web API默认的bool?模型绑定逻辑确实会把0解析为false，任何非0整数（不管是1、2还是-1）都解析为true，这是框架内置的转换规则，但显然不符合严格校验的需求。下面给你几个实用的解决办法，按需选择：

1. 自定义模型绑定器（推荐，直接拦截绑定过程） #

这种方式可以直接控制IsTrue字段的绑定逻辑，只有合法的输入才会被解析，非法输入会直接加入ModelState错误，ApiController会自动返回400 Bad Request并带上错误信息。

首先实现自定义模型绑定器：

public class StrictBooleanModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueProviderResult == ValueProviderResult.None)
            return Task.CompletedTask;

        bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);

        var inputValue = valueProviderResult.FirstValue;
        if (string.IsNullOrWhiteSpace(inputValue))
        {
            // 空值绑定为null（符合可空布尔的预期）
            bindingContext.Result = ModelBindingResult.Success(null);
            return Task.CompletedTask;
        }

        // 优先尝试解析布尔字符串
        if (bool.TryParse(inputValue, out bool parsedBool))
        {
            bindingContext.Result = ModelBindingResult.Success(parsedBool);
        }
        // 再尝试解析整数，只接受0或1
        else if (int.TryParse(inputValue, out int parsedInt))
        {
            if (parsedInt == 0)
                bindingContext.Result = ModelBindingResult.Success(false);
            else if (parsedInt == 1)
                bindingContext.Result = ModelBindingResult.Success(true);
            else
                bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, "IsTrue必须是有效的布尔值（true/false）或0/1");
        }
        // 其他所有输入都视为非法
        else
        {
            bindingContext.ModelState.TryAddModelError(bindingContext.ModelName, "IsTrue必须是有效的布尔值（true/false）或0/1");
        }

        return Task.CompletedTask;
    }
}

然后在你的输入模型上给IsTrue属性绑定这个自定义绑定器：

public class InputModel 
{
    public int Id { get; set; }

    [ModelBinder(BinderType = typeof(StrictBooleanModelBinder))]
    public bool? IsTrue { get; set; }
}

2. 自定义类型转换器（全局/局部生效） #

如果希望这个严格的转换逻辑不仅在模型绑定中生效，其他使用TypeConverter的场景也能生效，可以自定义类型转换器：

public class StrictNullableBooleanConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        // 支持从string和int类型转换
        return sourceType == typeof(string) || sourceType == typeof(int) || base.CanConvertFrom(context, sourceType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        if (value is string strValue)
        {
            if (string.IsNullOrWhiteSpace(strValue))
                return null;
            if (bool.TryParse(strValue, out bool boolResult))
                return boolResult;
            throw new FormatException("IsTrue必须是有效的布尔值（true/false）");
        }
        else if (value is int intValue)
        {
            if (intValue == 0)
                return false;
            else if (intValue == 1)
                return true;
            throw new FormatException("IsTrue必须是0或1");
        }
        return base.ConvertFrom(context, culture, value);
    }
}

然后给IsTrue属性添加TypeConverter特性：

public class InputModel 
{
    public int Id { get; set; }

    [TypeConverter(typeof(StrictNullableBooleanConverter))]
    public bool? IsTrue { get; set; }
}

注意：这种方式如果转换失败会抛出异常，需要在绑定过程中捕获并处理，或者结合ModelState验证。

3. DTO+数据验证（灵活控制验证逻辑） #

如果不想修改框架的绑定逻辑，可以先将IsTrue定义为字符串类型，然后通过数据验证规则限制输入，最后在业务逻辑中转换为bool?：

public class InputModel 
{
    public int Id { get; set; }

    [RegularExpression(@"^(true|false|0|1)$", ErrorMessage = "IsTrue必须是有效的布尔值（true/false）或0/1")]
    public string IsTrue { get; set; }

    // 提供转换方法，在业务逻辑中调用
    public bool? GetParsedIsTrue()
    {
        if (string.IsNullOrWhiteSpace(IsTrue))
            return null;
        
        return IsTrue switch
        {
            "0" or "false" or "False" => false,
            "1" or "true" or "True" => true,
            _ => null // 这里其实不会走到，因为有正则验证
        };
    }
}

如果使用FluentValidation这类第三方验证库，还可以写出更灵活的验证规则，这里就不展开了。

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