json.net (newtonsoft)
I am looking through the documentation but I can't find anything on this or the best way to do it.
public class Base
{
public string Name;
}
public class Derived : Base
{
public string Something;
}
JsonConvert.Deserialize<List<Base>>(text);
Now I have Derived objects in the serialized list. How do I deserialize the list and get back derived types?
If you are storing the type in your text (as you should be in this scenario), you can use the JsonSerializerSettings.
See: how to deserialize JSON into IEnumerable<BaseType> with Newtonsoft JSON.NET
Be careful, though. Using anything other than TypeNameHandling = TypeNameHandling.None could open yourself up to a security vulnerability - see "How to configure Json.NET to create a vulnerable web API".
TypeNameHandling = TypeNameHandling.Auto - this will add a $type property ONLY for instances where the declared type (i.e. Base) does not match the instance type (i.e. Derived). This way, it doesn't bloat your JSON as much as TypeNameHandling.All. –
Popple System.Text.Json.Serialization: learn.microsoft.com/en-us/dotnet/standard/serialization/… –
Newmint You have to enable Type Name Handling and pass that to the (de)serializer as a settings parameter for both Serialize and Deserialize operations.
Base object1 = new Base() { Name = "Object1" };
Derived object2 = new Derived() { Something = "Some other thing" };
List<Base> inheritanceList = new List<Base>() { object1, object2 };
JsonSerializerSettings settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All };
string Serialized = JsonConvert.SerializeObject(inheritanceList, settings);
List<Base> deserializedList = JsonConvert.DeserializeObject<List<Base>>(Serialized, settings);
This will result in correct deserialization of derived classes. A drawback to it is that it will name all the objects you are using, as such it will name the list you are putting the objects in.
TypeNameHandling.Auto will do it too, and is nicer because it doesn't write the instance type name when it matches the type of the field/property, which is often the case for most fields/properties. –
Sadler If you are storing the type in your text (as you should be in this scenario), you can use the JsonSerializerSettings.
See: how to deserialize JSON into IEnumerable<BaseType> with Newtonsoft JSON.NET
Be careful, though. Using anything other than TypeNameHandling = TypeNameHandling.None could open yourself up to a security vulnerability - see "How to configure Json.NET to create a vulnerable web API".
TypeNameHandling = TypeNameHandling.Auto - this will add a $type property ONLY for instances where the declared type (i.e. Base) does not match the instance type (i.e. Derived). This way, it doesn't bloat your JSON as much as TypeNameHandling.All. –
Popple System.Text.Json.Serialization: learn.microsoft.com/en-us/dotnet/standard/serialization/… –
Newmint Since the question is so popular, it may be useful to add on what to do if you want to control the type property name and its value.
The long way is to write custom JsonConverters to handle (de)serialization by manually checking and setting the type property.
A simpler way is to use JsonSubTypes, which handles all the boilerplate via attributes:
[JsonConverter(typeof(JsonSubtypes), "Sound")]
[JsonSubtypes.KnownSubType(typeof(Dog), "Bark")]
[JsonSubtypes.KnownSubType(typeof(Cat), "Meow")]
public class Animal
{
public virtual string Sound { get; }
public string Color { get; set; }
}
public class Dog : Animal
{
public override string Sound { get; } = "Bark";
public string Breed { get; set; }
}
public class Cat : Animal
{
public override string Sound { get; } = "Meow";
public bool Declawed { get; set; }
}
JsonSubtypes even defined? I'm using Newtonsoft.Json Version 12.0.0.0 and have no reference to JsonSubtypes, JsonSubTypes nor JsonSubtypesConverterBuilder (mentioned in that article). –
Scamander [JsonSubtypes.KnownSubType(typeof(Cat))] to tell the deserializer to use Cat if it finds a Declawed value? –
Inesita null for the second parameter for KnownSubType because I have nothing to give it; I've also tried KnownSubTypeWithPropertyAttribute(typeof(Cat), nameof(Cat.Declawed)) and even added jsonSerializer.Converters.Add(JsonSubtypesConverterBuilder.Of<Animal>(nameof(Cat.Declawed)).RegisterSubtype<Cat>(AnimalType.Cat).SerializeDiscriminatorProperty().Build()); to both the serializer and deserializer but only the base class properties are deserialized even though the sub class properties are present in the JSON! –
Scamander Use this JsonKnownTypes, it's very similar way to use, it just add discriminator to json:
[JsonConverter(typeof(JsonKnownTypeConverter<BaseClass>))]
[JsonKnownType(typeof(Base), "base")]
[JsonKnownType(typeof(Derived), "derived")]
public class Base
{
public string Name;
}
public class Derived : Base
{
public string Something;
}
Now when you serialize object in json will be add "$type" with "base" and "derived" value and it will be use for deserialize
Serialized list example:
[
{"Name":"some name", "$type":"base"},
{"Name":"some name", "Something":"something", "$type":"derived"}
]
In .NET 6/7 you could use System.Text.Json.Serialization
[JsonDerivedType(typeof(Panel), typeDiscriminator: "panel")]
JsonDerivedType works for .NET7+ (no .NET6- implementations from MS). See "Applies to" section here –
Sedgemoor just add object in Serialize method
var jsonMessageBody = JsonSerializer.Serialize<object>(model);
© 2022 - 2024 — McMap. All rights reserved.