JSON.NET: Comment faire pour désérialiser interface bien sur la base d'un parent (titulaire) la valeur de l'objet?

J'ai ces classes

class Holder {
    public int ObjType { get; set; }
    public List<Base> Objects { get; set; }
}

abstract class Base {
    //... doesn't matter
}

class DerivedType1 : Base {
    //... doesn't matter
}

class DerivedType2 : Base {
    //... doesn't matter
}

À l'aide de WebAPI je veux recevoir l'objet Holder et désérialiser correctement. Basé sur le ObjType valeur que j'ai besoin Objects bien être désérialisé soit comme List<DerivedType1> (ObjType == 1) ou List<DerivedType2> (ObjType == 2).

Pour le moment j'ai cherché SI et internet pour la meilleure approche, mais la meilleure que j'ai trouvé est cette réponse https://stackoverflow.com/a/8031283/1038496. Le problème de cette solution est qu'elle lâche contexte de l'objet parent, je ne peux pas trouver la valeur de ObjType. OK, j'ai pu le résoudre en créant personnalisé JsonConverter pour Holder et remebering la ObjType valeur, mais je suis peur de cette ligne

serializer.Populate(jObject.CreateReader(), target);

que le commentaire en dessous de cette réponse dit

La nouvelle JsonReader créé dans le ReadJson méthode n'héritent pas l'un de l'original du lecteur valeurs de configuration (Culture, DateParseHandling, DateTimeZoneHandling, FloatParseHandling, etc...). Ces valeurs doivent être copiés avant d'utiliser le nouveau JsonReader dans sérialiseur.Remplir().

qui est un problème pour moi et de copier ces valeurs par moi-même ne semble pas propre à moi (si j'ai raté quelque chose?)

La question est donc: Est-il une meilleure approche que j'ai manqué de désérialiser objet abstrait de la propriété fondée sur la propriété parent de la valeur?

InformationsquelleAutor Zoka | 2014-03-20

asp.net-web-api c#json-deserialization json.net

Vous êtes sur la bonne voie. Vous avez besoin de mettre en œuvre une coutume JsonConverter pour votre Holder classe pour gérer cette situation, comme vous l'avez suggéré. Mais, ne vous inquiétez pas, il est possible d'écrire le convertisseur de telle manière que vous pouvez utiliser le lecteur d'origine et sérialiseur cas transmis au convertisseur, sans jamais avoir besoin de copier les paramètres sur les nouvelles instances. Voici comment j'allais l'écrire:

class HolderConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(Holder));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject jo = JObject.Load(reader);
        Holder holder = new Holder();
        holder.ObjType = (int)jo["ObjType"];
        holder.Objects = new List<Base>();
        foreach (JObject obj in jo["Objects"])
        {
            if (holder.ObjType == 1)
                holder.Objects.Add(obj.ToObject<DerivedType1>(serializer));
            else
                holder.Objects.Add(obj.ToObject<DerivedType2>(serializer));
        }
        return holder;
    }

    public override bool CanWrite
    {
        get { return false; }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Voici une démonstration rapide:

class Program
{
static void Main(string[] args)
{
string json = @"
[
{
""ObjType"" : 1,
""Objects"" : 
[
{ ""Id"" : 1, ""Foo"" : ""One"" },
{ ""Id"" : 2, ""Foo"" : ""Two"" },
]
},
{
""ObjType"" : 2,
""Objects"" : 
[
{ ""Id"" : 3, ""Bar"" : ""Three"" },
{ ""Id"" : 4, ""Bar"" : ""Four"" },
]
},
]";
List<Holder> list = JsonConvert.DeserializeObject<List<Holder>>(json);
foreach (Holder holder in list)
{
if (holder.ObjType == 1)
{
foreach (DerivedType1 obj in holder.Objects)
{
Console.WriteLine("Id: " + obj.Id + "  Foo: " + obj.Foo);
}
}
else
{
foreach (DerivedType2 obj in holder.Objects)
{
Console.WriteLine("Id: " + obj.Id + "  Bar: " + obj.Bar);
}
}
}
}
}
[JsonConverter(typeof(HolderConverter))]
class Holder
{
public int ObjType { get; set; }
public List<Base> Objects { get; set; }
}
abstract class Base
{
public int Id { get; set; }
}
class DerivedType1 : Base
{
public string Foo { get; set; }
}
class DerivedType2 : Base
{
public string Bar { get; set; }
}

De sortie:

Id: 1  Foo: One
Id: 2  Foo: Two
Id: 3  Bar: Three
Id: 4  Bar: Four

C'est une solution élégante et plus d'avenir que l'alternative de copier les propriétés de la JsonReader. Une petite mise en garde: si le convertisseur est appliqué à une Classe plutôt qu'à une Propriété, il y a la possibilité de récursivité et de dépassement de pile.

InformationsquelleAutor Brian Rogers

Vous devez vous connecter pour publier un commentaire.