Comment gérer à la fois un élément unique et un tableau pour la même propriété à l'aide de JSON.net

La meilleure façon de gérer cette situation est d'utiliser un JsonConverter.

Avant de nous rendre à la convertisseur, nous avons besoin de définir une classe pour désérialiser les données. Pour le Categories propriété qui peut varier entre un élément unique et un tableau, le définir comme un List<string> et de marquer avec un [JsonConverter] attribut de sorte que JSON.Net saurez utiliser le convertisseur personnalisé pour cette propriété. Je vous recommande également à l'aide de [JsonProperty] attributs de sorte que les propriétés de membre ne peut être donnée des noms significatifs indépendant de ce qui est défini dans le JSON.

class Item
{
    [JsonProperty("email")]
    public string Email { get; set; }

    [JsonProperty("timestamp")]
    public int Timestamp { get; set; }

    [JsonProperty("event")]
    public string Event { get; set; }

    [JsonProperty("category")]
    [JsonConverter(typeof(SingleOrArrayConverter<string>))]
    public List<string> Categories { get; set; }
}

Ici est de savoir comment je voudrais mettre en œuvre le convertisseur. Notez que j'ai fait le convertisseur générique, de sorte qu'il peut être utilisé avec des chaînes ou d'autres types d'objets que nécessaire.

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JToken token = JToken.Load(reader);
        if (token.Type == JTokenType.Array)
        {
            return token.ToObject<List<T>>();
        }
        return new List<T> { token.ToObject<T>() };
    }

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

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

Voici un court programme de démonstration le convertisseur dans l'action avec vos données d'échantillonnage:

class Program
{
    static void Main(string[] args)
    {
        string json = @"
        [
          {
            ""email"": ""[email protected]"",
            ""timestamp"": 1337966815,
            ""category"": [
              ""newuser"",
              ""transactional""
            ],
            ""event"": ""open""
          },
          {
            ""email"": ""[email protected]"",
            ""timestamp"": 1337966815,
            ""category"": ""olduser"",
            ""event"": ""open""
          }
        ]";

        List<Item> list = JsonConvert.DeserializeObject<List<Item>>(json);

        foreach (Item obj in list)
        {
            Console.WriteLine("email: " + obj.Email);
            Console.WriteLine("timestamp: " + obj.Timestamp);
            Console.WriteLine("event: " + obj.Event);
            Console.WriteLine("categories: " + string.Join(", ", obj.Categories));
            Console.WriteLine();
        }
    }
}

Et enfin, voici la sortie de la ci-dessus:

email: [email protected]
timestamp: 1337966815
event: open
categories: newuser, transactional

email: [email protected]
timestamp: 1337966815
event: open
categories: olduser

Violon: https://dotnetfiddle.net/lERrmu

MODIFIER

Si vous avez besoin d'aller dans l'autre sens, c'est à dire sérialiser, tout en gardant le même format, vous pouvez mettre en œuvre la WriteJson() méthode du convertisseur, comme illustré ci-dessous. (Assurez-vous de retirer le CanWrite de remplacer ou de le changer pour revenir true, ou d'autre WriteJson() ne sera jamais appelé.)

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        List<T> list = (List<T>)value;
        if (list.Count == 1)
        {
            value = list[0];
        }
        serializer.Serialize(writer, value);
    }

Violon: https://dotnetfiddle.net/XG3eRy

OriginalL'auteur Brian Rogers

J'ai eu un Problème similaire.
Mon Json Demande a été complètement inconnu pour moi.
Je ne savais que le.

Il y aura un objectId en elle et quelques anonym paires clé-valeur ET les tableaux.

Je l'ai utilisé pour un Modèle EAV j'ai fait:

Mon JSON Demande:

{objectId": 2,
"firstName": "Hans",
"e-mail" :[ "[email protected]","[email protected]"],
"nom": "André",
"quelque chose" :["232","123"]
}

Ma Classe j'ai défini:

[JsonConverter(typeof(AnonyObjectConverter))]
public class AnonymObject
{
    public AnonymObject()
    {
        fields = new Dictionary<string, string>();
        list = new List<string>();
    }

    public string objectid { get; set; }
    public Dictionary<string, string> fields { get; set; }
    public List<string> list { get; set; }
}

et maintenant que je veux désérialiser les attributs inconnus avec sa valeur et des tableaux dans mon Convertisseur ressemble à ça:

   public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
AnonymObject anonym = existingValue as AnonymObject ?? new AnonymObject();
bool isList = false;
StringBuilder listValues = new StringBuilder();
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndObject) continue;
if (isList)
{
while (reader.TokenType != JsonToken.EndArray)
{
listValues.Append(reader.Value.ToString() + ", ");
reader.Read();
}
anonym.list.Add(listValues.ToString());
isList = false;
continue;
}
var value = reader.Value.ToString();
switch (value.ToLower())
{
case "objectid":
anonym.objectid = reader.ReadAsString();
break;
default:
string val;
reader.Read();
if(reader.TokenType == JsonToken.StartArray)
{
isList = true;
val = "ValueDummyForEAV";
}
else
{
val = reader.Value.ToString();
}
try
{
anonym.fields.Add(value, val);
}
catch(ArgumentException e)
{
throw new ArgumentException("Multiple Attribute found");
}
break;
}
}
return anonym;
}

Alors maintenant, chaque fois que je reçois un AnonymObject je peux parcourir le Dictionnaire et à chaque fois il y a mon Drapeau "ValueDummyForEAV" - je passer à la liste, à lire la première ligne et de diviser les valeurs. Après cela, j'ai supprimer le premier élément de la liste et aller à l'itération à partir du Dictionnaire.

Peut-être quelqu'un a le même problème et peut l'utiliser 🙂

Ce qui concerne
André

OriginalL'auteur Andre Fritzsche

Comme une variation mineure de la grande réponse par Brian Rogers, voici deux versions remaniées de SingleOrArrayConverter<T>.

Tout d'abord, voici une version qui fonctionne pour tous les List<T> pour chaque type de T qui n'est pas lui-même une collection:

public class SingleOrArrayListConverter : JsonConverter
{
//Adapted from this answer https://stackoverflow.com/a/18997172
//to https://stackoverflow.com/questions/18994685/how-to-handle-both-a-single-item-and-an-array-for-the-same-property-using-json-n
//by Brian Rogers https://stackoverflow.com/users/10263/brian-rogers
readonly bool canWrite;
readonly IContractResolver resolver;
public SingleOrArrayListConverter() : this(false) { }
public SingleOrArrayListConverter(bool canWrite) : this(canWrite, null) { }
public SingleOrArrayListConverter(bool canWrite, IContractResolver resolver)
{
this.canWrite = canWrite;
//Use the global default resolver if none is passed in.
this.resolver = resolver ?? new JsonSerializer().ContractResolver;
}
static bool CanConvert(Type objectType, IContractResolver resolver)
{
Type itemType;
JsonArrayContract contract;
return CanConvert(objectType, resolver, out itemType, out contract);
}
static bool CanConvert(Type objectType, IContractResolver resolver, out Type itemType, out JsonArrayContract contract)
{
if ((itemType = objectType.GetListItemType()) == null)
{
itemType = null;
contract = null;
return false;
}
//Ensure that [JsonObject] is not applied to the type.
if ((contract = resolver.ResolveContract(objectType) as JsonArrayContract) == null)
return false;
var itemContract = resolver.ResolveContract(itemType);
//Not implemented for jagged arrays.
if (itemContract is JsonArrayContract)
return false;
return true;
}
public override bool CanConvert(Type objectType) { return CanConvert(objectType, resolver); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
Type itemType;
JsonArrayContract contract;
if (!CanConvert(objectType, serializer.ContractResolver, out itemType, out contract))
throw new JsonSerializationException(string.Format("Invalid type for {0}: {1}", GetType(), objectType));
if (reader.MoveToContent().TokenType == JsonToken.Null)
return null;
var list = (IList)(existingValue ?? contract.DefaultCreator());
if (reader.TokenType == JsonToken.StartArray)
serializer.Populate(reader, list);
else
//Here we take advantage of the fact that List<T> implements IList to avoid having to use reflection to call the generic Add<T> method.
list.Add(serializer.Deserialize(reader, itemType));
return list;
}
public override bool CanWrite { get { return canWrite; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var list = value as ICollection;
if (list == null)
throw new JsonSerializationException(string.Format("Invalid type for {0}: {1}", GetType(), value.GetType()));
//Here we take advantage of the fact that List<T> implements IList to avoid having to use reflection to call the generic Count method.
if (list.Count == 1)
{
foreach (var item in list)
{
serializer.Serialize(writer, item);
break;
}
}
else
{
writer.WriteStartArray();
foreach (var item in list)
serializer.Serialize(writer, item);
writer.WriteEndArray();
}
}
}
public static partial class JsonExtensions
{
public static JsonReader MoveToContent(this JsonReader reader)
{
while ((reader.TokenType == JsonToken.Comment || reader.TokenType == JsonToken.None) && reader.Read())
;
return reader;
}
internal static Type GetListItemType(this Type type)
{
//Quick reject for performance
if (type.IsPrimitive || type.IsArray || type == typeof(string))
return null;
while (type != null)
{
if (type.IsGenericType)
{
var genType = type.GetGenericTypeDefinition();
if (genType == typeof(List<>))
return type.GetGenericArguments()[0];
}
type = type.BaseType;
}
return null;
}
}

Il peut être utilisé comme suit:

var settings = new JsonSerializerSettings
{
//Pass true if you want single-item lists to be reserialized as single items
Converters = { new SingleOrArrayListConverter(true) },
};
var list = JsonConvert.DeserializeObject<List<Item>>(json, settings);

Notes:

• Le convertisseur évite la nécessité de pré-charger l'intégralité de la valeur JSON dans la mémoire comme un JToken hiérarchie.

• Le convertisseur ne s'applique pas aux listes dont les éléments sont également sérialisé que les collections, par exemple List<string []>

• Le Booléen canWrite argument passé au constructeur décide de re-sérialiser un seul élément des listes de JSON valeurs ou JSON tableaux.

• Du convertisseur ReadJson() utilise le existingValue si la pré-alloué de manière à soutenir la population d'obtenir uniquement les membres de la liste.

Deuxièmement, voici une version qui fonctionne avec d'autres génériques de collections telles que ObservableCollection<T>:

public class SingleOrArrayCollectionConverter<TCollection, TItem> : JsonConverter
where TCollection : ICollection<TItem>
{
//Adapted from this answer https://stackoverflow.com/a/18997172
//to https://stackoverflow.com/questions/18994685/how-to-handle-both-a-single-item-and-an-array-for-the-same-property-using-json-n
//by Brian Rogers https://stackoverflow.com/users/10263/brian-rogers
readonly bool canWrite;
public SingleOrArrayCollectionConverter() : this(false) { }
public SingleOrArrayCollectionConverter(bool canWrite) { this.canWrite = canWrite; }
public override bool CanConvert(Type objectType)
{
return typeof(TCollection).IsAssignableFrom(objectType);
}
static void ValidateItemContract(IContractResolver resolver)
{
var itemContract = resolver.ResolveContract(typeof(TItem));
if (itemContract is JsonArrayContract)
throw new JsonSerializationException(string.Format("Item contract type {0} not supported.", itemContract));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
ValidateItemContract(serializer.ContractResolver);
if (reader.MoveToContent().TokenType == JsonToken.Null)
return null;
var list = (ICollection<TItem>)(existingValue ?? serializer.ContractResolver.ResolveContract(objectType).DefaultCreator());
if (reader.TokenType == JsonToken.StartArray)
serializer.Populate(reader, list);
else
list.Add(serializer.Deserialize<TItem>(reader));
return list;
}
public override bool CanWrite { get { return canWrite; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
ValidateItemContract(serializer.ContractResolver);
var list = value as ICollection<TItem>;
if (list == null)
throw new JsonSerializationException(string.Format("Invalid type for {0}: {1}", GetType(), value.GetType()));
if (list.Count == 1)
{
foreach (var item in list)
{
serializer.Serialize(writer, item);
break;
}
}
else
{
writer.WriteStartArray();
foreach (var item in list)
serializer.Serialize(writer, item);
writer.WriteEndArray();
}
}
}

Ensuite, si votre modèle à l'aide, par exemple, un ObservableCollection<T> pour certains T, vous pouvez l'appliquer comme suit:

class Item
{
public string Email { get; set; }
public int Timestamp { get; set; }
public string Event { get; set; }
[JsonConverter(typeof(SingleOrArrayCollectionConverter<ObservableCollection<string>, string>))]
public ObservableCollection<string> Category { get; set; }
}

Notes:

• En plus des notes et des restrictions pour SingleOrArrayListConverter, le TCollection type doit être en lecture/écriture et d'avoir un constructeur sans paramètre.

De démonstration de jouer avec l'unité de base des tests de ici.

OriginalL'auteur dbc