ASP.NET中反序列化不同JSON至类型层级结构的技术问询

针对你遇到的POST请求体中Payload存在多种结构的情况，结合你已有的类型层级，我推荐两种可行的实现方案，都是基于.NET生态里常用的序列化工具：

方案一：使用Newtonsoft.Json（Json.NET）自定义转换器（推荐） #

Json.NET是比ASP.NET 2.0默认序列化器更灵活的选择，通过自定义转换器可以精准识别不同结构的Payload并反序列化为对应的子类。

步骤1：完善你的类型层级 #

首先确保你的基类和子类结构清晰，所有Payload类型继承自同一个抽象基类：

public class BaseRequest
{
    public string Version { get; set; }
    public string Session { get; set; }
    public BasePayload Payload { get; set; }
}

// 抽象基类定义公共字段
public abstract class BasePayload
{
    // 注意：你示例里的JSON字段是"tmestamp"，这里建议修正拼写为"timestamp"，如果必须保留原拼写，可加[JsonProperty("tmestamp")]特性
    public string Timestamp { get; set; }
}

// 仅含Timestamp的Payload
public class SimplePayload : BasePayload { }

// 含Timestamp和Name的Payload
public class NamedPayload : BasePayload
{
    public string Name { get; set; }
}

// 含Timestamp、Status和Values的Payload
public class StatusValuesPayload : BasePayload
{
    public int Status { get; set; }
    public List<int> Values { get; set; }
}

步骤2：实现自定义JsonConverter #

创建一个转换器类，根据JSON中的字段判断应该实例化哪个Payload子类：

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;

public class PayloadConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        // 只处理BasePayload类型的转换
        return objectType == typeof(BasePayload);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // 加载JSON对象
        var jObject = JObject.Load(reader);

        // 根据字段判断Payload类型
        if (jObject.ContainsKey("name"))
        {
            return jObject.ToObject<NamedPayload>(serializer);
        }
        else if (jObject.ContainsKey("status") && jObject.ContainsKey("values"))
        {
            return jObject.ToObject<StatusValuesPayload>(serializer);
        }
        else
        {
            // 默认匹配仅含Timestamp的SimplePayload
            return jObject.ToObject<SimplePayload>(serializer);
        }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        // 序列化时直接按实际类型输出
        serializer.Serialize(writer, value);
    }
}

步骤3：在Web API中注册转换器 #

打开WebApiConfig.cs，将自定义转换器添加到JsonFormatter的序列化设置中：

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        // 注册自定义转换器
        config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new PayloadConverter());

        // 其他路由配置...
    }
}

步骤4：使用反序列化后的对象 #

在API控制器的POST方法中，直接接收BaseRequest类型参数即可，之后可以通过类型判断处理不同的Payload：

public IHttpActionResult Post(BaseRequest request)
{
    if (request.Payload is StatusValuesPayload statusPayload)
    {
        // 处理包含status和values的逻辑
        var status = statusPayload.Status;
        var values = statusPayload.Values;
    }
    else if (request.Payload is NamedPayload namedPayload)
    {
        // 处理包含name的逻辑
        var name = namedPayload.Name;
    }
    else if (request.Payload is SimplePayload simplePayload)
    {
        // 处理仅含timestamp的逻辑
    }

    return Ok();
}

方案二：使用默认的DataContractJsonSerializer（KnownType特性） #

如果你倾向于使用ASP.NET 2.0默认的序列化器，可以通过[KnownType]特性告诉序列化器基类可能的子类类型：

步骤1：修改类型层级为DataContract风格 #

给基类和子类添加[DataContract]和[DataMember]特性，并通过[KnownType]声明所有可能的Payload子类：

using System.Runtime.Serialization;
using System.Collections.Generic;

[DataContract]
public class BaseRequest
{
    [DataMember(Name = "Version")]
    public string Version { get; set; }
    [DataMember(Name = "Session")]
    public string Session { get; set; }
    [DataMember(Name = "Payload")]
    public BasePayload Payload { get; set; }
}

[DataContract]
[KnownType(typeof(SimplePayload))]
[KnownType(typeof(NamedPayload))]
[KnownType(typeof(StatusValuesPayload))]
public abstract class BasePayload
{
    // 匹配JSON中的"tmestamp"字段
    [DataMember(Name = "tmestamp")]
    public string Timestamp { get; set; }
}

[DataContract]
public class SimplePayload : BasePayload { }

[DataContract]
public class NamedPayload : BasePayload
{
    [DataMember(Name = "name")]
    public string Name { get; set; }
}

[DataContract]
public class StatusValuesPayload : BasePayload
{
    [DataMember(Name = "status")]
    public int Status { get; set; }
    [DataMember(Name = "values")]
    public List<int> Values { get; set; }
}

步骤2：直接在控制器中使用 #

此时Web API会自动使用DataContractJsonSerializer处理反序列化，你可以在POST方法中直接接收BaseRequest，之后同样通过类型判断处理不同Payload：

public IHttpActionResult Post(BaseRequest request)
{
    // 类型判断逻辑和方案一一致
    return Ok();
}

注意事项 #

1. 字段名匹配：确保类属性的名称（或特性中的Name值）和JSON中的键完全一致，比如你示例里的"tmestamp"，如果拼写是笔误建议修正为标准的"timestamp"，避免不必要的错误。
2. 类型判断：反序列化后可以用is或as关键字安全地转换Payload的实际类型，避免强制转换出现异常。
3. 依赖安装：如果使用方案一的Json.NET，需要通过NuGet安装Newtonsoft.Json包（ASP.NET 2.0可能需要指定兼容的版本，比如12.x系列）。

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