Json.net serializa / desserializa tipos derivados?

json.net (newtonsoft)
Estou olhando a documentação, mas não consigo encontrar nada sobre isso ou a melhor maneira de fazer isso.

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

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

Agora tenho objetos derivados na lista serializada. Como faço para desserializar a lista e recuperar os tipos derivados?

Se você estiver armazenando o tipo em seu text(como deveria neste cenário), você pode usar o JsonSerializerSettings.

Veja: como desserializar JSON em IEnumerable <BaseType> com Newtonsoft JSON.NET

Mas tenha cuidado. Usar qualquer coisa diferente TypeNameHandling = TypeNameHandling.Nonepode abrir-se a uma vulnerabilidade de segurança .

Você deve habilitar o Tratamento de Nome de Tipo e passar isso para o (des) serializador como um parâmetro de configuração.

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

Isso resultará na desserialização correta das classes derivadas. Uma desvantagem é que nomeará todos os objetos que você está usando, assim como nomeará a lista na qual você está colocando os objetos.

Visto que a pergunta é tão popular, pode ser útil acrescentar o que fazer se quiser controlar o nome da propriedade do tipo e seu valor.

O longo caminho é escrever de forma personalizada JsonConverter s para lidar com a (des) serialização verificando e configurando manualmente a propriedade type.

Uma maneira mais simples é usar JsonSubTypes , que lida com todo o boilerplate por meio de atributos:

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

Use este JsonKnownTypes , é uma forma muito semelhante de usar, basta adicionar discriminador ao 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;
}

Agora, quando você serializar objeto em JSON será adicionar "$type"com "base"e "derived"valor e que vai ser usado para deserialize

Exemplo de lista serializada:

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