Saltar al contenido principal

Métodos LINQ comunes en C#

LINQ (Consulta Integrada del Lenguaje) ofrece un amplio conjunto de métodos para consultar y manipular datos en C#. A continuación, se muestran ejemplos de algunos métodos LINQ de uso común:

1. Where​

El método Where filtra elementos según una condición.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Where(num => num > 2).ToList();

foreach (var num in result)
{
Console.WriteLine(num); // Salida: 3, 4, 5
}

2. Select​

El método Select proyecta cada elemento de una secuencia en una nueva forma.

string[] fruits = { "apple", "banana", "cherry" };

var result = fruits.Select(fruit => fruit.ToUpper()).ToList();

foreach (var fruit in result)
{
Console.WriteLine(fruit); // Salida: MANZANA, PLÁTANO, CEREZA
}

3. Ordenar por​

El método OrderBy ordena los elementos en orden ascendente.

string[] fruits = { "manzana", "plátano", "cereza" };

var result = fruits.Select(fruit => fruit.ToUpper()).ToList();

foreach (var fruit in result)
{
Console.WriteLine(fruit); // Salida: MANZANA, PLÁTANO, CEREZA
}

4. Ordenar por descendente​

El método OrderByDescending ordena los elementos en orden descendente.

int[] números = { 5, 2, 7, 1, 3 };

var resultado = números.OrderByDescending(num => num).ToList();

foreach (var num in resultado)
{
Console.WriteLine(num); // Salida: 7, 5, 3, 2, 1
}

5. First​

El método First devuelve el primer elemento de una secuencia que cumple una condición.

int[] números = { 1, 2, 3, 4, 5 };

var resultado = números.First(num => num > 2);

Console.WriteLine(resultado); // Salida: 3

6. FirstOrDefault​

El método FirstOrDefault devuelve el primer elemento de una secuencia que cumple una condición, o un valor predeterminado si no se encuentra dicho elemento.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.FirstOrDefault(num => num > 5);

Console.WriteLine(result); // Salida: 0 (valor predeterminado para int)

7. Any​

El método Any determina si algún elemento de una secuencia cumple una condición.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Any(num => num > 3);

Console.WriteLine(result); // Resultado: Verdadero

8. All​

El método All determina si todos los elementos de una secuencia cumplen una condición.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.All(num => num > 0);

Console.WriteLine(result); // Resultado: Verdadero

9. Count​

El método Count devuelve el número de elementos de una secuencia.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Count();

Console.WriteLine(result); // Resultado: 5

10. Sum​

El método Sum calcula la suma de la secuencia de valores numéricos.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Sum();

Console.WriteLine(result); // Resultado: 15

11. Average​

El método Average calcula el promedio de la secuencia de valores numéricos.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Average();

Console.WriteLine(result); // Resultado: 3

12. Mín​

El método Mín devuelve el valor mínimo de una secuencia.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Min();

Console.WriteLine(result); // Salida: 1

13. Máx​

El método Máx devuelve el valor máximo de una secuencia.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Max();

Console.WriteLine(result); // Salida: 5

14. Take​

El método Take devuelve un número específico de elementos contiguos desde el inicio de una secuencia.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Take(3).ToList();

foreach (var num in result)
{
Console.WriteLine(num); // Salida: 1, 2, 3
}

15. Skip​

El método Skip omite un número específico de elementos en una secuencia y luego devuelve los elementos restantes.

int[] numbers = { 1, 2, 3, 4, 5 };

var result = numbers.Skip(2).ToList();

foreach (var num in result)
{
Console.WriteLine(num); // Salida: 3, 4, 5
}

16. Distinct​

El método Distinct devuelve elementos distintos de una secuencia utilizando el comparador de igualdad predeterminado para comparar valores.

int[] numbers = { 1, 2, 2, 3, 4, 4, 5 };

var result = numbers.Distinct();

foreach (var num en resultado)
{
Console.WriteLine(num); // Salida: 1, 2, 3, 4, 5
}

Uso de LINQ con colecciones y bases de datos

LINQ es muy flexible porque se puede aplicar tanto a colecciones en memoria (arrays, listas, diccionarios, etc.) como a fuentes de datos externas como bases de datos mediante Entity Framework.

LINQ con colecciones en memoria​

Cualquier colección que implemente IEnumerable<T> puede ser consultada con LINQ.

Ejemplo con una lista​

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

// Consulta con sintaxis de consulta
var query = from num in numbers
            where num > 2
            orderby num descending
            select num;

// Consulta con sintaxis de métodos
var methodQuery = numbers
    .Where(num => num > 2)
    .OrderByDescending(num => num);

foreach (var num in query)
{
    Console.WriteLine(num); // Imprime: 5, 4, 3
}

Ejemplo con diccionario​

Dictionary<string, int> students = new Dictionary<string, int>
{
    { "Ana", 18 },
    { "Luis", 22 },
    { "Pedro", 19 }
};

var mayoresDeEdad = students
    .Where(s => s.Value >= 18)
    .Select(s => s.Key);

foreach (var nombre in mayoresDeEdad)
{
    Console.WriteLine(nombre); // Imprime: Ana, Luis, Pedro
}

LINQ con bases de datos​

Con Entity Framework (EF Core), LINQ permite trabajar con tablas como si fueran colecciones.

Ejemplo básico​

using (var context = new AppDbContext())
{
    var estudiantes = from e in context.Students
                      where e.Age > 18
                      orderby e.Name
                      select e;

    foreach (var estudiante in estudiantes)
    {
        Console.WriteLine($"{estudiante.Name} - {estudiante.Age}");
    }
}

Ejemplo con sintaxis de métodos​

using (var context = new AppDbContext())
{
    var estudiantes = context.Students
        .Where(e => e.Age > 18)
        .OrderBy(e => e.Name)
        .ToList();

    estudiantes.ForEach(e =>
        Console.WriteLine($"{e.Name} - {e.Age}")
    );
}