Varios métodos de serialización y deserialización JSON. neto
JSON (JavaScript Object Notation, JS Object Notation) es un formato ligero de intercambio de datos. Se basa en un subconjunto de ECMAScript (la especificación js desarrollada por la Asociación Europea de Computación) y utiliza un formato de texto que es completamente independiente de los lenguajes de programación para almacenar y representar datos. La estructura jerárquica simple y clara hace de JSON un lenguaje de intercambio de datos ideal. Es conveniente para las personas leer y escribir, y también es conveniente para el análisis y la generación de máquinas, lo que mejora efectivamente la eficiencia de transmisión de la red.
Es un formato utilizado por JavaScript para procesar datos. La mayoría de ellos se utilizan para manejar el intercambio de datos entre JavaScript y servidores web. Los datos del servidor web en segundo plano se transmiten a la recepción y luego se procesan mediante JavaScript, como ajax. Es un formato de intercambio de datos liviano que es independiente del idioma y de la plataforma.
2. Sintaxis JSON
1. Reglas de sintaxis JSON
En lenguaje JS, todo es un objeto. Entonces JSON puede representar cualquier tipo admitido, como cadenas, números, objetos, matrices, etc. Pero los objetos y las matrices son dos tipos especiales y de uso común:
Los objetos se representan como pares clave-valor.
Los datos están separados por comas.
Las llaves guardan objetos.
Los corchetes guardan matrices
Objeto: en JS, el objeto es el contenido entre llaves y la estructura de datos es {clave 1: valor 1, clave 2: valor 2, ... .}.En lenguajes orientados a objetos, clave es el atributo del objeto y valor es el valor correspondiente. Los nombres de las claves se pueden representar mediante números enteros y cadenas. El tipo de valor puede ser cualquier tipo.
{ "Nombre": "Brett", "Apellido": "McLaughlin" }
Matriz: en JS, la matriz está entre corchetes [] Contenido, los datos La estructura es la estructura de índice de [".net", "JavaScript", "Python",...]. En JS, la matriz es un tipo de datos especial, también puede usar pares clave-valor como objetos, pero los índices aún lo son. usado mucho más. De manera similar, el tipo de valor puede ser cualquier tipo.
{
"人":[{
"Nombre":"Zhang",
"Apellido":"三"
},
{
"Nombre":"李",
"Apellido":" si "
}
]
}
2. Pares clave-valor JSON
Los pares clave-valor JSON almacenan objetos JSON Uno De esta manera, se escriben de la misma manera que los objetos JSON. El nombre de la clave en el par clave/valor se escribe al frente, con comillas dobles "", separadas por dos puntos: y luego seguido del valor: {"firstName": "Json"}, que es fácil de entender y equivalente a esta declaración de JavaScript: {primerNombre: "Json"}.
3. La relación entre objetos JSON y JS
La relación entre objetos JSON se puede entender de la siguiente manera: JSON es una representación de cadena de un objeto JSON y se utiliza texto para representar. un objeto JS. La información es esencialmente una cadena. Por ejemplo:
var obj = {a:'Hola', b:'Mundo'} //Este es un objeto. Tenga en cuenta que los nombres de las claves también pueden ir entre comillas.
var json = '{"a": "Hola", "b": "Mundo" } '; //Esta es una cadena JSON, esencialmente una cadena.
4.Los objetos JSON y JS se convierten entre sí.
Para convertir un objeto en una cadena JSON, utilice el método JSON.stringify():
var JSON = JSON . ' }); //El resultado es ' {"a": "Hello ", " b": "World"} '
Para convertir de JSON a objeto, utilice el método JSON.parse(). :
var obj = JSON.parse('{"a": "Hola", " b ": " Mundo " } '); //El resultado es {a:'Hola', b: 'World' }
En tercer lugar, modo de serialización Json
1. Serializador de JavaScript
El espacio de nombres que debe introducirse cuando se utiliza el método JavaScriptSerializer está en el ensamblado. Sistema .Web.Extensions.dll.
Usa el sistema. Web.Script.Serialization;
PD: las propiedades no serializadas se pueden marcar con [ScriptIgnore].
Código:
Resultado de la operación pública GetJsonDemo()
{
//Objeto
modelo de datos = nuevo modelo de datos();
Modelo. ID = 1;
Modelo. Nombre = "Zhang San";
Modelo. género = "femenino";
Modelo. edad = 18;
//Objeto Json serializado
Cadena strJson = JsonHelper. ObjectToJson(modelo);
//Objeto de deserialización Json
model= JsonHelper. JsonToObject & ltData Model& gt(str JSON);
String strContent = "Serialización del objeto:"+strJson+"\n"+
"Valor de deserialización:"+ nombre del modelo+" ". +model . sex+" "+model age;
Devolver contenido (str Content);
}
JsonHelper:
Público clase JsonHelper
{
#regionThe first JavaScriptSerializer
// El espacio de nombres que debe introducirse al usar JavaScriptSerializer, está en el ensamblado System.Web. Extensiones.dll.
//Usa el sistema. Web.Script.Serialization;
//Nota: puede utilizar [ScriptIgnore] para marcar propiedades no serializadas.
///<Summary>
///Serialización
///</summary>
///& lt; nombre del parámetro = " obj " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt; object obj)
{
Serializador de JavaScript jsonSerialize = nuevo serializador de JavaScript();
Devuelve jsonSerialize.
serialize(obj);
}
///& lt;Resumen>
///Deserialización
/ //& lt ;/summary & gt;
///& lt;typeparam nombre = " T " & gt& lt/type param & gt;
///& lt ;param nombre = " strJson " & gt& lt/param & gt;
///& lt;returns & gt& lt/returns & gt;
T JsonToObject estático público & ltT & gt(String strJson)
{
Serializador de JavaScript jsonSerialize = nuevo serializador de JavaScript();
//jsonSerialize. Deserialize <dynamic>(str JSON); //Value Model["Name"]; Para obtener el valor usando un índice, no puede usar un objeto. propiedad.
Devuelve jsonSerialize. Deserializar& ltT & gt(str JSON);
}
#End area
}
Resultado:
2.JSON.NET
Utilice el espacio de nombres de Newtonsoft. Json que debe introducirse al utilizar la biblioteca de clases Json.NET
PD: las propiedades que no están serializadas se pueden marcar con [JsonIgnore].
Código:
Resultado de la operación pública GetJsonDemo()
{
//Objeto
modelo de datos = nuevo modelo de datos();
Modelo. ID = 2;
Modelo. Name = " LiSi
Model.Gender = "Male";
Model.Age = 20;
//Serialización de objetos Json
String strJson = JsonHelper.ObjectToJson(model);
//Objeto de deserialización Json
model = JsonToObject<data model>(str JSON);
String strContent = " Serialización de objetos:"+strJson+"\n"+
"Valor de deserialización:"+model . name+" "+model . sex+" "+ model.age;
Devolver contenido ( str Content);
}
JsonHelper:
///<Summary& gt
/// Clase de ayuda Json
///& lt;/summary & gt;
Clase pública JsonHelper
{
#Región 2 JSON.NET
//El uso del espacio de nombres a través de Newtonsoft. Json debe introducirse en la biblioteca de clases Json.NET
//Nota: puede usar [JsonIgnore] para marcar propiedades que no están serializadas.
///<Summary>
///Serialización
///</summary>
///& lt; nombre del parámetro = " obj " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt; objeto obj)
{
Devuelve JsonConvert. serializar objeto(obj);
}
///<Resumen>
///Deserialización
///& lt ;/summary & gt;
///& lt;typeparam nombre = " T " & gt& lt/type param & gt;
///& lt; " strJson " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt;
T JsonToObject estático público & ltT & gt(String strJson)
{
Devuelve JsonConvert. Objeto deserializado<T>(str JSON);
}
#End area
}
Resultado:
p >
3. DataContractJsonSerializer
El espacio de nombres que debe introducirse al utilizar DataContractJsonSerializer es System.Runtime.Serialization.dll.
Usa el sistema. Runtime. Serialization.Json
Se debe usar DataContractJsonSerializer para agregar los contratos [DataMember] y [DataContract] en la entidad para la serialización y deserialización, pero para los otros dos métodos, se pueden agregar o no.
PD: Los atributos no serializados se pueden marcar con [IgnoreDataMember].
Código:
Resultado de la operación pública GetJsonDemo()
{
//Objeto
modelo de datos = nuevo modelo de datos();
Modelo. ID = 3;
Modelo. Nombre = "Wu Wang";
Modelo. género = "femenino";
Modelo. edad = 22;
//Objeto Json serializado
Cadena strJson = JsonHelper. ObjectToJson(modelo);
//Objeto de deserialización Json
modelo = JsonHelper.
JsonToObject & ltData Model& gt(str JSON);
String strContent = "Serialización del objeto:"+strJson+"\n"+
"Valor de deserialización:"+ nombre del modelo+" ". +modelo . sexo+" "+modelo edad;
Devolver contenido (str Contenido);
}
JsonHelper:
/ //<Summary>
///Clase de ayuda Json
///</summary>
Clase pública JsonHelper
{
#region El tercer DataContractJsonSerializer
// El espacio de nombres que debe introducirse cuando se usa DataContractJsonSerializer está en System.Runtime.Serialization.dll.
//Usa el sistema. Runtime. Serialization.Json
//Nota: puede utilizar [IgnoreDataMember] para marcar propiedades no serializadas.
//DataContractJsonSerializer debe usarse para agregar los contratos [DataMember] y [DataContract] en la entidad para la serialización y deserialización.
//Para los otros dos métodos, no es necesario agregarlos, pero se pueden hacer.
///<Summary>
///Serialización
///</summary>
///& lt; nombre del parámetro = " obj " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt; objeto obj)
{
Uso (flujo de flujo de memoria = nuevo flujo de memoria())
{
DataContractJsonSerializer jsonSerialize = nuevo DataContractJsonSerializer (obj.GetType());
jsonSerialize. WriteObject(stream, obj);
Devuelve la codificación. UTF8.GetString(stream.ToArray());
}
}
///<Resumen>
/// Deserialización
///& lt;/summary & gt;
///& lt;typeparam name = " T " & gt& lt/type param & gt;
///& lt; nombre del parámetro = " strJson " & gt& lt/param & gt;
///& lt; devuelve & gt& lt/returns & gt ;
T público estático JsonToObject & ltT & gt(String strJson)
{
Uso (flujo de flujo de memoria = nuevo flujo de memoria (Codificación.
UTF8.GetBytes(strJson)))
{
DataContractJsonSerializer jsonSerialize = nuevo DataContractJsonSerializer(tipo de (T));
Devuelve (T) jsonSerialize. ReadObject(flujo);
}
}
#Área final
}
Resultado: p>
PS: Modelo de datos
[Contrato de datos]
Modelo de datos de clase pública
{
[Datos Miembros]
ID int pública { obtener configuración;}
[Miembro de datos]
Nombre de cadena pública { obtener configuración;}
[Miembro de datos]
Propiedad de cadena pública { get configuración;}
[Miembro de datos]
public int Edad { get configuración;}
}
Cuarto, resumen
Hay tres formas de serializar 1 y JSON.
Clase JavaScriptSerializer
Biblioteca de clases JSON.NET
Clase DataContractJsonSerializer
2. serialización y deserialización, el rendimiento es bueno.