.NET Framework
Serialización JSON

Observaciones

Deserialización utilizando System.Web.Script.Serialization.JavaScriptSerializer

El método JavaScriptSerializer.Deserialize<T>(input) intenta deserializar una cadena de JSON válida en un objeto del tipo especificado <T> , utilizando las asignaciones predeterminadas admitidas de forma nativa por 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: el objeto JavaScriptSerializer se introdujo en .NET versión 3.5

Deserialización utilizando 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);

Para obtener más información, consulte el sitio oficial de Json.NET .

Nota: Json.NET admite .NET versión 2 y superior.

Serialización utilizando 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}

Observe cómo las propiedades (y las clases) se pueden decorar con atributos para cambiar su apariencia en la cadena json resultante o para eliminarlas de la cadena json (JsonIgnore).

Puede encontrar más información sobre los atributos de serialización de Json.NET aquí .

En C #, los identificadores públicos se escriben en PascalCase por convención. En JSON, la convención es usar camelCase para todos los nombres. Puede utilizar un resolutor de contrato para convertir entre los dos.

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

Serialización-Deserialización utilizando Newtonsoft.Json

A diferencia de los otros ayudantes, este utiliza ayudantes de clase estática para serializar y deserializar, por lo que es un poco más fácil de usar que los demás.

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

Vinculación dinámica

Json.NET de Newtonsoft le permite enlazar json dinámicamente (utilizando objetos dinámicos / ExpandoObject) sin la necesidad de crear el tipo explícitamente.

Publicación por entregas

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

De serialización

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

Observe que las claves en el objeto rawJson se han convertido en variables miembro en el objeto dinámico.

Esto es útil en los casos en que una aplicación puede aceptar / producir diferentes formatos de JSON. Sin embargo, se sugiere utilizar un nivel adicional de validación para la cadena Json o para el objeto dinámico generado como resultado de la serialización / deserialización.

Serialización utilizando Json.NET con JsonSerializerSettings

Este serializador tiene algunas características interesantes que el serializador .net json predeterminado no tiene, como el manejo de valor nulo, solo necesita crear el JsonSerializerSettings :

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

Otro problema serio del serializador en .net es el bucle de referencia automática. En el caso de un estudiante que está inscrito en un curso, su instancia tiene una propiedad del curso y un curso tiene una colección de estudiantes que significa una List<Student> que creará un bucle de referencia. Puedes manejar esto con JsonSerializerSettings :

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

Puedes poner varias opciones de serializaciones como esta:

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