.NET 6自定义模型绑定如何让非Ids属性回退到默认绑定逻辑

解决方案 #

优先推荐单属性绑定方案，侵入性最低，无需修改全局绑定配置，也不用处理其他属性的绑定逻辑。

方案1：仅为Ids属性配置专属自定义绑定器 #

无需为整个Specification类编写绑定器，只需要针对Ids属性单独绑定即可，其他属性完全走默认绑定逻辑，复杂类型、嵌套类型、数据验证都不会受影响。

1. 编写CSV转int数组的专属绑定器

public class CsvIntArrayBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        ArgumentNullException.ThrowIfNull(bindingContext);
        
        // 仅处理int[]类型
        if (bindingContext.ModelType != typeof(int[]))
            return Task.CompletedTask;

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

        int[]? ids = null;
        // 同时兼容两种传参形式：?Ids=1,2,3 和 ?Ids=1&Ids=2&Ids=3
        if (valueResult.Values.Count > 1)
        {
            // 多值传参直接转换
            ids = valueResult.Values
                .Where(x => int.TryParse(x, out _))
                .Select(int.Parse)
                .ToArray();
        }
        else
        {
            var idsString = valueResult.FirstValue;
            if (!string.IsNullOrWhiteSpace(idsString))
            {
                // 单值CSV分割转换
                ids = idsString.Split(',', StringSplitOptions.RemoveEmptyEntries)
                    .Where(x => int.TryParse(x, out _))
                    .Select(int.Parse)
                    .ToArray();
            }
        }

        bindingContext.Result = ModelBindingResult.Success(ids);
        return Task.CompletedTask;
    }
}

2. 在基类的Ids属性上标记绑定器

public abstract class SpecificationBase<T>
{
    [ModelBinder(BinderType = typeof(CsvIntArrayBinder))]
    public int[]? Ids { get; set; }
    // 其他属性保持原有定义即可
}

方案2：自定义类绑定器中调用默认绑定逻辑 #

如果确实需要为整个Specification类做统一绑定处理，可以通过IModelBinderFactory获取默认的复杂类型绑定器，先完成所有通用属性的绑定，再重写Ids属性的逻辑：

1. 编写类绑定器

public class SpecificationModelBinder : IModelBinder
{
    private readonly IModelBinderFactory _binderFactory;
    private readonly IModelMetadataProvider _metadataProvider;

    public SpecificationModelBinder(IModelBinderFactory binderFactory, IModelMetadataProvider metadataProvider)
    {
        _binderFactory = binderFactory;
        _metadataProvider = metadataProvider;
    }

    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        ArgumentNullException.ThrowIfNull(bindingContext);

        // 非Specification类型跳过
        if (bindingContext.ModelType.BaseType?.GetGenericTypeDefinition() != typeof(SpecificationBase<>))
            return;

        // 1. 获取当前类型的默认复杂对象绑定器，先执行默认绑定逻辑
        var defaultBinder = _binderFactory.CreateBinder(new BinderFactoryContext
        {
            Metadata = _metadataProvider.GetMetadataForType(bindingContext.ModelType),
            BindingInfo = new BindingInfo()
        });
        await defaultBinder.BindModelAsync(bindingContext);

        // 默认绑定失败直接返回
        if (!bindingContext.Result.IsModelSet)
            return;

        var model = bindingContext.Result.Model;
        var idsProperty = bindingContext.ModelType.GetProperty("Ids");
        if (idsProperty == null)
            return;

        // 2. 仅重写Ids属性的绑定逻辑
        var valueResult = bindingContext.ValueProvider.GetValue("Ids");
        if (valueResult != ValueProviderResult.None)
        {
            int[]? ids = null;
            if (valueResult.Values.Count > 1)
            {
                ids = valueResult.Values.Where(x => int.TryParse(x, out _)).Select(int.Parse).ToArray();
            }
            else
            {
                var idsString = valueResult.FirstValue;
                if (!string.IsNullOrWhiteSpace(idsString))
                {
                    ids = idsString.Split(',', StringSplitOptions.RemoveEmptyEntries)
                        .Where(x => int.TryParse(x, out _))
                        .Select(int.Parse)
                        .ToArray();
                }
            }
            idsProperty.SetValue(model, ids);
        }

        // 重新设置绑定结果
        bindingContext.Result = ModelBindingResult.Success(model);
    }
}

2. 编写绑定器提供程序，为所有Specification子类动态生成绑定器

public class SpecificationModelBinderProvider : IModelBinderProvider
{
    public IModelBinder? GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType.BaseType is { IsGenericType: true } baseType 
            && baseType.GetGenericTypeDefinition() == typeof(SpecificationBase<>))
        {
            var binderFactory = context.Services.GetRequiredService<IModelBinderFactory>();
            var metadataProvider = context.Services.GetRequiredService<IModelMetadataProvider>();
            return new SpecificationModelBinder(binderFactory, metadataProvider);
        }
        return null;
    }
}

3. 在Program.cs中注册绑定器提供程序

builder.Services.AddControllers(options =>
{
    // 插入到绑定器列表首位，优先匹配Specification类型
    options.ModelBinderProviders.Insert(0, new SpecificationModelBinderProvider());
});

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