Json.net abgeleitete Typen serialisieren / deserialisieren?

json.net (newtonsoft)
Ich sehe mir die Dokumentation an, finde aber nichts dazu oder den besten Weg, dies zu tun.

public class Base
{
    public string Name;
}
public class Derived : Base
{
    public string Something;
}

JsonConvert.Deserialize<List<Base>>(text);

Jetzt habe ich Objekte in der serialisierten Liste abgeleitet. Wie deserialisiere ich die Liste und erhalte abgeleitete Typen zurück?

Wenn Sie den Typ in Ihrem speichern text(wie Sie es in diesem Szenario tun sollten), können Sie das verwenden JsonSerializerSettings.

Siehe: So deserialisieren Sie JSON mit Newtonsoft JSON.NET in IEnumerable <BaseType>

Sei aber vorsichtig. Wenn Sie etwas anderes verwenden, als TypeNameHandling = TypeNameHandling.Nonesich einer Sicherheitslücke öffnen könnten .

Sie müssen die Behandlung von Typnamen aktivieren und diese als Einstellungsparameter an den (De-) Serializer übergeben.

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);

Dies führt zu einer korrekten Deserialisierung abgeleiteter Klassen. Ein Nachteil dabei ist, dass alle von Ihnen verwendeten Objekte benannt werden. Als solche wird die Liste benannt, in die Sie die Objekte einfügen.

Da die Frage so beliebt ist, kann es hilfreich sein, hinzuzufügen, was zu tun ist, wenn Sie den Namen der Typ-Eigenschaft und ihren Wert steuern möchten.

Der lange Weg besteht darin, benutzerdefinierte JsonConverters zu schreiben , um die (De-) Serialisierung zu handhaben, indem die type-Eigenschaft manuell überprüft und festgelegt wird.

Eine einfachere Möglichkeit ist die Verwendung von JsonSubTypes , das die gesamte Boilerplate über Attribute verarbeitet:

[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; }
}

Verwenden Sie diese JsonKnownTypes , es ist sehr ähnlich zu verwenden, es fügt nur einen Diskriminator zu json hinzu:

[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;
}

Wenn Sie nun ein Objekt in json serialisieren, wird es "$type"mit "base"und "derived"value hinzugefügt und zum Deserialisieren verwendet

Beispiel für eine serialisierte Liste:

[
    {"Name":"some name", "$type":"base"},
    {"Name":"some name", "Something":"something", "$type":"derived"}
]