serializar - recorrer json c#

Cómo convertir objetos JSON a objetos personalizados C#?

Question

¿Hay alguna manera fácil de poblar mi Objeto C # con el objeto JSON pasado a través de AJAX?

// Este es el objeto JSON pasado a C # WEBMETHOD desde la página usando JSON.stringify

{
"user" : {
"name" : "asdf",
"teamname" : "b",
"email" : "c",
"players" : ["1",
"2"]
}
}

// C # WebMetod que recibe el objeto JSON

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

// Clase C # que representa la estructura de objeto del objeto JSON pasada al WebMethod

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

Answer 1

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

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

Sin embargo, en general, puede utilizar la clase JavascriptSerializer como se indica a continuación, o para mayor flexibilidad, utilice cualquiera de los diversos frameworks Json (Jayrock JSON es bueno) para facilitar la manipulación de JSON.

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

Answer 2

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

Answer 3

En lo que respecta al rendimiento, el serializador de ServiceStack me pareció un poco más rápido que otros. Es la clase JsonSerializer en el espacio de nombres ServiceStack.Text.

https://github.com/ServiceStack/ServiceStack.Text

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

Answer 4

En lugar de enviar solo como 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.

Answer 5

Esta es una herramienta muy práctica que crea modelos de objetos C # * de JSON: http://json2csharp.com

Answer 6

JSON.Net es su mejor opción, pero, dependiendo de la forma de los objetos y de si existen dependencias circulares, puede usar JavaScriptSerializer o DataContractSerializer.

Answer 7

Los siguientes 2 ejemplos hacen uso de cualquiera

1. JavaScriptSerializer en System.Web.Script.Serialization Or
2. Json.Decode en System.Web.Helpers

Ejemplo 1: utilizando System.Web.Script.Serialization

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 al objeto personalizado C #

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: utilizando 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 al objeto personalizado C #

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 el espacio de nombres System.Web.Helpers que se encuentra en,

% ProgramFiles% / Microsoft ASP.NET / ASP.NET Páginas web {VERSIÓN} / Assemblies / System.Web.Helpers.dll

O

% ProgramFiles (x86)% / Microsoft ASP.NET / ASP.NET Web Pages {VERSION} / Assemblies / System.Web.Helpers.dll

¡Espero que esto ayude!

Answer 8

Otra solución realmente simple es el uso de la biblioteca Newtonsoft.Json:

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

Answer 9

Para mantener sus opciones abiertas, si está utilizando .NET 3.5 o posterior, aquí hay un ejemplo envuelto que puede usar directamente desde el marco usando Generics. Como otros han mencionado, si no se trata solo de objetos simples, debería 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;

Answer 10

Serializador de JavaScript: requiere el 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 contrato de datos: requiere el using System.Runtime.Serialization.Json; - El tipo genérico T debería ser serializable más en Data Contract

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

Answer 11

Una buena forma de usar JSON en C # es con JSON.NET

Quick Starts & API Documentation de JSON.NET - El sitio oficial te ayuda a trabajar con él.

Un ejemplo de cómo usarlo:

public class User
{
public User(string json)
{
JObject jObject = JObject.Parse(json);
JToken jUser = jObject["user"];
name = (string) jUser["name"];
teamname = (string) jUser["teamname"];
email = (string) jUser["email"];
players = jUser["players"].ToArray();
}
public string name { get; set; }
public string teamname { get; set; }
public string email { get; set; }
public Array players { get; set; }
}
// Use
private void Run()
{
string 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);
}

Answer 12

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

Eso podría ser útil al pasar json al servidor que no coincide exactamente con la definición del objeto al que intenta convertir.

Answer 13

Dado que a todos nos encanta el código de un revestimiento

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

si tenemos clase entonces use abajo.

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

ninguna clase luego usa dinámica

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

Answer 14

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 Class que puede leer here .