如何处理包含派生类的基类列表，保留子类全部属性？

方案1：配置序列化器支持多态（推荐） #

如果使用ASP.NET Core的序列化组件（System.Text.Json或Newtonsoft.Json），可以通过配置让序列化器识别派生类，服务层无需修改返回类型，仍返回IEnumerable<ParentClass>，但序列化时会自动保留派生类的属性，同时保持类型安全。

System.Text.Json 配置示例 #

在Program.cs中添加序列化配置：

builder.Services.AddControllers()
    .AddJsonOptions(options =>
    {
        options.JsonSerializerOptions.TypeInfoResolver = new DefaultJsonTypeInfoResolver
        {
            Modifiers = {
                typeInfo =>
                {
                    if (typeInfo.Type == typeof(ParentClass))
                    {
                        // 注册所有需要序列化的派生类
                        typeInfo.PolymorphismOptions.AddDerivedType(typeof(ChildClassA));
                        typeInfo.PolymorphismOptions.AddDerivedType(typeof(ChildClassB));
                    }
                }
            }
        };
    });

服务层代码保持不变：

public async Task<IEnumerable<ParentClass>> ReadResultAsync()
{
    var results = new List<ParentClass>();
    results.Add(new ChildClassA { A = "a", B = "b", C = "c", D = "d", E = "e" });
    results.Add(new ChildClassB { A = "a", B = "b", C = "c", F = "f" });
    return results;
}

此时控制器返回的JSON会自动包含每个派生类的所有属性。

Newtonsoft.Json 配置示例 #

如果使用Newtonsoft.Json（Json.NET），配置方式如下：

builder.Services.AddControllers()
    .AddNewtonsoftJson(options =>
    {
        options.SerializerSettings.TypeNameHandling = TypeNameHandling.Auto;
        // 注册具体派生类
        options.SerializerSettings.Converters.Add(new JsonDerivedTypeConverter(typeof(ChildClassA), "ChildA"));
        options.SerializerSettings.Converters.Add(new JsonDerivedTypeConverter(typeof(ChildClassB), "ChildB"));
    });

方案2：使用DTO（数据传输对象） #

创建与业务类对应的DTO，通过映射转换后返回，既能保留类型安全，又能灵活控制返回的属性结构，适合需要对返回数据做自定义处理的场景。

定义DTO类 #

public class ParentDto
{
    public string A { get; set; }
    public string B { get; set; }
    public string C { get; set; }
}

public class ChildADto : ParentDto
{
    public string D { get; set; }
    public string E { get; set; }
}

public class ChildBDto : ParentDto
{
    public string F { get; set; }
}

服务层映射并返回DTO #

public async Task<IEnumerable<ParentDto>> ReadResultAsync()
{
    var results = new List<ParentDto>();
    // 假设从数据源获取ChildClassA/ChildClassB实例
    var childA = new ChildClassA { A = "a", B = "b", C = "c", D = "d", E = "e" };
    var childB = new ChildClassB { A = "a", B = "b", C = "c", F = "f" };
    
    results.Add(new ChildADto 
    { 
        A = childA.A, 
        B = childA.B, 
        C = childA.C, 
        D = childA.D, 
        E = childA.E 
    });
    results.Add(new ChildBDto 
    { 
        A = childB.A, 
        B = childB.B, 
        C = childB.C, 
        F = childB.F 
    });
    
    return results;
}

方案3：使用动态类型（不推荐长期使用） #

如果只是临时过渡，可以用dynamic替代object，语法上更简洁，但会失去编译时类型检查，增加潜在bug风险：

public async Task<IEnumerable<dynamic>> ReadResultAsync()
{
    var results = new List<dynamic>();
    results.Add(new ChildClassA { A = "a", B = "b", C = "c", D = "d", E = "e" });
    results.Add(new ChildClassB { A = "a", B = "b", C = "c", F = "f" });
    return results;
}

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