.NET Framework
Serializacja JSON

Uwagi

Deserializacja za pomocą System.Web.Script.Serialization.JavaScriptSerializer

Metoda JavaScriptSerializer.Deserialize<T>(input) próbuje przekształcić ciąg prawidłowego JSON w obiekt określonego typu <T> , używając domyślnych odwzorowań natywnie obsługiwanych przez 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"]

Uwaga: Obiekt JavaScriptSerializer został wprowadzony w .NET w wersji 3.5

Deserializacja za pomocą 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);

Więcej informacji można znaleźć na oficjalnej stronie Json.NET .

Uwaga: Json.NET obsługuje .NET w wersji 2 i wyższej.

Serializacja przy użyciu 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}

Zwróć uwagę, jak właściwości (i klasy) można dekorować atrybutami, aby zmienić ich wygląd w wynikowym łańcuchu json lub w ogóle usunąć je z łańcucha json (JsonIgnore).

Więcej informacji o atrybutach serializacji Json.NET można znaleźć tutaj .

W języku C # identyfikatory publiczne są zapisywane w PascalCase zgodnie z konwencją. W JSON konwencja polega na użyciu camelCase dla wszystkich nazw. Możesz użyć narzędzia do rozwiązywania umów, aby dokonać konwersji między nimi.

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}
}

Serializacja-deserializacja za pomocą Newtonsoft.Json

W przeciwieństwie do innych pomocników, ten korzysta z pomocników klasy statycznej do serializacji i deserializacji, dlatego jest nieco łatwiejszy w użyciu niż inne.

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);

Dynamiczne wiązanie

Json.NET firmy Newtonsoft umożliwia dynamiczne wiązanie jsona (przy użyciu obiektów ExpandoObject / Dynamic) bez potrzeby jawnego tworzenia typu.

Serializacja

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

Dezeralizacja

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);

Zauważ, że klucze w obiekcie rawJson zostały zamienione na zmienne składowe w obiekcie dynamicznym.

Jest to przydatne w przypadkach, w których aplikacja może akceptować / produkować różne formaty JSON. Sugeruje się jednak użycie dodatkowego poziomu sprawdzania poprawności dla ciągu Json lub do obiektu dynamicznego wygenerowanego w wyniku serializacji / deserializacji.

Serializacja przy użyciu Json.NET z JsonSerializerSettings

Ten serializator ma kilka fajnych funkcji, których nie ma domyślny serializator json .net, takich jak obsługa wartości Null, wystarczy utworzyć JsonSerializerSettings :

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

Kolejnym poważnym problemem związanym z serializatorem w .net jest pętla samo-referencyjna. W przypadku ucznia zapisanego na kurs jego instancja ma właściwość kursu, a kurs ma kolekcję studentów, co oznacza List<Student> która utworzy pętlę referencyjną. Możesz sobie z tym poradzić za pomocą JsonSerializerSettings :

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

Możesz umieścić różne opcje serializacji takie jak to:

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