Cómo implementar JSON con C#

En mi artículo anterior vimos un poco de teoría, pero ahora veremos cómo utilizar JSON (serializar y deserializar) en nuestras aplicaciones utilizando C#. Let's go!

¿Cómo leer y escribir archivos JSON con C#?

En esta oportunidad les mostraré dos maneras de hacerlo. Usaremos las siguientes herramientas:

  • Clase JavaScriptSerializer, que está construida en .NET.
  • Librería JSON.NET, que es en realidad un third party NuGet Package y que podemos agregar fácilmente a cualquier aplicación de Visual Studio.

Importante! Recuerda que para leer JSON necesitamos serializar, mientras que para escribir, debemos deserializar.

Serializar quiere decir que a partir de un objeto, generaremos un texto con formato JSON. Deserializar es el proceso contrario.

Usando JavaScriptSerializer Class

Paso 1. Primero crearemos nuestro proyecto en Visual Studio. En mi caso, estoy utilizando Visual Studio Community 2015, pero la versión no importa mucho en esta oportunidad.

New Project

Paso 2. Escogeremos dentro de los Templates (a la izquierda) la opción Visual C# y luego Console Application. Escogemos el nombre y ruta que queramos y avanzamos.

Console Application

Paso 3. Una vez abierto nuestro proyecto, lo que necesitamos es agregar una referencia a System.Web.Extensions, como muestro a continuación:

AddReference

AddSystemWebExtensions

Paso 4. Clic en OK y ahora vamos a agregar un par de líneas de código para que funcione correctamente nuestra aplicación. Al inicio de nuestro código fuente agreguemos en la sección using las siguientes importaciones:


using System.Web.Script.Serialization;
using System.IO;

La primera importación la necesitamos para que la clase que contiene el serializador para nuestro JSON funcione, mientras que la segunda es necesaria ya que utilizaremos lecturas y escrituras de archivos (es decir, nuestros archivos de extensión .json).

Nos debe quedar algo más o menos como esto:

Using

Ahora que ya tenemos todo listo, empecemos a codificar un poco! :)

Paso 5: Código!

Para nuestro ejemplo, necesitaremos de una clase Person que nos servirá para crear nuestros objetos y tendrá tan solo dos propiedades: name y age.


class Person
{
    public string name { get; set; }
    public int age { get; set; }
}

Primero haremos el ejemplo para escribir JSON, así que:
Dentro de la clase Program, ubicamos nuestro main() y escribiremos el siguiente código:


static void Main(string[] args)
{
    JavaScriptSerializer ser = new JavaScriptSerializer();
    Person p1 = new Person { name = "Javier", age = 18};
    string outputJSON = ser.Serialize(p1);
    File.WriteAllText("MiPrimerJSON.json", outputJSON);
}

Lo que hemos hecho aquí es:

  1. Crear un objeto ser a partir de la clase JavaScriptSerializer que hemos incluido en nuestro proyecto. Utilizaremos esta referencia para acceder a las funciones de serialización y deserialización.
  2. Crear un objeto p1 a partir de la clase Person e inicializar sus atributos.
  3. Crear una variable string outputJSON, que almacenará la cadena deserializada en formato JSON. Aquí está la magia.
  4. En la última línea hacemos uso del método WriteAllText de la clase File para escribir nuestro outputJSON al archivo que indicamos. En el primer parámetro pondremos el nombre del archivo, mientras que en el segundo pondremos la cadena a escribir.

Nuestro código completo deberá quedar más o menos de la siguiente manera:


namespace JavaScriptSerializerClass
{
    class Person
    {
        public string name { get; set; }
        public int age { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            JavaScriptSerializer ser = new JavaScriptSerializer();
            Person p1 = new Person { name = "Javier", age = 18};
            string outputJSON = ser.Serialize(p1);
            File.WriteAllText("MiPrimerJSON.json", outputJSON);
        }
    }
}

Ahora ya estamos listos para correr nuestra aplicación y ver qué ha sucedido.
En la parte superior seleccionamos Debug y clickeamos Start.

Run

Adivinen qué... Acabamos de generar nuestro primer archivo JSON! ¿No me creen? Pues se lo mostraré. Para esto, vamos a File > Open > File.

OpenJSON

Buscamos la carpeta bin de nuestro proyecto, luego Debug y encontraremos nuestro archivo .json creado.

JSONFound

Aquí está!

JSONOpened

Ahora que tenemos el archivo JSON con nuestra información, lo aprovecharemos e intentaremos leerlo desde nuestra aplicación para luego mostrar su contenido en la consola; es decir, vamos a deserializar.
Para esto necesitamos hacer unos pequeños cambios en el código.


namespace JavaScriptSerializerClass
{
    class Person
    {
        public string name { get; set; }
        public int age { get; set; }
        public override string ToString()
        {
            return "Nombre: " + name + "\nEdad: " + age;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            JavaScriptSerializer ser = new JavaScriptSerializer();
            string outputJSON = File.ReadAllText("MiPrimerJSON.json");
            Person p1 = ser.Deserialize(outputJSON);
            Console.WriteLine(p1.ToString());
            Console.ReadLine();
        }
    }
}

Lo que hemos hecho es:

  1. Agregar un método toString() (en realidad sobreescribirlo, por eso la palabra override) a nuestra clase Person. Esto lo hacemos con motivo de darle un formato a lo que queremos imprimir en la consola.
  2. En nuestro main() hemos mantenido solo la primera línea, que crea la instancia de nuestro serializador.
  3. Luego, creamos una variable string que almacenará como una cadena todo lo que contenga el archivo que indicamos como parámetro (MiPrimerJSON.json). Para esto hacemos uso del método ReadAllText de la clase File.
  4. En la línea que viene es donde pasa nuevamente la magia, ya que aquí es donde exactamente ocurre la deserialización. Utilizamos nuestro objeto ser y accedemos al método Deserialize<>().
    Los <> nos indican que estamos haciendo uso de Generics. Dentro de estos símbolos debemos indicar el tipo de dato al que queremos serializar, en nuestro caso, de tipo Person.
    Además, debemos pasar como parámetro el string que contiene nuestro JSON por deserializar.
    Como estamos deserializando un objeto Person, debemos almacenarlo dentro de nuestra aplicación. Por esta razón, necesitamos crear un objeto p1 de este tipo que cumplirá esta función.
  5. Finalmente, imprimimos nuestro objeto utilizando su método ToString() para ver lo que acabamos de deserializar.

Nota: La línea Console.ReadLine(); solo la usamos para que nuestra consola no se cierre inmediatamente después de realizar todo el proceso. Para salir, solo debemos presionar Enter.

Nuestro resultado:

AppRunningJSSClass

Usando JSON.NET Library

Otra opción para realizar los procesos de serialización y deserialización es usando la librería JSON.NET.
Para practicar un poco con esto crearemos un nuevo proyecto dentro de Visual Studio (como ya lo hicimos líneas arriba) y haremos lo siguiente:

Paso 1: Como ya lo mencioné anteriormente, necesitaremos instalar un NuGet Packagea nuestro proyecto. Clic derecho a nuestro proyecto en el Solution Explorer > Manage NuGet Packages.

ManageNuGet

Paso 2: Nos aparecerá una pestaña nueva, donde buscaremos JSON.NET, como a continuación.

InstallingNuget

Paso 3: Seleccionamos Newtonsoft.Json y le damos clic a instalar.

Paso 4: Clic en OK y verificamos que nuestro paquete NuGet fue instalado correctamente fijándonos en el Output en la parte inferior.

OutputNuget

Paso 5: Ahora solo hace falta agregar las importaciones necesarias:


using Newtonsoft.Json;
using System.IO;

Paso 6: Otra vez al código!

Reutilizaremos un poco el código para nuestro ejemplo anterior. Primero, escribiremos JSON.


namespace JSONNETLibrary
{
    class Person
    {
        public string name { get; set; }
        public int age { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person { name = "Pedro Picapiedra", age = 39 };
            string outputJSON = JsonConvert.SerializeObject(p1);
            File.WriteAllText("MiSegundoJSON.json", outputJSON);
        }
    }
}

En este caso podemos observar que solo fue necesario cambiar dos líneas de código con respecto a lo que usamos para el ejemplo anterior.

  1. Para este método, ya no necesitaremos crear un objeto ser para que podamos acceder a los métodos de serialización, es decir, podremos acceder a ellos estáticamente.
  2. Después de haber creado nuestro objeto p1, lo serializamos utilizando el método SerializeObject() que está dentro de la clase JsonConvert y almacenándolo en nuestra variable string outputJSON. Luego, como ya suponemos, escribiremos dicha cadena en nuestro archivo deseado.

Ahora lo corremos y listo! Tenemos nuestro JSON generado. Para comprobar, File > Open > File y lo buscamos nuevamente en la ruta bin\debug.

SecondJSON

Ahora, pasaremos a leer el JSON que acabamos de escribir utilizando el código a continuación:


namespace JSONNETLibrary
{
    class Person
    {
        public string name { get; set; }
        public int age { get; set; }
        public override string ToString()
        {
            return "Nombre: " + name + "\nEdad: " + age;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string outputJSON = File.ReadAllText("MiSegundoJSON.json");
            Person p1 = JsonConvert.Deserialize(outputJSON);
            Console.WriteLine(p1.ToString());
            Console.ReadLine();
        }
    }
}

Al igual que antes, ya no necesitaremos crear el objeto ser. Lo único que cambia con respecto al ejercicio con JavaScriptSerializer Class es la forma en que accedemos al método Deserialize: será de forma estática a través de la clase JsonConvert. Todo lo demás, funciona tal como en nuestro ejercicio anterior.

Nuestro resultado:

AppRunningJSONNETLibrary

Bien, hemos terminado este tutorial, pero tu experiencia aún empieza. No dudes más y ponte a practicar! Si quieres más ejemplos aquí te dejo uno que hice en mi tiempo libre:

Saludos, amigos.

-Amor yo no cerré tu Facebook, mira, estoy usando el Gotzilla.
Había abierto Mozilla Firefox.