LINQ: consultando documentos JSON

En el post anterior vimos cómo realizar consultas en archivos XML. Ahora veremos cómo consultar documentos JSON con LINQ.

Teniendo el siguiente documento JSON:

developer.json

{
  "desarrolladores":[
    {
	"id_empleado":"7894311",
	"nombre": "Karla Alvarez Montoya",
	"telefono": "555 32 53 138",
	"correo":"karla.alvarez@edu.mx"
	},
	{
	"id_empleado":"74533267",
	"nombre": "Laura Torres Jimenez",
	"telefono": "552 99 00 112",
	"correo":"laura.torres@edu.mx"
	},
	{
	"id_empleado":"55533800",
	"nombre": "Joan Sebastian Laredo Arsate",
	"telefono": "553 56 33 008",
	"correo":"joan.laredo.arsate@edu.mx"
	}
  ]
}

1. Vamos a crear un proyecto .NET para consultar ese documento.

$ dotnet new console -n DemoLinqJson
$ cd DemoLinqJson

2. Instalaremos los paquetes necesarios para manipular el docuemnto JSON:

Con la herramienta CLI:

$ dotnet add package Newtonsoft.Json --version 13.0.5-beta1

Con NuGet:

$ NuGet\Install-Package Newtonsoft.Json -Version 13.0.5-beta1

3. Modificamos el programa principal ``Program.cs``:

using System;
using System.Linq;
using Newtonsoft.Json.Linq;

class Program
{
    public static readonly string PATH = "developer.json";
    
    static void Main()
    {
       try{
        var json = File.ReadAllText(PATH);
        var data = JObject.Parse(json);
        Console.WriteLine("Contenido del archivo: {0}",data.ToString());
       } catch (FileNotFoundException ex)
        {
            Console.WriteLine("El archivo no existe: {0}", ex.Message);
        }
    }

}

4. Ejecutamos el proyecto:

$ dotnet run

Salida:

Contenido del archivo: {
  "desarrolladores": [
    {
      "id_empleado": "7894311",
      "nombre": "Karla Alvarez Montoya",
      "telefono": "555 32 53 138",
      "correo": "karla.alvarez@edu.mx"
    },
    {
      "id_empleado": "74533267",
      "nombre": "Laura Torres Jimenez",
      "telefono": "552 99 00 112",
      "correo": "laura.torres@edu.mx"
    },
    {
      "id_empleado": "55533800",
      "nombre": "Joan Sebastian Laredo Arsate",
      "telefono": "553 56 33 008",
      "correo": "joan.laredo.arsate@edu.mx"
    }
  ]
}

Como se puede observar hemos mostrado todo el contenido del archivo JSON. ¿Se podrá realizar consultas? Estamos a punto de averiguarlo.

Lo primero a hacer será crear una clase que contenga la lógica del JSON al leer.

Desarrollador.cs

using System.Text.Json.Serialization;

namespace model
{
    public class Desarrollador
    {
        [JsonPropertyName("id_empleado")]
        public string Id { get; set; } = string.Empty;
        [JsonPropertyName("nombre")]
        public string Nombre { get; set; } = string.Empty;
        [JsonPropertyName("telefono")]
        public string Telefono { get; set; } = string.Empty;
        [JsonPropertyName("correo")]
        public string Correo { get; set; } = string.Empty;
    }

    public class Root
    {
        [JsonPropertyName("desarrolladores")]
        public List<Desarrollador> Desarrolladores { get; set; }
    }
}

Como se puede ver, esta clase es coherente con los atributos del JSON. No solo por el nombre sino por el tipo de dato.

Ahora modifiquemos el programa principal.

Program.cs

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;
using System.Text.Json;
using model;

class Program
{
    public static readonly string PATH = "developer.json";
    
    static void Main()
    {
        try
        {
            var json = File.ReadAllText(PATH);
            Root data = JsonSerializer.Deserialize<Root>(json);

            Console.WriteLine("Contenido del archivo:");
            foreach (var dev in data.Desarrolladores)
            {
                Console.WriteLine($"{dev.Id} - {dev.Nombre} - {dev.Correo}");
            }

            var desarrolladoresAgrupados = from dev in data.Desarrolladores
                                           group dev by dev.Id into idGroup
                                           select new
                                           {
                                               MyId = idGroup.Key,
                                               Count = idGroup.Count()
                                           };

            foreach (var group in desarrolladoresAgrupados)
            {
                Console.WriteLine($"Id del empleado: {group.MyId}, Count: {group.Count}");
            }
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine("El archivo no existe: {0}", ex.Message);
        }
    }
}

La parte que nos interesa es esta:

            var json = File.ReadAllText(PATH);
            Root data = JsonSerializer.Deserialize<Root>(json);

        
            var desarrolladoresAgrupados = from dev in data.Desarrolladores
                                           group dev by dev.Id into idGroup
                                           select new
                                           {
                                               MyId = idGroup.Key,
                                               Count = idGroup.Count()
                                           };

            foreach (var group in desarrolladoresAgrupados)
            {
                Console.WriteLine($"Id del empleado: {group.MyId}, Count: {group.Count}");
            }

Este bloque lee el contenido del archivo, lo deserializa y posteriormente agrupa a los desarrolladores por su Id y cuenta cuántos hay en cada grupo. Si nos recuerda a una consulta SQL es por que toma referencia a ese lenguaje.

Traducida a una consulta SQL vendría siendo algo como esto:

SELECT 
    id_empleado AS MyId,
    COUNT(*) AS Count
FROM desarrolladores
GROUP BY id_empleado;

Hacer consultas similares a los que se haría en SQL en archivos XML y/o JSON es posible gracias a LINQ.

Hay proyectos en los que nos será de mucha ayuda.

Continuaremos en próximas entregas.

Enlaces:

https://www.newtonsoft.com/json/help/html/queryinglinqtojson.htm
https://codemonkeyjunior.blogspot.com/2025/12/linq-consultando-documentos-xml.html
https://medium.com/@ddemirugur/c-13-net-9-part-10-linq-linq-to-xml-json-etc-f6f939f97222
https://developer.mescius.com/blogs/how-to-query-json-in-c-sharp-using-sql-linq-ado-net
https://learn.microsoft.com/es-es/dotnet/standard/linq/
https://www.johnpapa.net/linq-to-json-ndash-checking-for-an-object-or-array/
https://csharphardcoreprogramming.wordpress.com/2016/01/19/json-to-linq-to-json/
https://medium.com/hacking-building/using-linq-to-serialize-a-c-object-into-json-9ecbe9ca2941
https://codesignal.com/learn/courses/parsing-json-with-csharp/lessons/introduction-to-json-and-its-usage-in-csharp

Visualizar variables de un archivo de configuración en proyecto web ASP .Net

En este post veremos cómo visualizar  las variables de un archivo de configuración (en formato JSON) de de una aplicación web sencilla ASP .NET.

En el anterior post vimos cómo crear un proyecto.

dotnet new webApp -o miwebapp --no-https
cd miwebapp

Creamos dos páginas *.cshtml, amas con nombre Index.cshtml, una de ellas dentro de un directorio llamado Solange.

• Index.cshtml
• Solange/Index.cshtml

Nuestro directorio:

Nuestro archivo JSON  se verá así:

appsettings.json 

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Message": "Aqui un saludo desde el archivo de configuracion",
  "Email": "codemonkey.blogspot@latinmail.com",
  "Author":"Codemonkey Junior",
  "NumberOfPostOnHomePage": 10,
  "ShowAdsOnHomePage": true,
  "PageSize": 10
}

Nuestras páginas *.cshtml:
Index.cshtml

@page
@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration

<h1 align='center'>Hola, <font color='green'>amigo</font>.</h1>
<p align='center'><b>Estás en la página principal.</b></p>
<p>El curso inicia en <b>@DateTime.Now</b> </p>

<h2>@Configuration["Message"]</h2>
<h2>@Configuration["Author"]</h2>
<h2>@Configuration["Email"]</h2>

<p>Expresiones:</p>
@{
    var booleano = 50 > 100;
    var operacion = 9+3;
}
<p>50 > 100 es @booleano</p>
<p>9 + 3 es @operacion</p>

Solange/Index.cshtml

@page

<h1>Hola, está página está solita.</h1>
<p>Su ubicación está en /Solange</p>

Ahora nuestras clases principales: Startup.cs y Program.cs Startup.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;

namespace miwebapp
{
    public class Startup
    {
        public IConfiguration Configurations{ get; set; }

        public Startup(IConfiguration config)
        {
            Configurations = config;
        }

          public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseMvc();

            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("<h1 align ='center'>Programando en <font color='blue'>C#</font> como si fuera en primero.</h1><hr/>");
            });

            
        }
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace miwebapp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Programando en C#");
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>();
    }
}

Desde la terminal tecleamos:

dotnet run

Abrimos el navegador en http://localhost:5000

Al abrir http://localhost:5000/Solange obtendremos:

100 días de código en Javascript... 1era parte

En este post veremos algunos ejemplos de código en Javascript.

1. Si quieres obtener un elemento mediante su id debes hacerlo de esta forma:

const item = document.getElementById("item");

2. Si quieres obtener un arreglo (inicia en 0) de elementos debes hacer esto:

var items = document.getElementsByTagName("tag");

/*Arreglo de h1*/
var cabezas = document.getElementsByTagName("h1");

//Si necesitas obtener el primer elemento h1:
console.log(cabezas[0]);

//Si quieres obtener su tamaño:
console.log("Tam:",cabezas.length);

3. Si quieres acceder a un item mediante su id o clase debes hacer esto:

//Acceder a un elemento mediante un id
const item1 = document.querySelector("#item1");


//Acceder a un elemento mediante su clase
const item2 = document.querySelector(".item2");

4. Si quieres obtener todos los elementos con una clase en particular debes hacer esto:

//Obtener todos las etiquetas p con la clase 'intro'
var misParrafos = document.querySelectorAll("p.intro");

5. Si quieres colocar un texto en un elemento debes hacer esto:

var texto = document.getElementById("identificador");

//Colocar texto:
texto.textContent = "Hola, mundo" ;

6. Si quieres colocar contenido HTML en otro elemento:

//Mediante su id
var contenedor1 = document.getElementById("contenedor1");
contenedor.innerHTML = "<h1>Hola, mundo</h1>";

//Con querySelector, accediendo a su clase
var contenedor2 = document.querySelector(".contenedor2");

contenedor2.innerHTML = "<p>Ciao</p>";


//Con querySelector, accediendo a su id
var contenedor3 = document.querySelector("#contenedor3");

contenedor3.innerHTML = "<p>Arrivaderci</p>";

7. Si quieres recargar una página HTML en un tiempo determinado:

setTimeout(window.location.reload(),3000);

8. Si quieres recargar la página usando un botón:

const btn = document.getElementById("btn");

btn.addEventListener("click",()=>{
 window.location.reload();
});

9. Cargar contenido DOM:

document.addEventListener("DOMContentLoaded", function(event) {
   /*Cargar contenido JS en Página HTML
     equivalente a:
   $(document).ready(function() {});
    */
});

10. Crear evento en un elemento (click, dblclick, mouseout, mouseover, etc.):

const btn = document.getElementById("btn");
btn.addEventListener('click',()=>{
    //Hacer algo
});

11. Si quieres abrir una página HTML externa:

var abrirVentana=function(){
  window.open("ventana.html","Ventana HTML","width=400, height=250");
};

const btn = document.getElementById("btn");
btn.addEventListener("click",()=>{
  abrirVentana();
});

12. Ocultar elemento:

const btn = document.getElementById("btn");
const contenedor = document.querySelector("#contenedor");

//Ocultar
btn.addEventListener("click",()=>{
  contenedor.style.display = "none";
});

13. Mostrar elemento (el estilo del elemento debe ser style="display:none"):

const btn = document.getElementById("btn");
const contenedor = document.querySelector("#contenedor");

//Mostrar
btn.addEventListener("click",()=>{
  contenedor.style.display = "";
});

14. Aplicar CSS desde Javascript:

document.addEventListener("DOMContentLoaded", function(event) {
console.log('%c Codemonkey Junior','color:#E6E6E6;background-color:#2F0B3A;');

//1. Aplicar estilo desde JS
const titulo = document.getElementById("titulo");
titulo.style.backgroundColor = "black";
titulo.style.color = "gray";
titulo.style.textAlign = "center";

});

15.Si quieres obtener un atributo de un elemento, por ejemplo su clase (class):

var cabeza = document.getElementsByTagName("h1")[0].getAttribute("class"); 
const contenedor = document.getElementById("contenedor");
const btn =document.querySelector("#btn");


btn.addEventListener("click",() =>{
contenedor.innerHTML = cabeza;
});

16. Si quieres crear una variable constante:

/*Las variables constantes (const) no pueden alterar su valor*/
const print = console.log;
const label = document.getElementById("identificador");
const TAM = 100;

17. Si quieres crear un nuevo elemento y colocarlo dentro de otro:

var parrafo = document.createElement("p");
var texto = document.createTextNode("Nuevo parrafo.");
parrafo.appendChild(texto);

const contenedor = document.getElementById("contenedor");
element.appendChild(parrafo);

18. Si quieres cerrar la ventana actual:

window.close();

19. Si quieres obtener la URL completa de la página en la que estas:

const URL = window.location.href;
const btn = document.getElementById("btn");

btn.addEventListener("click", ()=>{
   alert("URL es: "+URL);
});

Links:
https://codemonkeyjunior.blogspot.com/2014/06/javascript-aspectos-basicos.html 
https://codemonkeyjunior.wordpress.com/2017/09/22/javascript-uso-de-prototype/
https://www.w3schools.com/js/default.asp 

Groovy en ejemplos no.9: Leer un JSON

Usar archivos JSON para el intercambio de información entre aplicaciones se ha vuelto muy indispensable. Es una alternativa para sustituir el uso de archivos XML.

Un archivo JSON se compone de:

• Una colección tipo diccionario con nombre y valor.
• Un arreglo o lista ordenada.

Ejemplo. Un archivo JSON llamado "persona.json" puede tener una estructura similar a la siguiente:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32
   }
}

Donde "persona" es el nodo (objeto) principal. Los valores pueden ser de tipo boolean (true o false), númericos y cadenas.  También podemos definir arreglos (que inician y cierran con corchetes) como este:
{
   "persona": {
          "nombre": "Mariana",
           "edad": 32,
          "libros":[
           "El extraño caso de el perro en el ropero",
           "El error de llamarse Godofredo"
         ]
   }
}

Donde "libros" es el arreglo.

¿Cómo leer el archivo JSON?

• Necesitamos crear un archivo json (que cumpla con la estructura adecuada), y que denominaremos como "persona.json"
• Usar la librería groovy.json.JsonSlurper

leerJSON.groovy

import groovy.json.JsonSlurper
import java.io.File

static main(args) {
  def json=new JsonSlurper()
  def archivo=new File("persona.json")

  if(archivo.exists()){
    println "Archivo existe:${archivo.getAbsolutePath()}"
    def objeto=json.parse(archivo) 
    if(objeto !=null){
        if(objeto.persona.nombre == null && objeto.persona.nombre == null){
            println "Objetos nulos"
        }
        javax.swing.JOptionPane.showMessageDialog(null, "Nombre:"+objeto.persona.nombre+"\nEdad:"+objeto.persona.edad)
    }
  }

}

Para acceder a una propiedad del objeto es necesario definir su nombre, por ejemplo, si queremos obtener el "valor" de la propiedad "nombre" debemos acceder de este modo:  objeto.persona.nombre

Ejecutamos: groovy leerJSON.groovy

Y obtenemos:

Links
https://geekytheory.com/json-i-que-es-y-para-que-sirve-json/
http://www.json.org/json-es.html