.NET Framework
JSON Serialisatie

Opmerkingen

Deserialisatie met behulp van System.Web.Script.Serialization.JavaScriptSerializer

De methode JavaScriptSerializer.Deserialize<T>(input) probeert een reeks geldige JSON te deserialiseren in een object van het opgegeven type <T> , met behulp van de standaardtoewijzingen die native worden ondersteund door 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"]

Opmerking: het JavaScriptSerializer object is geïntroduceerd in .NET-versie 3.5

Deserialisatie met behulp van 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);

Raadpleeg de officiële website van Json.NET voor meer informatie.

Opmerking: Json.NET ondersteunt .NET versie 2 en hoger.

Serialisatie met behulp van 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}

Merk op hoe eigenschappen (en klassen) kunnen worden versierd met attributen om hun uiterlijk in de resulterende json-string te wijzigen of om ze helemaal uit de json-string te verwijderen (JsonIgnore).

Meer informatie over Json.NET-serialisatiekenmerken vindt u hier .

In C # worden openbare identificatiegegevens volgens conventie in PascalCase geschreven. In JSON is de conventie om camelCase voor alle namen te gebruiken. U kunt een contractresolver gebruiken om tussen de twee te converteren.

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

Serialisatie-Deserialisatie met behulp van Newtonsoft.Json

In tegenstelling tot de andere helpers, gebruikt deze helpers van de statische klasse om te serialiseren en deserialiseren, vandaar dat het een beetje gemakkelijker is dan de andere om te gebruiken.

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

Dynamische binding

Met Json.NET van Newtonsoft kunt u json dynamisch binden (met ExpandoObject / Dynamic-objecten) zonder het type expliciet te hoeven maken.

serialization

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

De-serialisatie

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

Merk op dat de sleutels in het rawJson-object zijn omgezet in lidvariabelen in het dynamische object.

Dit is handig in gevallen waarin een toepassing verschillende JSON-indelingen kan accepteren / produceren. Er wordt echter voorgesteld om een extra validatieniveau te gebruiken voor de Json-string of voor het dynamische object dat wordt gegenereerd als gevolg van serialisatie / de-serialisatie.

Serialisatie met Json.NET met JsonSerializerSettings

Deze serializer heeft een aantal leuke functies die de standaard .net json serializer niet heeft, zoals Null value handling, je hoeft alleen de JsonSerializerSettings te maken:

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

Een ander serieus serienummerprobleem in .net is de zelfverwijzingslus. In het geval van een student die is ingeschreven voor een cursus, heeft zijn instantie een cursuseigenschap en heeft een cursus een verzameling studenten, wat een List<Student> die een referentielus zal creëren. Je kunt dit aan met JsonSerializerSettings :

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

U kunt verschillende serialisaties als volgt plaatsen:

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