.NET Framework
JSON-Serialisierung

Bemerkungen

Deserialisierung mit System.Web.Script.Serialization.JavaScriptSerializer

Die JavaScriptSerializer.Deserialize<T>(input) -Methode JavaScriptSerializer.Deserialize<T>(input) versucht, eine Zeichenfolge gültiger JSON in ein Objekt des angegebenen Typs <T> zu deserialisieren, wobei die Standardzuordnungen verwendet werden, die von JavaScriptSerializer standardmäßig unterstützt werden.

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"]

Hinweis: Das JavaScriptSerializer Objekt wurde in .NET Version 3.5 eingeführt

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

Weitere Informationen finden Sie auf der offiziellen Website von Json.NET .

Hinweis: Json.NET unterstützt .NET Version 2 und höher.

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

Beachten Sie, wie Eigenschaften (und Klassen) mit Attributen versehen werden können, um ihr Erscheinungsbild in der resultierenden Json-Zeichenfolge zu ändern oder sie überhaupt aus der Json-Zeichenfolge zu entfernen (JsonIgnore).

Weitere Informationen zu Json.NET-Serialisierungsattributen finden Sie hier .

In C # werden öffentliche Bezeichner nach Konventionen in PascalCase geschrieben. In JSON ist es üblich, camelCase für alle Namen zu verwenden. Sie können einen Vertragsauflöser verwenden, um zwischen den beiden zu konvertieren.

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

Serialisierung-Deserialisierung mit Newtonsoft.Json

Im Gegensatz zu den anderen Helfern verwendet dieser Assistent statische Klassenhelfer zum Serialisieren und Deserialisieren. Daher ist es etwas einfacher als die anderen.

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 Bindung

Mit Json.NET von Newtonsoft können Sie Json dynamisch binden (mithilfe von ExpandoObject / Dynamic-Objekten), ohne dass Sie den Typ explizit erstellen müssen.

Serialisierung

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

De-Serialisierung

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

Beachten Sie, dass die Schlüssel im rawJson-Objekt im dynamischen Objekt in Member-Variablen umgewandelt wurden.

Dies ist in Fällen nützlich, in denen eine Anwendung unterschiedliche JSON-Formate akzeptieren / produzieren kann. Es wird jedoch empfohlen, eine zusätzliche Validierungsstufe für den Json-String oder für das als Ergebnis der Serialisierung / Deserialisierung generierte dynamische Objekt zu verwenden.

Serialisierung mit Json.NET mit JsonSerializerSettings

Dieser Serialisierer verfügt über einige nette Funktionen, die der standardmäßige .net json-Serialisierer nicht bietet. Wie bei der Nullwertverarbeitung müssen Sie lediglich die JsonSerializerSettings erstellen:

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

Ein weiteres ernstes Problem des Serializers in .net ist die selbstreferenzierende Schleife. Im Falle eines Studenten, der an einem Kurs angemeldet ist, verfügt seine Instanz über eine Kurseigenschaft und ein Kurs enthält eine Sammlung von Studenten, dh eine List<Student> die eine Referenzschleife erstellt. Sie können dies mit JsonSerializerSettings :

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

Sie können verschiedene Serialisierungsoptionen wie folgt setzen:

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