Cómo convertir objeto JSON a objeto C # personalizado?

Ya que todos amamos uno liners code

Newtonsoft es más rápido que java script serializer. ... este depende del paquete NuGet de Newtonsoft, que es popular y mejor que el serializador predeterminado.

Si tenemos clase entonces use abajo.

Mycustomclassname oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<Mycustomclassname>(Json Object);

No hay clase entonces use dinámico

var oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(Json Object);

Para mantener sus opciones abiertas, si está utilizando.NET 3.5 o posterior, aquí hay un ejemplo resumido que puede usar directamente desde el marco utilizando Genéricos. Como otros han mencionado, si no son solo objetos simples, realmente debe usar JSON.net.

public static string Serialize<T>(T obj)
{
    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
    MemoryStream ms = new MemoryStream();
    serializer.WriteObject(ms, obj);
    string retVal = Encoding.UTF8.GetString(ms.ToArray());
    return retVal;
}

public static T Deserialize<T>(string json)
{
    T obj = Activator.CreateInstance<T>();
    MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
    obj = (T)serializer.ReadObject(ms);
    ms.Close();
    return obj;
}

Necesitarás:

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

Dado su ejemplo de código, no debería tener que hacer nada más.

Si pasa esa cadena JSON a su método web, analizará automáticamente la cadena JSON y creará un objeto de usuario rellenado como parámetro para su método SaveTeam.

En general, sin embargo, puede usar la clase JavascriptSerializer como se muestra a continuación, o para mayor flexibilidad, use cualquiera de los diversos marcos Json que existen (Jayrock JSON es bueno) para una fácil manipulación de JSON.

 JavaScriptSerializer jss= new JavaScriptSerializer();
 User user = jss.Deserialize<User>(jsonResponse); 

Otra Solución realmente simple es usar la biblioteca Newtonsoft.Json:

User user = JsonConvert.DeserializeObject<User>(jsonString);

Los siguientes 2 ejemplos hacen uso de

1. JavaScriptSerializerbajo System.Web.Script.Serialización O
2. Json.Decodificar en el sistema .Web.Helpers

Ejemplo 1: usando System.Web.Script.Serialización

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void Test()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            dynamic jsonObject = serializer.Deserialize<dynamic>(json);

            dynamic x = jsonObject["user"]; // result is Dictionary<string,object> user with fields name, teamname, email and players with their values
            x = jsonObject["user"]["name"]; // result is asdf
            x = jsonObject["user"]["players"]; // result is object[] players with its values
        }
    }
}

Uso: Objeto JSON a objeto C # personalizado

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;
using System.Linq;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJavaScriptSerializer()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            User user = new User(json);
            Console.WriteLine("Name : " + user.name);
            Console.WriteLine("Teamname : " + user.teamname);
            Console.WriteLine("Email : " + user.email);
            Console.WriteLine("Players:");
            foreach (var player in user.players)
                Console.WriteLine(player);
        }
    }

    public class User {
        public User(string json) {
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            var jsonObject = serializer.Deserialize<dynamic>(json);
            name = (string)jsonObject["user"]["name"];
            teamname = (string)jsonObject["user"]["teamname"];
            email = (string)jsonObject["user"]["email"];
            players = jsonObject["user"]["players"];
        }

        public string name { get; set; }
        public string teamname { get; set; }
        public string email { get; set; }
        public Array players { get; set; }
    }
}

Ejemplo 2: usando System.Web.Helpers

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJsonDecode()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            dynamic jsonObject = Json.Decode(json);

            dynamic x = jsonObject.user; // result is dynamic json object user with fields name, teamname, email and players with their values
            x = jsonObject.user.name; // result is asdf
            x = jsonObject.user.players; // result is dynamic json array players with its values
        }
    }
}

Uso: objeto JSON para Objeto C # personalizado

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;
using System.Linq;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJsonDecode()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            User user = new User(json);
            Console.WriteLine("Name : " + user.name);
            Console.WriteLine("Teamname : " + user.teamname);
            Console.WriteLine("Email : " + user.email);
            Console.WriteLine("Players:");
            foreach (var player in user.players)
                Console.WriteLine(player);
        }
    }

    public class User {
        public User(string json) {
            var jsonObject = Json.Decode(json);
            name = (string)jsonObject.user.name;
            teamname = (string)jsonObject.user.teamname;
            email = (string)jsonObject.user.email;
            players = (DynamicJsonArray) jsonObject.user.players;
        }

        public string name { get; set; }
        public string teamname { get; set; }
        public string email { get; set; }
        public Array players { get; set; }
    }
}

Este código requiere agregar Sistema.Web.Helpers espacio de nombres encontrado en,

%Archivos de programa%\Microsoft ASP.NET\ASP.NET Web Pages{VERSION} \ Assemblies \ System.Web.Ayudante.dll

O

%Archivos de programa (x86) % \ Microsoft ASP.NET\ASP.NET Web Pages{VERSION} \ Assemblies \ System.Web.Ayudante.dll

Espero que esto ayude!

public static class Utilities
{
    public static T Deserialize<T>(string jsonString)
    {
        using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
        {    
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            return (T)serializer.ReadObject(ms);
        }
    }
}

Más información ir al siguiente enlace http://ishareidea.blogspot.in/2012/05/json-conversion.html

Acerca de DataContractJsonSerializer Classpuedes leer aquí.

Usar JavaScriptSerializer() es menos estricto que la solución genérica ofrecida: public static T Deserialize (string json)

Esto puede ser útil al pasar json al servidor que no coincide exactamente con la definición de objeto a la que está tratando de convertir.

En cuanto al rendimiento, encontré el serializador de ServiceStack un poco más rápido que otros. Es la clase JsonSerializer en ServiceStack.Espacio de nombres de texto.

Https://github.com/ServiceStack/ServiceStack.Text

ServiceStack está disponible a través del paquete NuGet: https://www.nuget.org/packages/ServiceStack /

JSON.Net es tu mejor apuesta pero, dependiendo de la forma de los objetos y si hay dependencias circulares, puedes usar JavaScriptSerializer o DataContractSerializer.

El generador de clases JSON C# en codeplex genera clases que funcionan bien con NewtonSoftJS.

Serializador JavaScript: requiere using System.Web.Script.Serialization;

public class JavaScriptSerializerDeSerializer<T>
{
    private readonly JavaScriptSerializer serializer;

    public JavaScriptSerializerDeSerializer()
    {
        this.serializer = new JavaScriptSerializer();
    }

    public string Serialize(T t)
    {
        return this.serializer.Serialize(t);
    }

    public T Deseralize(string stringObject)
    {
        return this.serializer.Deserialize<T>(stringObject);
    }
}

Serializador de Contratos de datos: requiere using System.Runtime.Serialization.Json; - El tipo genérico T debe ser serializable más sobre el Contrato de datos

public class JsonSerializerDeserializer<T> where T : class
{
    private readonly DataContractJsonSerializer jsonSerializer;

    public JsonSerializerDeserializer()
    {
        this.jsonSerializer = new DataContractJsonSerializer(typeof(T));
    }

    public string Serialize(T t)
    {
        using (var memoryStream = new MemoryStream())
        {
            this.jsonSerializer.WriteObject(memoryStream, t);
            memoryStream.Position = 0;
            using (var sr = new StreamReader(memoryStream))
            {
                return sr.ReadToEnd();
            }
        }
    }

    public T Deserialize(string objectString)
    {
        using (var ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes((objectString))))
        {
            return (T)this.jsonSerializer.ReadObject(ms);
        }
    }
}

En lugar de enviar como solo un objeto .

Cree una clase pública de propiedades que sea accesible y envíe los datos al Webmethod.

[WebMethod]
public static void SaveTeam(useSomeClassHere user)
{
}

Use los mismos nombres de parámetros en la llamada ajax para enviar datos.