.NET Framework
Serializzazione JSON

Osservazioni

Deserializzazione tramite System.Web.Script.Serialization.JavaScriptSerializer

Il metodo JavaScriptSerializer.Deserialize<T>(input) tenta di deserializzare una stringa di JSON valido in un oggetto del tipo specificato <T> , utilizzando i mapping predefiniti supportati nativamente da JavaScriptSerializer .

using System.Collections;
using System.Web.Script.Serialization;

// ...

string rawJSON = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";

JavaScriptSerializer JSS = new JavaScriptSerializer(); 
Dictionary<string, object> parsedObj = JSS.Deserialize<Dictionary<string, object>>(rawJSON);

string name = parsedObj["Name"].toString();
ArrayList numbers = (ArrayList)parsedObj["Numbers"]

Nota: l'oggetto JavaScriptSerializer stato introdotto in .NET versione 3.5

Deserializzazione con Json.NET

internal class Sequence{
    public string Name;
    public List<int> Numbers;
}    

// ...

string rawJSON = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";

Sequence sequence = JsonConvert.DeserializeObject<Sequence>(rawJSON);

Per ulteriori informazioni, consultare il sito ufficiale Json.NET .

Nota: Json.NET supporta .NET versione 2 e successive.

Serializzazione con Json.NET

[JsonObject("person")]
public class Person
{
    [JsonProperty("name")]
    public string PersonName { get; set; }
    [JsonProperty("age")]
    public int PersonAge { get; set; }
    [JsonIgnore]
    public string Address { get; set; }
}

Person person = new Person { PersonName = "Andrius", PersonAge = 99, Address = "Some address" };
string rawJson = JsonConvert.SerializeObject(person);

Console.WriteLine(rawJson); // {"name":"Andrius","age":99}

Si noti come le proprietà (e le classi) possono essere decorate con attributi per cambiare il loro aspetto nella stringa json risultante o per rimuoverli da json string a tutti (JsonIgnore).

Ulteriori informazioni sugli attributi di serializzazione Json.NET possono essere trovate qui .

In C #, gli identificatori pubblici sono scritti in PascalCase per convenzione. In JSON, la convenzione è usare CamelCase per tutti i nomi. È possibile utilizzare un resolver di contratto per convertire tra i due.

using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    [JsonIgnore]
    public string Address { get; set; }
}

public void ToJson() {
    Person person = new Person { Name = "Andrius", Age = 99, Address = "Some address" };
    var resolver = new CamelCasePropertyNamesContractResolver();
    var settings = new JsonSerializerSettings { ContractResolver = resolver };
    string json = JsonConvert.SerializeObject(person, settings);

    Console.WriteLine(json); // {"name":"Andrius","age":99}
}

Serializzazione-Deserializzazione usando Newtonsoft.Json

A differenza degli altri helper, questo usa gli helper di classe statici per serializzare e deserializzare, quindi è un po 'più semplice degli altri da usare.

using Newtonsoft.Json;

var rawJSON      = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
var fibo         = JsonConvert.DeserializeObject<Dictionary<string, object>>(rawJSON);
var rawJSON2     = JsonConvert.SerializeObject(fibo);

Associazione dinamica

Json.NET di Newtonsoft ti permette di legare json in modo dinamico (usando ExpandoObject / oggetti dinamici) senza la necessità di creare il tipo esplicitamente.

serializzazione

dynamic jsonObject = new ExpandoObject();
jsonObject.Title   = "Merchent of Venice";
jsonObject.Author  = "William Shakespeare";
Console.WriteLine(JsonConvert.SerializeObject(jsonObject));

De-serializzazione

var rawJson = "{\"Name\":\"Fibonacci Sequence\",\"Numbers\":[0, 1, 1, 2, 3, 5, 8, 13]}";
dynamic parsedJson = JObject.Parse(rawJson);
Console.WriteLine("Name: " + parsedJson.Name);
Console.WriteLine("Name: " + parsedJson.Numbers.Length);

Si noti che le chiavi nell'oggetto rawJson sono state trasformate in variabili membro nell'oggetto dinamico.

Ciò è utile nei casi in cui un'applicazione può accettare / produrre diversi formati di JSON. Si consiglia comunque di utilizzare un ulteriore livello di convalida per la stringa Json o per l'oggetto dinamico generato come risultato della serializzazione / de-serializzazione.

Serializzazione tramite Json.NET con JsonSerializerSettings

Questo serializzatore ha alcune caratteristiche interessanti che il serializzatore json predefinito non ha, come la gestione del valore Null, devi solo creare JsonSerializerSettings :

public static string Serialize(T obj)
{
   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore});
   return result;
}

Un altro problema serio di serializzazione in .net è il loop autoreferenziale. Nel caso di uno studente iscritto a un corso, la sua istanza ha una proprietà del corso e un corso ha una raccolta di studenti che significa una List<Student> che creerà un ciclo di riferimento. Puoi gestirlo con JsonSerializerSettings :

public static string Serialize(T obj)
{
   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore});
   return result;
}

Puoi mettere varie opzioni di serializzazione come questa:

public static string Serialize(T obj)
{
   string result = JsonConvert.SerializeObject(obj, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, ReferenceLoopHandling = ReferenceLoopHandling.Ignore});
   return result;
}