Désérialiser la propriété JSON incohérente

J'espère que quelqu'un pourra m'aider avec l'incohérence suivante se produisant dans un gros fichier JSON que j'essaie de désérialiser à l'aide de Newtonsoft.Json.

L'une des propriétés de l'objet apparaît parfois comme :

"roles": [
  {
    "field1" : "value",
    "field2" : "value"
  }
]

Alors que d'autres fois, cette même propriété apparaît comme :

"roles": {
  "roles": [
    {
      "field1" : "value",
      "field2" : "value"
    }
  ]
}

Pour référence, cette propriété est implémentée dans sa classe comme suit :

[JsonProperty("roles")]
public List<Role> Roles { get; set; }

Ce que je dois faire, c'est que chaque fois que la deuxième situation ci-dessus se produit, le contenu de l'objet est désérialisé comme la première situation. c'est-à-dire que l'objet "extérieur" est rejeté/ignoré

J'ai réussi à gérer une autre incohérence dans ce fichier lorsqu'une propriété distincte apparaît parfois en tant qu'objet et parfois en tant que tableau en utilisant l'approche suivante dans sa définition de classe :

[JsonConverter(typeof(SingleValueArrayConverter<Address>))]
public List<Address> Location { get; set; }

Et mis en œuvre comme :

public class SingleValueArrayConverter<T> : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        object retVal = new Object();
        if (reader.TokenType == JsonToken.StartObject)
        {
            T instance = (T)serializer.Deserialize(reader, typeof(T));
            retVal = new List<T>() { instance };
        }
        else if (reader.TokenType == JsonToken.StartArray)
        {
            retVal = serializer.Deserialize(reader, objectType);
        }
        return retVal;
    }

    public override bool CanConvert(Type objectType)
    {
        return true;
    }
}

Cependant, je n'arrive pas à résoudre ce problème. Quelqu'un peut-il aider?

Vous pouvez gérer cette incohérence avec a JsonConverteraussi. Ce sera un peu différent de celui que vous avez, mais l'idée est très similaire :

public class ArrayOrWrappedArrayConverter<T> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(List<T>).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JToken token = JToken.Load(reader);
        if (token.Type == JTokenType.Array)
        {
            return CreateListFromJArray((JArray)token, serializer);
        }
        if (token.Type == JTokenType.Object)
        {
            JObject wrapper = (JObject)token;
            JProperty prop = wrapper.Properties().FirstOrDefault();
            if (prop.Value.Type == JTokenType.Array)
            {
                return CreateListFromJArray((JArray)prop.Value, serializer);
            }
        }
        // If the JSON is not what we expect, just return an empty list.
        // (Could return null or throw an exception here instead if desired.)
        return new List<T>();
    }

    private List<T> CreateListFromJArray(JArray array, JsonSerializer serializer)
    {
        List<T> list = new List<T>();
        serializer.Populate(array.CreateReader(), list);
        return list;
    }

    public override bool CanWrite => false;

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

Ajoutez simplement le convertisseur à votre Rolespropriété et vous devriez être prêt à partir :

[JsonProperty("roles")]
[JsonConverter(typeof(ArrayOrWrappedArrayConverter<Role>))]
public List<Role> Roles { get; set; }

Démonstration de travail :https://dotnetfiddle.net/F6qgQB

le moyen le plus simple (pas nécessairement le plus propre) serait de modifier manuellement la chaîne avant de désérialiser -

jsonString = jsonString.replace("\"roles\": {", "\"rolesContainer\": {");
jsonString = jsonString.replace("\"roles\":{", "\"rolesContainer\": {");

puis dans votre code principal, vous auriez à la fois des rôlesContainer et des rôles en tant que champs - puis les fusionner après

public List<Role> roles { get; set; }
public RoleContainer rolesContainer { get; set; }
public class RoleContainer {
    Public List<Role> roles;
}

c'est sale, mais ça devrait marcher