web-dev-qa-db-fra.com

Sérialiser une liste en JSON

J'ai un modèle d'objet qui ressemble à ceci:

public MyObjectInJson
{
   public long ObjectID {get;set;}
   public string ObjectInJson {get;set;}
}

La propriété ObjectInJson est une version déjà sérialisée d'un objet contenant des listes imbriquées. Pour le moment, je sérialise la liste de MyObjectInJson manuellement comme ceci:

StringBuilder TheListBuilder = new StringBuilder();

TheListBuilder.Append("[");
int TheCounter = 0;

foreach (MyObjectInJson TheObject in TheList)
{
  TheCounter++;
  TheListBuilder.Append(TheObject.ObjectInJson);

  if (TheCounter != TheList.Count())
  {
    TheListBuilder.Append(",");
  }
}
TheListBuilder.Append("]");

return TheListBuilder.ToString();

Je me demande si je peux remplacer ce type de code dangereux par JavascriptSerializer et obtenir les mêmes résultats. Comment je ferais ça?

Merci.

c#asp.netjson
164
frenchie
// you need to reference System.Web.Extensions

using System.Web.Script.Serialization;

var jsonSerialiser = new JavaScriptSerializer();
var json = jsonSerialiser.Serialize(aList);

Remarque:

Les temps ont changé, j’utilisais par défaut JSON.Net comme premier analyseur JSON. Si c'est le bon choix pour WebAPI, c'est le bon choix pour moi.

par exemple.

using Newtonsoft.Json;

var json = JsonConvert.SerializeObject(aList);

vous devrez peut-être d'abord installer le paquet.

PM> Install-Package Newtonsoft.Json

Pour plus de détails voir et contrôler la réponse qui est la source de cette information .

303
Jodrell

Vous pouvez également utiliser Json.NET. Il suffit de le télécharger sur le site http://james.newtonking.com/pages/json-net.aspx , d'extraire le fichier compressé et de l'ajouter comme référence.

Ensuite, il suffit de sérialiser la liste (ou l'objet de votre choix) avec les éléments suivants:

using Newtonsoft.Json;

string json = JsonConvert.SerializeObject(listTop10);

Mise à jour: vous pouvez également l'ajouter à votre projet via le gestionnaire de paquets NuGet (Outils -> Gestionnaire de paquets NuGet -> Console du gestionnaire de paquets):

PM> Install-Package Newtonsoft.Json

Documentation: Sérialisation des collections

106
Brent Barbata

Il existe deux manières courantes de le faire avec les sérialiseurs JSON intégrés:

  1. JavaScriptSerializer

    var serializer = new JavaScriptSerializer();
return serializer.Serialize(TheList);

  2. DataContractJsonSerializer

    var serializer = new DataContractJsonSerializer(TheList.GetType());
using (var stream = new MemoryStream())
{
    serializer.WriteObject(stream, TheList);
    using (var sr = new StreamReader(stream))
    {
        return sr.ReadToEnd();
    }
}

    Notez que cette option nécessite la définition d'un contrat de données pour votre classe:

    [DataContract]
public class MyObjectInJson
{
   [DataMember]
   public long ObjectID {get;set;}
   [DataMember]
   public string ObjectInJson {get;set;}
}
11
Joulukuusi
public static string JSONSerialize<T>(T obj)
        {
            string retVal = String.Empty;
            using (MemoryStream ms = new MemoryStream())
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
                serializer.WriteObject(ms, obj);
                var byteArray = ms.ToArray();
                retVal = Encoding.UTF8.GetString(byteArray, 0, byteArray.Length);
            }
            return retVal;
        }
5
samsanthosh2008

.NET prend déjà en charge la sérialisation Json de base via la classe espace de noms System.Runtime.Serialization.Json et la classe DataContractJsonSerializer depuis la version 3.5. Comme son nom l'indique, DataContractJsonSerializer prend en compte les annotations de données que vous ajoutez à vos objets pour créer la sortie Json finale.

Cela peut être pratique si vous avez déjà des classes de données annotées que vous souhaitez sérialiser Json en un flux, comme décrit dans la section Procédure: sérialiser et désérialiser des données JSON . Il y a des limitations, mais c'est assez bon et assez rapide si vous avez des besoins de base et que vous ne voulez pas ajouter Yet Another Library à votre projet.

Le code suivant sérialisait une liste dans le flux de sortie de la console. Comme vous le voyez, il s'agit d'un bit plus détaillé que Json.NET et non conforme au type (c'est-à-dire, aucun générique).

        var list = new List<string> {"a", "b", "c", "d"};

        using(var output = Console.OpenStandardOutput())                
        {                
            var writer = new DataContractJsonSerializer(typeof (List<string>));
            writer.WriteObject(output,list);
        }

D'autre part, Json.NET permet de contrôler beaucoup mieux la façon dont vous générez Json. Cela sera très pratique lorsque vous devrez mapper des noms compatibles avec le javascript aux classes .NET, formater les dates au format json, etc.

Une autre option est ServiceStack.Text , composant de la pile ServicStack ..., qui fournit un ensemble de sérialiseurs très rapides pour Json, JSV et CSV.

4
Panagiotis Kanavos

je me suis inspiré de la réponse dynamique avec Json.NET version 12.x.

using Newtonsoft.Json;

static class JsonObj
{
    /// <summary>
    /// Deserializes a json file into an object list
    /// Author: Joseph Poirier 2/26/2019
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="fileName"></param>
    /// <returns></returns>
    public static List<T> DeSerializeObject<T>(string fileName)
    {
        List<T> objectOut = new List<T>();

        if (string.IsNullOrEmpty(fileName)) { return objectOut; }

        try
        {
            // reading in full file as text
            string ss = File.ReadAllText(fileName);

            // went with <dynamic> over <T> or <List<T>> to avoid error..
            //  unexpected character at line 1 column 2
            var output = JsonConvert.DeserializeObject<dynamic>(ss);

            foreach (var Record in output)
            {
                foreach (T data in Record)
                {
                    objectOut.Add(data);
                }
            }
        }
        catch (Exception ex)
        {
            //Log exception here
            Console.Write(ex.Message);
        }

        return objectOut;
    }
}

appel à traiter

{
        string fname = "../../Names.json"; // <- your json file path

        // for alternate types replace string with custom class below
        List<string> jsonFile = JsonObj.DeSerializeObject<string>(fname);
}

ou cet appel à traiter

{
        string fname = "../../Names.json"; // <- your json file path

        // for alternate types replace string with custom class below
        List<string> jsonFile = new List<string>();
        jsonFile.AddRange(JsonObj.DeSerializeObject<string>(fname));
}
0
Joseph Poirier