Json.net sérialise / désérialise les types dérivés?

json.net (newtonsoft)
Je suis en train de parcourir la documentation mais je ne trouve rien sur ceci ou la meilleure façon de le faire.

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

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

Maintenant, j'ai des objets dérivés dans la liste sérialisée. Comment désérialiser la liste et récupérer les types dérivés?

Si vous stockez le type dans votre text(comme vous devriez l'être dans ce scénario), vous pouvez utiliser le JsonSerializerSettings.

Voir: comment désérialiser JSON en IEnumerable <BaseType> avec Newtonsoft JSON.NET

Soyez prudent, cependant. Utiliser autre chose que TypeNameHandling = TypeNameHandling.Nonepourrait vous ouvrir à une faille de sécurité .

Vous devez activer la gestion du nom de type et le transmettre au (dé) sérialiseur en tant que paramètre de configuration.

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

Cela entraînera une désérialisation correcte des classes dérivées. Un inconvénient est qu'il nommera tous les objets que vous utilisez, en tant que tel, il nommera la liste dans laquelle vous placez les objets.

Étant donné que la question est si populaire, il peut être utile d'ajouter ce qu'il faut faire si vous souhaitez contrôler le nom de la propriété de type et sa valeur.

Le long chemin est d'écrire des JsonConverters personnalisés pour gérer la (dé) sérialisation en vérifiant et en définissant manuellement la propriété type.

Un moyen plus simple consiste à utiliser JsonSubTypes , qui gère tout le passe-partout via des attributs:

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

Utilisez ce JsonKnownTypes , c'est une manière très similaire d'utiliser, il suffit d'ajouter un discriminateur à 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;
}

Maintenant , lorsque vous sérialiser objet JSON sera ajouter "$type"avec "base"et "derived"valeur et il sera utilisé pour deserialize

Exemple de liste sérialisée:

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