LINQ: un lenguaje de consulta para C#

LINQ (Language Integrated Query) es una característica de C# que permite consultar y manipular datos directamente desde el lenguaje, usando una sintaxis coherente y expresiva. En lugar de escribir SQL o recorrer colecciones manualmente, LINQ te deja trabajar con objetos, colecciones, XML o bases de datos de forma declarativa.

Su ventaja primordial es: unificar la forma de consultar datos, sin importar el origen.

Se puede emplear de esta forma:

1. Sintaxis de consulta (query syntax, parecida a SQL):

var resultado = from p in db.Persons
                where p.City == "CDMX"
                orderby p.LastName
                select p;

2. Sintaxis de métodos (method syntax, con lambdas y métodos de extensión):

var resultado = db.Persons
                  .Where(p => p.City == "CDMX")
                  .OrderBy(p => p.LastName)
                  .ToList();

Como se puede observar ambas sintaxis, aunque diferentes, hacen lo mismo.

Usando LINQ en nuestro proyecto

En el post anterior vimos cómo crear una aplicación dotnet que intergra EntityFramework para trabajar con una base de datos de MariaDB. Usemos LINQ como herramienta para hacer SELECT, INSERT, UPDATE y DELETE de forma sencilla.

1. Hacer consultas como un SELECT:

using var db = new AppDbContext();

var personsInCDMX = db.Persons
                      .Where(p => p.City == "CDMX")
                      .OrderBy(p => p.LastName)
                      .ToList();

foreach (var p in personsInCDMX)
{
    Console.WriteLine($"{p.FirstName} {p.LastName} - {p.City}");
}

2. Insertar datos como un INSERT INTO:

db.Persons.Add(new Person {
    PersonId = 2,
    FirstName = "Ana",
    LastName = "García",
    Address = "Av. Reforma 456",
    City = "CDMX"
});
db.SaveChanges();

3. Modificar datos como un UPDATE:

var person = db.Persons.FirstOrDefault(p => p.PersonId == 2);
if (person != null)
{
    person.City = "Guadalajara";
    db.SaveChanges();
}

4. Remover datos como un DELETE:

var person = db.Persons.FirstOrDefault(p => p.PersonId == 2);
if (person != null)
{
    db.Persons.Remove(person);
    db.SaveChanges();
}

El código Program.cs quedaría de la siguiente manera:

using System;
using System.Linq;
using Model;

class Program
{
    static void Main()
    {
        using var db = new AppDbContext();

        // INSERT
        db.Persons.Add(new Person {
            PersonId = 2,
            FirstName = "Ana",
            LastName = "García",
            Address = "Av. Reforma 456",
            City = "CDMX"
            });
        db.SaveChanges();

        // SELECT
        var personsInCDMX = db.Persons
                      .Where(p => p.City == "CDMX")
                      .OrderBy(p => p.LastName)
                      .ToList();
        foreach (var p in personsInCDMX)
        {
            Console.WriteLine($"{p.FirstName} {p.LastName} - {p.City}");
        }
        
        // UPDATE
        var person = db.Persons.FirstOrDefault(p => p.PersonId == 2);
        if (person != null)
        {
            person.City = "Guadalajara";
            db.SaveChanges();
        }

        // DELETE
        if (person != null)
        {
            db.Persons.Remove(person);
            db.SaveChanges();
        }
        
    }
}

Y podríamos hacer más ejemplos.

Filtrar registros (Where):

// Personas que viven en CDMX
var enCDMX = db.Persons
               .Where(p => p.City == "CDMX")
               .ToList();

Seleccionar campos específicos:

// Solo nombres y apellidos
var nombres = db.Persons
                .Select(p => new { p.FirstName, p.LastName })
                .ToList();

Ordenar (ORDER BY):

// Ordenar por apellido
var ordenados = db.Persons
                  .OrderBy(p => p.LastName)
                  .ToList();

Combinar condiciones:

// Personas en CDMX o Guadalajara
var filtrados = db.Persons
                  .Where(p => p.City == "CDMX" || p.City == "Guadalajara")
                  .ToList();

Agrupar (GROUP BY):

// Agrupar personas por ciudad
var agrupados = db.Persons
                  .GroupBy(p => p.City)
                  .Select(g => new { Ciudad = g.Key, Total = g.Count() })
                  .ToList();

Unir tablas (JOIN):

var consulta = db.Persons
                 .Join(db.Orders,
                       p => p.PersonId,
                       o => o.PersonId,
                       (p, o) => new { p.FirstName, p.LastName, o.OrderDate })
                 .ToList();

Paginar (Skip y Take):

// Obtener los primeros 10 registros
var primeros10 = db.Persons
                   .Take(10)
                   .ToList();

// Saltar los primeros 10 y traer los siguientes 5
var pagina2 = db.Persons
                .Skip(10)
                .Take(5)
                .ToList();

Y otras cosas más.

Contar registros (Count):

// Total de personas en la tabla
int total = db.Persons.Count();

// Personas en CDMX
int enCDMX = db.Persons.Count(p => p.City == "CDMX");

Sumar valores (Sum):

// Suma de todas las edades
int sumaEdades = db.Persons.Sum(p => p.Age);

Obtener promedio (Average):

// Edad promedio
double promedioEdad = db.Persons.Average(p => p.Age);

Agrupación con agregados:

// Número de personas por ciudad
var personasPorCiudad = db.Persons
    .GroupBy(p => p.City)
    .Select(g => new {
        Ciudad = g.Key,
        Total = g.Count()
    })
    .ToList();

Búsquedas con Any/All:

// ¿Existe alguien en Monterrey?
bool existeMonterrey = db.Persons.Any(p => p.City == "Monterrey");

// ¿Todos viven en CDMX?
bool todosCDMX = db.Persons.All(p => p.City == "CDMX");

Proyección de cálculos:

// Proyectar nombre completo y longitud del apellido
var consulta = db.Persons
    .Select(p => new {
        NombreCompleto = p.FirstName + " " + p.LastName,
        LargoApellido = p.LastName.Length
    })
    .ToList();

LINQ es una herramienta que nos ayuda a realizar consultas de una manera sencilla.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/11/entity-framework-un-orm-para-net.html
https://learn.microsoft.com/es-es/dotnet/csharp/linq/
https://www.netmentor.es/entrada/linq-csharp