如何优雅实现JSON字符串到多目标类的反序列化？

兄弟，那种靠try-catch挨个试的方式确实太糙了——不仅异常处理本身开销不小，以后加新类还要堆更多try块，维护起来头疼死。给你几个更优雅的解决方案，按需选：

方案1：通过特征字段先判断类型（最直观高效） #

如果你的JSON字符串里有能区分不同类的唯一标识字段（比如每个类对应的JSON里都有Type字段，值分别是"Class1"、"Class2"），可以先把JSON解析成JObject，读取这个标识后再针对性反序列化，完全不用依赖异常：

using Newtonsoft.Json.Linq;

// 先解析JSON读取特征字段
var jObject = JObject.Parse(stringJson);
var typeFlag = jObject["Type"]?.Value<string>();

// 根据标识选择对应类反序列化
object result = typeFlag switch
{
    "Class1" => JsonConvert.DeserializeObject<MyClass1>(stringJson),
    "Class2" => JsonConvert.DeserializeObject<MyClass2>(stringJson),
    // 新增类时直接加分支即可
    _ => throw new InvalidOperationException("无法识别的目标类型")
};

// 后续可以用is/as判断具体类型
if (result is MyClass1 class1Instance)
{
    // 处理MyClass1的业务逻辑
}

这个方法性能最优，逻辑也清晰，是最推荐的方案。

方案2：自定义JsonConverter统一处理（适合有基类的场景） #

如果这些类有共同的基类（比如BaseClass），可以写一个自定义转换器，把类型判断的逻辑封装起来，调用方代码会非常干净：

public class BaseClassConverter : JsonConverter<BaseClass>
{
    public override BaseClass ReadJson(JsonReader reader, Type objectType, BaseClass existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        var jObject = JObject.Load(reader);
        var typeFlag = jObject["Type"]?.Value<string>();

        return typeFlag switch
        {
            "Class1" => jObject.ToObject<MyClass1>(serializer),
            "Class2" => jObject.ToObject<MyClass2>(serializer),
            _ => throw new JsonSerializationException("无法识别的类型标识")
        };
    }

    // 如果需要序列化基类实例，也可以在这里统一写入类型标识
    public override void WriteJson(JsonWriter writer, BaseClass value, JsonSerializer serializer)
    {
        var jObject = JObject.FromObject(value);
        jObject["Type"] = value.GetType().Name switch
        {
            nameof(MyClass1) => "Class1",
            nameof(MyClass2) => "Class2",
            _ => throw new JsonSerializationException("未知类型")
        };
        jObject.WriteTo(writer);
    }
}

调用时只需要配置一次转换器：

var settings = new JsonSerializerSettings();
settings.Converters.Add(new BaseClassConverter());

// 直接反序列化为基类即可
var result = JsonConvert.DeserializeObject<BaseClass>(stringJson, settings);

方案3：类型映射字典+反射（适合动态扩展场景） #

如果你的类会动态增加，不想每次修改switch分支，可以把类型标识和对应Type存在字典里，用反射实现动态反序列化：

// 提前定义类型映射关系，新增类时只需加条目
var typeMap = new Dictionary<string, Type>
{
    {"Class1", typeof(MyClass1)},
    {"Class2", typeof(MyClass2)}
};

var jObject = JObject.Parse(stringJson);
var typeFlag = jObject["Type"]?.Value<string>();

if (!typeMap.TryGetValue(typeFlag, out var targetType))
{
    throw new InvalidOperationException("未知的目标类型");
}

// 通过反射调用JsonConvert的泛型反序列化方法
var deserializeMethod = typeof(JsonConvert)
    .GetMethod("DeserializeObject", new[] { typeof(string) })
    ?.MakeGenericMethod(targetType);

var result = deserializeMethod?.Invoke(null, new object[] { stringJson });

这个方案灵活性最高，适合类型较多或需要动态加载类型的场景。

内容的提问来源于stack exchange，提问作者Marcin Gołuński