ASP.NET Core WebAPI单端点接收多派生类型实现方案问询

嘿，这个需求我太熟了——在ASP.NET Core WebAPI里处理多态模型，不用给每个派生类单独写端点，完全可以按你说的，控制器先反序列化为基类，再丢给服务层做类型分支处理。下面给你一步步拆解具体怎么做：

1. 定义多态模型 #

首先先把基类和派生类的结构搭好，建议加一个类型标识字段（或者直接用系统的多态特性），方便后续识别具体类型：

public class ModelA
{
    public string CommonProperty { get; set; }
    // 可选：自定义类型标识，也可以用系统自动的类型名称
    public string ModelType { get; set; }
}

public class ModelB : ModelA
{
    public string BSpecificProperty { get; set; }
}

public class ModelC : ModelA
{
    public int CSpecificProperty { get; set; }
}

2. 配置JSON多态反序列化 #

默认情况下，System.Text.Json不会自动把JSON反序列化为派生类，所以我们需要在Program.cs里配置多态规则（.NET 7+支持更简洁的API）：

builder.Services.AddControllers()
    .AddJsonOptions(options =>
    {
        // 方案1：用类型名称作为自动标识（推荐，无需手动维护ModelType）
        options.JsonSerializerOptions.TypeInfoResolverChain.Insert(0, 
            JsonSerializerOptions.Default.WithAddedPolymorphism<ModelA>(
                derivedType => derivedType.Name,
                typeof(ModelB),
                typeof(ModelC)
            ));

        // 方案2：用自定义的ModelType字段作为标识
        // options.JsonSerializerOptions.TypeInfoResolverChain.Insert(0,
        //     JsonSerializerOptions.Default.WithAddedPolymorphism<ModelA>(
        //         prop => prop.ModelType,
        //         new Dictionary<string, Type>
        //         {
        //             { nameof(ModelB), typeof(ModelB) },
        //             { nameof(ModelC), typeof(ModelC) }
        //         }
        //     ));
    });

如果是.NET 6及更早版本，需要自定义JsonConverter来实现多态反序列化，原理类似——根据标识字段判断具体类型再反序列化。

3. 编写通用控制器端点 #

只需要一个接受基类ModelA的POST端点，不用关心具体派生类型：

[ApiController]
[Route("api/models")]
public class ModelsController : ControllerBase
{
    private readonly IModelService _modelService;

    public ModelsController(IModelService modelService)
    {
        _modelService = modelService;
    }

    [HttpPost]
    public IActionResult ProcessModel([FromBody] ModelA model)
    {
        if (model == null)
            return BadRequest("Model cannot be null");
        
        _modelService.Process(model);
        return Ok("Model processed successfully");
    }
}

4. 服务层处理类型分支 #

在服务层，用C#的模式匹配来识别具体派生类型，代码简洁又易维护：

public interface IModelService
{
    void Process(ModelA model);
}

public class ModelService : IModelService
{
    public void Process(ModelA model)
    {
        switch (model)
        {
            case ModelB bModel:
                HandleModelB(bModel);
                break;
            case ModelC cModel:
                HandleModelC(cModel);
                break;
            default:
                throw new ArgumentException($"Unsupported model type: {model.GetType().Name}");
        }
    }

    private void HandleModelB(ModelB model)
    {
        // 这里写ModelB专属的业务逻辑
        Console.WriteLine($"Processing ModelB: {model.CommonProperty} | {model.BSpecificProperty}");
    }

    private void HandleModelC(ModelC model)
    {
        // 这里写ModelC专属的业务逻辑
        Console.WriteLine($"Processing ModelC: {model.CommonProperty} | {model.CSpecificProperty}");
    }
}

可选优化：用策略模式处理大量派生类 #

如果你的派生类型特别多，写一堆switch会显得臃肿，推荐用策略模式拆分逻辑，符合开闭原则：

第一步：定义处理器接口和具体实现 #

// 通用处理器接口
public interface IModelProcessor<T> where T : ModelA
{
    void Process(T model);
}

// ModelB的专属处理器
public class ModelBProcessor : IModelProcessor<ModelB>
{
    public void Process(ModelB model)
    {
        // ModelB的业务逻辑
    }
}

// ModelC的专属处理器
public class ModelCProcessor : IModelProcessor<ModelC>
{
    public void Process(ModelC model)
    {
        // ModelC的业务逻辑
    }
}

第二步：改造服务层，依赖注入获取处理器 #

public class ModelService : IModelService
{
    private readonly IServiceProvider _serviceProvider;

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

    public void Process(ModelA model)
    {
        // 根据模型类型获取对应的处理器
        var processorType = typeof(IModelProcessor<>).MakeGenericType(model.GetType());
        var processor = _serviceProvider.GetService(processorType);
        
        if (processor == null)
            throw new ArgumentException($"No processor registered for {model.GetType().Name}");
        
        // 调用处理器的Process方法
        processorType.GetMethod(nameof(IModelProcessor<ModelA>.Process))?.Invoke(processor, new[] { model });
    }
}

第三步：注册处理器到DI容器 #

// 在Program.cs里注册所有处理器
builder.Services.AddScoped<IModelProcessor<ModelB>, ModelBProcessor>();
builder.Services.AddScoped<IModelProcessor<ModelC>, ModelCProcessor>();

这样以后新增派生类，只需要加对应的处理器和注册代码，完全不用修改服务层的核心逻辑。

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