将 JSON 反序列化为抽象类

Question

我正在尝试将 JSON 字符串反序列化为从抽象类继承的具体类，但我就是无法让它工作。我已经用谷歌搜索并尝试了一些解决方案，但它们似乎也不起作用。

这就是我现在拥有的：

abstract class AbstractClass { }
class ConcreteClass { }
public AbstractClass Decode(string jsonString)
{
    JsonSerializerSettings jss = new JsonSerializerSettings();
    jss.TypeNameHandling = TypeNameHandling.All;
    return (AbstractClass)JsonConvert.DeserializeObject(jsonString, null, jss);
}

但是，如果我尝试强制转换生成的对象，它就是不起作用。

我不使用反序列化对象的原因是我有很多具体的类。

有什么建议吗？

• 我正在使用Newtonsoft.Json

Answer 1

人们可能不想使用 TypeNameHandling（因为想要更紧凑的 json，或者想要为类型变量使用特定名称而不是 "$type"）。同时，如果想要将基类反序列化为多个派生类中的任何一个，而事先不知道要使用哪个派生类，则 customCreationConverter 方法将不起作用。

另一种方法是在基类中使用 int 或其他类型并定义 JsonConverter。

[JsonConverter(typeof(BaseConverter))]
abstract class Base
{
    public int ObjType { get; set; }
    public int Id { get; set; }
}
class DerivedType1 : Base
{
    public string Foo { get; set; }
}
class DerivedType2 : Base
{
    public string Bar { get; set; }
}

然后，基类的 JsonConverter 可以根据对象的类型反序列化对象。复杂之处在于，为了避免堆栈溢出（JsonConverter 反复调用自身），在此反序列化期间必须使用自定义协定解析器。

public class BaseSpecifiedConcreteClassConverter : DefaultContractResolver
{
    protected override JsonConverter ResolveContractConverter(Type objectType)
    {
        if (typeof(Base).IsAssignableFrom(objectType) && !objectType.IsAbstract)
            return null; // pretend TableSortRuleConvert is not specified (thus avoiding a stack overflow)
        return base.ResolveContractConverter(objectType);
    }
}
public class BaseConverter : JsonConverter
{
    static JsonSerializerSettings SpecifiedSubclassConversion = new JsonSerializerSettings() { ContractResolver = new BaseSpecifiedConcreteClassConverter() };
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(Base));
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject jo = JObject.Load(reader);
        switch (jo["ObjType"].Value<int>())
        {
            case 1:
                return JsonConvert.DeserializeObject<DerivedType1>(jo.ToString(), SpecifiedSubclassConversion);
            case 2:
                return JsonConvert.DeserializeObject<DerivedType2>(jo.ToString(), SpecifiedSubclassConversion);
            default:
                throw new Exception();
        }
        throw new NotImplementedException();
    }
    public override bool CanWrite
    {
        get { return false; }
    }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException(); // won't be called because CanWrite returns false
    }
}

就是这样。现在，您可以使用序列化/反序列化任何派生类。您还可以在其他类中使用基类，并序列化/反序列化这些类，而无需任何其他工作：

class Holder
    {
        public List<Base> Objects { get; set; }
    }
string json = @"
        [
            {
                ""Objects"" : 
                [
                    { ""ObjType"": 1, ""Id"" : 1, ""Foo"" : ""One"" },
                    { ""ObjType"": 1, ""Id"" : 2, ""Foo"" : ""Two"" },
                ]
            },
            {
                ""Objects"" : 
                [
                    { ""ObjType"": 2, ""Id"" : 3, ""Bar"" : ""Three"" },
                    { ""ObjType"": 2, ""Id"" : 4, ""Bar"" : ""Four"" },
                ]
            },
        ]";
            List<Holder> list = JsonConvert.DeserializeObject<List<Holder>>(json);
            string serializedAgain = JsonConvert.SerializeObject(list);
            Debug.WriteLine(serializedAgain);

Answer 2

我建议通过以下方式使用CustomCreationConverter：

public enum ClassDiscriminatorEnum
    {
        ChildClass1,
        ChildClass2
    }
    public abstract class BaseClass
    {
        public abstract ClassDiscriminatorEnum Type { get; }
    }
    public class Child1 : BaseClass
    {
        public override ClassDiscriminatorEnum Type => ClassDiscriminatorEnum.ChildClass1;
        public int ExtraProperty1 { get; set; }
    }
    public class Child2 : BaseClass
    {
        public override ClassDiscriminatorEnum Type => ClassDiscriminatorEnum.ChildClass2;
    }
    public class BaseClassConverter : CustomCreationConverter<BaseClass>
    {
        private ClassDiscriminatorEnum _currentObjectType;
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var jobj = JObject.ReadFrom(reader);
            _currentObjectType = jobj["Type"].ToObject<ClassDiscriminatorEnum>();
            return base.ReadJson(jobj.CreateReader(), objectType, existingValue, serializer);
        }
        public override BaseClass Create(Type objectType)
        {
            switch (_currentObjectType)
            {
                case ClassDiscriminatorEnum.ChildClass1:
                    return new Child1();
                case ClassDiscriminatorEnum.ChildClass2:
                    return new Child2();
                default:
                    throw new NotImplementedException();
            }
        }
    }

Answer 3

尝试这样的事情

public AbstractClass Decode(string jsonString)
{
    var jss = new JavaScriptSerializer();
    return jss.Deserialize<ConcreteClass>(jsonString);
}

更新
对于这种情况，我认为一切都可以随心所欲地工作

public abstract class Base
{
    public abstract int GetInt();
}
public class Der:Base
{
    int g = 5;
    public override int GetInt()
    {
        return g+2;
    }
}
public class Der2 : Base
{
    int i = 10;
    public override int GetInt()
    {
        return i+17;
    }
}
....
var jset = new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All };
Base b = new Der()
string json = JsonConvert.SerializeObject(b, jset);
....
Base c = (Base)JsonConvert.DeserializeObject(json, jset);

其中c类型为test.Base {test.Der}

更新

@Gusman建议使用 TypeNameHandling.Objects 而不是 TypeNameHandling.All .这就足够了，它将产生不那么冗长的序列化。

Answer 4

实际上，正如更新中所述，最简单的方法（在 2019 年）是使用一个简单的自定义预定义 JsonSerializerSettings，如此处所述

        string jsonTypeNameAll = JsonConvert.SerializeObject(priceModels, Formatting.Indented,new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.All
        });

对于反序列化：

TDSPriceModels models = JsonConvert.DeserializeObject<TDSPriceModels>(File.ReadAllText(jsonPath), new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.All
        });

Answer 5

 public class CustomConverter : JsonConverter
{
    private static readonly JsonSerializer Serializer = new JsonSerializer();
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var jObject = JObject.Load(reader);
        var typeString = jObject.Value<string>("Kind"); //Kind is a property in json , from which we know type of child classes
        var requiredType = RecoverType(typeString);
        return Serializer.Deserialize(jObject.CreateReader(), requiredType);
    }
    private Type RecoverType(string typeString)
    {
        if (typeString.Equals(type of child class1, StringComparison.OrdinalIgnoreCase))
            return typeof(childclass1);
        if (typeString.Equals(type of child class2, StringComparison.OrdinalIgnoreCase))
            return typeof(childclass2);            
        throw new ArgumentException("Unrecognized type");
    }
    public override bool CanConvert(Type objectType)
    {
        return typeof(Base class).IsAssignableFrom(objectType) || typeof((Base class) == objectType;
    }
    public override bool CanWrite { get { return false; } }
}

现在在 JsonSerializerSettings 中添加此转换器，如下所示

   var jsonSerializerSettings = new JsonSerializerSettings();
        jsonSerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
        jsonSerializerSettings.Converters.Add(new CustomConverter());

添加序列化或反序列化基类对象后，如下所示

 JsonConvert.DeserializeObject<Type>("json string", jsonSerializerSettings );

Answer 6

我有一个类似的问题，我用另一种方式解决了它，也许这会帮助某人：我有 json，其中包含几个始终相同的字段，除了一个名为"data"的字段，该字段每次都可以是不同类型的类。我想反序列化它，而不分析每个具体的归档。我的解决方案是：要使用 定义主类（带有"数据"字段），则字段 Data 的类型为 T。每当我反序列化时，我都会指定类型：

主类：

public class MainClass<T>
{
    [JsonProperty("status")]
    public Statuses Status { get; set; }
    [JsonProperty("description")]
    public string Description { get; set; }
    [JsonProperty("data")]
    public T Data { get; set; }
    public static MainClass<T> Parse(string mainClsTxt)
    {
        var response = JsonConvert.DeserializeObject<MainClass<T>>(mainClsTxt);
        return response;
    }
} 

用户

public class User
{
    [JsonProperty("id")]
    public int UserId { get; set; }
    [JsonProperty("first_name")]
    public string FirstName { get; set; }
    [JsonProperty("last_name")]
    public string LastName { get; set; }
}

产品

public class Product
{
    [JsonProperty("product_id")]
    public int ProductId { get; set; }
    [JsonProperty("product_name")]
    public string ProductName { get; set; }
    [JsonProperty("stock")]
    public int Stock { get; set; }
}

用

var v = MainClass<User>.Parse(userJson);
var v2 = MainClass<Product>.Parse(productJson);

JSON 示例

userJson: "{"status":1,"description":"my description","data":{"id":12161347,"first_name":"my fname","last_name":"my lname"}}"
productJson: "{"status":1,"description":"my description","data":{"product_id":5,"product_name":"my product","stock":1000}}"

Answer 7

public abstract class JsonCreationConverter<T> : JsonConverter
{
    protected abstract T Create(Type objectType, JObject jObject);
    public override bool CanConvert(Type objectType)
    {
        return typeof(T) == objectType;
    }
    public override object ReadJson(JsonReader reader,Type objectType,
        object existingValue, JsonSerializer serializer)
    {
        try
        {
            var jObject = JObject.Load(reader);
            var target = Create(objectType, jObject);
            serializer.Populate(jObject.CreateReader(), target);
            return target;
        }
        catch (JsonReaderException)
        {
            return null;
        }
    }
    public override void WriteJson(JsonWriter writer, object value,
        JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

现在实现此接口

public class SportActivityConverter : JsonCreationConverter<BaseSportActivity>
{
    protected override BaseSportActivity Create(Type objectType, JObject jObject)
    {
        BaseSportActivity result = null;
        try
        {
            switch ((ESportActivityType)jObject["activityType"].Value<int>())
            {
                case ESportActivityType.Football:
                    result = jObject.ToObject<FootballActivity>();
                    break;
                case ESportActivityType.Basketball:
                    result = jObject.ToObject<BasketballActivity>();
                    break;
            }
            
        }
        catch(Exception ex)
        {
            Debug.WriteLine(ex);
        }
        return result;
        
    }
}