En ocasiones nos encontramos en la tesitura de que necesitamos modificar o leer un JSON pero, debido a diferentes motivos, no lo queremos convertir o parsear a un objeto C# de .NET. A través de este artículo aprenderás como realizar este proceso de manera sencilla mediante varios ejemplos prácticos.
¿Por qué no podemos convertir un JSON a un objeto C#?
Esta es una pregunta muy interesante ya que no me dí cuenta, hasta hace poco que me surgió la necesidad, de que hay ocasiones donde no vamos a poder o querer convertir un JSON a un objeto para leerlo o modificarlo cómodamente. Algunos de los escenarios donde puede ocurrir esto son lo siguientes:
Pérdida de información
En primer lugar podemos perder información del JSON original cuando conocemos solo una parte de éste pero no la estructura completa.
Pongamos el ejemplo de que te han asignado la tarea de recibir un JSON, modificar dos de sus propiedades y enviarlo a otro sistema; además, en los requisitos, lo único que te han dado como definición son los nombres de las dos propiedades, en qué parte del JSON se encuentran y el tipo de datos que tienen.
Dado este escenario, si conviertes el JSON a un objeto que solo tiene esas dos propiedades que conoces, las modificas y lo envias al otro sistema, estarás perdiendo la información de las propiedades que desconoces.
Veamos un ejemplo completo de pérdida de información:
- Supongamos que el JSON completo es el siguiente:
{ "Marca": "Toyota", "Modelo": "Corolla", "Año": 2022, "Color": "Rojo", "NumeroDePuertas": 4, "TipoCombustible": "Gasolina", "PotenciaMotor": 120, "Matricula": "AB123CD", "Kilometraje": 25000, "Transmision": "Automática" } - Ahora supongamos que las únicas propiedades que nos han dado en los requisitos son las dos primeras, la marca y el modelo, el resto las desconocemos completamente.
- El primer paso consiste en transformarlo a un objeto representado por la siguiente clase:
public class Coche { public string Marca { get; set; } public string Modelo { get; set; } } - Después simplemente modificamos el objeto con un código similar al siguiente:
Coche miCoche = JsonSerializer.Deserialize<Coche>(@"{ ""Marca"": ""Toyota"", ""Modelo"": ""Corolla"", ""Año"": 2022, ""Color"": ""Rojo"", ""NumeroDePuertas"": 4, ""TipoCombustible"": ""Gasolina"", ""PotenciaMotor"": 120, ""Matricula"": ""AB123CD"", ""Kilometraje"": 25000, ""Transmision"": ""Automática"" }"); miCoche.Marca = "Honda"; miCoche.Modelo = "Civic"; - Y finalmente serializamos y enviamos al sistema externo con el siguiente código:
string jsonAEnviar = JsonSerializer.Serialize(miCoche); Enviar(jsonAEnviar);
Pues bien, si haces lo anterior y depuras el JSON enviado te darás cuenta que únicamente estás enviando las dos propiedades que conoces y que has perdido el resto de información del objeto recibido:
Tiempo y trabajo excesivo de desarrollo
En segundo lugar puede suponer un tiempo y trabajo excesivo de desarrollo si la estructura de datos la conocemos y es muy grande y/o compleja.
Siguiendo el excenario anterior veamos un ejemplo completo de tiempo y trabajo excesivo de desarrollo:
- Supongamos que la estructura de coche tiene 1.000 propiedades donde se incluyen listas, propiedades anidadas, tipos de datos complejos… etc.
- A diferencia del caso anterior, en los requisitos, nos han dado la definición completa de la estructura de datos del coche y solo debemos modificar dos de sus propiedades.
- El primer paso consistiría en crear una clase con todas esas propiedades bien definidas a través de las clases necesarias para evitar la pérdida de información que hemos visto en el apartado anterior.
- El resto de pasos serían exactamente los mismos que antes, es decir, convertir el JSON recibido a la clase definida, modificar el objeto y serializarlo para enviarlo al sistema externo.
Ahora bien, parémonos a pensar, ¿realmente merece la pena invertir tiempo en definir una estructura de datos compleja con 1.000 propiedades y sus clases correspondientes si lo que necesitamos es únicamente modificar 2 propiedades?; la respuesta es sencilla, no compensa tanto trabajo.
Cómo leer o modificar un JSON sin convertir a objeto
Para evitar los escenarios anteriores veremos un ejemplo de código C# para leer o modificar un JSON sin convertir a un objeto:
using System.Text.Json;
using System.Text.Json.Nodes;
internal class Program
{
private static void Main(string[] args)
{
string json = @"{
""Marca"": ""Toyota"",
""Modelo"": ""Corolla"",
""Año"": 2022,
""Color"": ""Rojo"",
""NumeroDePuertas"": 4,
""TipoCombustible"": ""Gasolina"",
""PotenciaMotor"": 120,
""Matricula"": ""AB123CD"",
""Kilometraje"": 25000,
""Transmision"": ""Automática""
}";
// Parsear a un JsonNode
JsonNode rootNode = JsonNode.Parse(json);
// Leer un valor
string marca = rootNode["Marca"]?.ToString();
// Modificar un valor
rootNode["Marca"] = "Honda";
// Obtener JSON modificado
string jsonModificado = rootNode.ToJsonString();
// Enviar el JSON modificado
Enviar(jsonModificado);
}
private static void Enviar(string jsonAEnviar)
{
throw new NotImplementedException();
}
}Si depuramos el código y anterior y analizamos la información que estamos enviando al sistema externo al final podemos darnos cuenta de que no hemos perdido nada de información a la hora de modificar o leer el JSON:
Y, por lo tanto, como conclusión, podemos decir que utilizando el código C# del ejemplo hemos conseguido los siguientes puntos:
- No hemos necesitado conocer la clase coche completa, solo las propiedades que nos interesan leer o modificar.
- Hemos ahorrado tiempo de desarrollo puesto que solo ha sido necesario utilizar unas pocas líneas.
- No hemos perdido nada de la información original del JSON recibido y, además, hemos sido capaces de modificarlo y/o leerlo.
