Comment sérialiser / désérialiser une collection personnalisée avec des propriétés supplémentaires à l'aide de Json.Net

J'ai une collection personnalisée (implémente IList) qui a certaines propriétés personnalisées comme indiqué ci-dessous:

class FooCollection : IList<Foo> {

    private List<Foo> _foos = new List<Foo>();
    public string Bar { get; set; }        

    //Implement IList, ICollection and IEnumerable members...

}

Quand je sérialiser, j'utilise le code suivant:

JsonSerializerSettings jss = new JsonSerializerSettings() {
    TypeNameHandling = TypeNameHandling.Auto
};
string serializedCollection = JsonConvert.SerializeObject( value , jss );

Il sérialise et désérialise tous les articles de la collection correctement; cependant, toutes les propriétés supplémentaires dans le FooCollection de classe ne sont pas prises en compte.

Est-il de toute façon à l'inclure dans la sérialisation?

source d'informationauteur Pierluc SS

.net c#json json.net serialization

Le problème est le suivant: lorsqu'un objet implémente IEnumerableJSON.net l'identifie comme un tableau de valeurs et sérialise suivant le tableau La syntaxe Json (qui n'inclut pas les propriétés),
par exemple :

 [ {"FooProperty" : 123}, {"FooProperty" : 456}, {"FooProperty" : 789}]

Si vous voulez sérialiser en gardant les propriétés, vous devez gérer la sérialisation de l'objet à la main par la définition d'un personnalisé JsonConverter :

//intermediate class that can be serialized by JSON.net
//and contains the same data as FooCollection
class FooCollectionSurrogate
{
    //the collection of foo elements
    public List<Foo> Collection { get; set; }
    //the properties of FooCollection to serialize
    public string Bar { get; set; }
}

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

    public override object ReadJson(
        JsonReader reader, Type objectType, 
        object existingValue, JsonSerializer serializer)
    {
        //N.B. null handling is missing
        var surrogate = serializer.Deserialize<FooCollectionSurrogate>(reader);
        var fooElements = surrogate.Collection;
        var fooColl = new FooCollection { Bar = surrogate.Bar };
        foreach (var el in fooElements)
            fooColl.Add(el);
        return fooColl;
    }

    public override void WriteJson(JsonWriter writer, object value, 
                                   JsonSerializer serializer)
    {
        //N.B. null handling is missing
        var fooColl = (FooCollection)value;
        //create the surrogate and serialize it instead 
        //of the collection itself
        var surrogate = new FooCollectionSurrogate() 
        { 
            Collection = fooColl.ToList(), 
            Bar = fooColl.Bar 
        };
        serializer.Serialize(writer, surrogate);
    }
}

De l'utiliser ensuite comme suit:

var ss = JsonConvert.SerializeObject(collection, new FooCollectionConverter());

var obj = JsonConvert.DeserializeObject<FooCollection>(ss, new FooCollectionConverter());

7

Personnellement, j'aime bien éviter d'écrire personnalisé JsonConverters si possible, et au lieu d'utiliser les différentes JSON attributs qui ont été conçus à cette fin. Vous pouvez tout simplement décorer FooCollection avec JsonObjectAttributeoù les forces de sérialisation comme un objet JSON plutôt qu'un tableau. Vous devez décorer la Count et IsReadOnly propriétés avec JsonIgnore pour les empêcher d'apparaître dans la sortie. Si vous voulez garder _foos un domaine privé, vous devez également avoir à le décorer avec des JsonProperty.
```
[JsonObject]
class FooCollection : IList<Foo> {
    [JsonProperty]
    private List<Foo> _foos = new List<Foo>();
    public string Bar { get; set; }  

    //IList implementation
    [JsonIgnore]
    public int Count { ... }
    [JsonIgnore]
    public bool IsReadOnly { ... }
}
```
La sérialisation des rendements quelque chose comme ce qui suit:
```
{
  "_foos": [
    "foo1",
    "foo2"
  ],
  "Bar": "bar"
}
```
Évidemment, cela ne fonctionne que si vous êtes en mesure de modifier la définition de FooCollection afin d'ajouter ces attributs, sinon, vous devrez aller dans le sens de la coutume convertisseurs.

N'héritant de la Liste de travail?

class FooCollection : List<Foo>, IList<Foo>
{
    public string Bar { get; set; }        
    //Implement IList, ICollection and IEnumerable members...
}

Si vous aussi vous souhaitez conserver le contenu de la Liste ou de la collection elle-même,
Vous pourriez envisager d'exposer le retour du bien de la liste. Il convient de papier pour éviter cyclique problème lors de la sérialisation:

[JsonObject]
public class FooCollection : List<int>
{
    [DataMember]
    public string Bar { get; set; } = "Bar";
    public ICollection<int> Items => new _<int>(this);
}

public class _<T> : ICollection<T>
{
    public _(ICollection<T> collection) => Inner = collection;    
    public ICollection<T> Inner { get; }    
    public int Count => this.Inner.Count;    
    public bool IsReadOnly => this.Inner.IsReadOnly;    
    public void Add(T item) => this.Inner.Add(item);    
    public void Clear() => this.Inner.Clear();    
    public bool Contains(T item) => this.Inner.Contains(item);    
    public void CopyTo(T[] array, int arrayIndex) => this.Inner.CopyTo(array, arrayIndex);    
    public IEnumerator<T> GetEnumerator()=> this.Inner.GetEnumerator();
    public bool Remove(T item) => this.Inner.Remove(item);    
    IEnumerator IEnumerable.GetEnumerator() => this.Inner.GetEnumerator();
}

new FooCollection { 1, 2, 3, 4, 4 } =>

{
  "Bar": "Bar",
  "Items": [
    1,
    2,
    3
  ],
  "Capacity": 4,
  "Count": 3
}

new FooCollection { 1, 2, 3 }.ToArray() => new []{1, 2, 3}.ToArray()

Vous devez vous connecter pour publier un commentaire.