Docs ejecutables de C#: LINQ

Q: ¿Qué diferencia hay entre Select y Where en LINQ?

Where filtra: conserva los elementos para los que la lambda devuelve true y los deja sin cambios. Select proyecta: transforma cada elemento en otra cosa, como una propiedad o un objeto nuevo, y mantiene el mismo número de elementos. Suelen encadenarse: people.Where(p => p.Age >= 18).Select(p => p.Name).

Q: ¿Qué diferencia hay entre First y FirstOrDefault?

First() devuelve el primer elemento (o la primera coincidencia de un predicado) y lanza InvalidOperationException ("Sequence contains no elements" o "no matching element") cuando no hay ninguno. FirstOrDefault() devuelve en su lugar el valor por defecto del tipo: null en las clases y 0 en int, así que comprueba el resultado antes de usarlo.

Q: ¿Cómo ordeno por dos campos con LINQ?

Encadena ThenBy después de OrderBy: orders.OrderBy(o => o.Customer).ThenByDescending(o => o.Total). Llamar dos veces a OrderBy no funciona: la segunda llamada vuelve a ordenar toda la secuencia, así que su clave pasa a ser la principal y la primera solo deshace empates, lo contrario de lo que se pretendía.

Q: ¿Cómo funciona GroupBy en LINQ?

GroupBy(x => key) devuelve un grupo por cada clave distinta. Cada grupo es un IGrouping : tiene una propiedad Key y es a su vez una secuencia de los elementos con esa clave, así que puedes llamar a Count(), Sum() o Select sobre él. Los grupos salen en el orden en que aparecen por primera vez sus claves.

LINQ (Language Integrated Query) es una biblioteca de métodos para filtrar, transformar, ordenar, agrupar y resumir secuencias. Añade using System.Linq; y todo array, List<T>, Dictionary y demás IEnumerable<T> gana métodos como Where, Select y OrderBy, cada uno de los cuales recibe una lambda que dice qué hacer con un elemento.

Una primera consulta: sintaxis de métodos y sintaxis de consulta

LINQ tiene dos notaciones. La sintaxis de métodos encadena llamadas; la sintaxis de consulta se lee como SQL. El compilador convierte la sintaxis de consulta en las mismas llamadas a métodos, así que producen resultados idénticos.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79, 91 };

        // Method syntax
        IEnumerable<int> high = scores
            .Where(s => s >= 80)
            .OrderByDescending(s => s);

        // Query syntax: the same query
        IEnumerable<int> high2 =
            from s in scores
            where s >= 80
            orderby s descending
            select s;

        Console.WriteLine(string.Join(", ", high));
        Console.WriteLine(string.Join(", ", high2));
    }
}

Salida:

95, 91, 88
95, 91, 88

La sintaxis de métodos es más habitual en el código moderno, y algunos operadores (Take, Distinct, Count, First, ToList) solo existen como métodos. La sintaxis de consulta brilla en los joins y en las consultas que introducen variables intermedias con let. El resto de esta página usa la sintaxis de métodos y muestra la sintaxis de consulta donde aporta algo.

Where y Select: filtrar y proyectar

Where conserva los elementos que cumplen una condición. Select convierte cada elemento en otra cosa. Juntos cubren la mayoría de las consultas del día a día.

using System;
using System.Collections.Generic;
using System.Linq;

class Product
{
    public string Name;
    public string Category;
    public decimal Price;
    public Product(string n, string c, decimal p) { Name = n; Category = c; Price = p; }
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new Product("Mug", "Kitchen", 8.50m),
            new Product("Lamp", "Home", 32.00m),
            new Product("Kettle", "Kitchen", 27.00m),
            new Product("Rug", "Home", 120.00m),
        };

        IEnumerable<string> cheapNames = products
            .Where(p => p.Price < 30m)
            .Select(p => p.Name);
        Console.WriteLine(string.Join(", ", cheapNames));

        var labels = products.Select(p => p.Name.ToUpper() + " $" + p.Price);
        Console.WriteLine(string.Join(" | ", labels));

        // An anonymous type holds a few properties without declaring a class.
        var summary = products
            .Where(p => p.Category == "Home")
            .Select(p => new { p.Name, WithTax = Math.Round(p.Price * 1.2m, 2) });
        foreach (var item in summary)
        {
            Console.WriteLine(item.Name + ": " + item.WithTax);
        }

        // Select also has an overload with the index.
        var numbered = products.Select((p, i) => (i + 1) + ". " + p.Name);
        Console.WriteLine(string.Join(" ", numbered));
    }
}

Salida:

Mug, Kettle
MUG $8.50 | LAMP $32.00 | KETTLE $27.00 | RUG $120.00
Lamp: 38.40
Rug: 144.00
1. Mug 2. Lamp 3. Kettle 4. Rug

Where nunca cambia los elementos, y Select nunca cambia cuántos hay. new { p.Name, WithTax = ... } crea un tipo anónimo, una clase que el compilador escribe por ti, cuyas propiedades lees con la sintaxis de punto normal. No tiene un nombre que puedas escribir, así que una variable que contenga uno debe declararse con var, y encaja con resultados que se quedan dentro de un método.

OrderBy, ThenBy y ordenar por varias claves

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var orders = new List<(string Customer, decimal Total)>
        {
            ("Ben", 40m), ("Ana", 15m), ("Ben", 90m), ("Ana", 60m), ("Chloe", 25m),
        };

        var sorted = orders
            .OrderBy(o => o.Customer)            // first key
            .ThenByDescending(o => o.Total);     // tie breaker
        foreach (var o in sorted)
        {
            Console.WriteLine(o.Customer + " " + o.Total);
        }

        var query =
            from o in orders
            orderby o.Total descending
            select o.Customer;
        Console.WriteLine(string.Join(", ", query));
    }
}

Salida:

Ana 60
Ana 15
Ben 90
Ben 40
Chloe 25
Ben, Ana, Ben, Chloe, Ana

OrderBy es estable: los elementos con claves iguales conservan su orden original. Usa ThenBy o ThenByDescending para una segunda clave. Un segundo OrderBy volvería a ordenarlo todo por su propia clave y dejaría la primera clave como simple desempate: la prioridad contraria. En la sintaxis de consulta, las claves se separan con comas: orderby o.Customer, o.Total descending.

A diferencia de List<T>.Sort, OrderBy no toca el origen y devuelve una secuencia nueva.

First, Single, Last y sus versiones OrDefault

Estos devuelven un elemento en lugar de una secuencia. Las versiones simples lanzan una excepción cuando no hay nada que devolver; las versiones OrDefault devuelven el valor por defecto del tipo.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Bea", "Chloe" };

        Console.WriteLine(names.First());
        Console.WriteLine(names.First(n => n.StartsWith("B")));
        Console.WriteLine(names.Last(n => n.StartsWith("B")));
        Console.WriteLine(names.FirstOrDefault(n => n.StartsWith("Z")) == null);

        try
        {
            names.First(n => n.StartsWith("Z"));
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("First: " + e.GetType().Name);
        }

        try
        {
            names.Single(n => n.StartsWith("B")); // two matches
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Single: " + e.GetType().Name);
        }

        int[] scores = { 72, 95 };
        Console.WriteLine(scores.FirstOrDefault(s => s > 100)); // 0, not "missing"
    }
}

Salida:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

La excepción de First sobre una secuencia vacía es InvalidOperationException con el mensaje "Sequence contains no elements" (o "Sequence contains no matching element" cuando un predicado no coincidió con nada), uno de los errores de C# más buscados. Usa FirstOrDefault cuando "ninguno" sea un resultado normal y comprueba si es null.

La última línea muestra la trampa de los tipos de valor: en una secuencia de int, FirstOrDefault devuelve 0 cuando nada coincide, lo que no se distingue de un 0 real. Filtra con Where y comprueba antes Any(), o en .NET 6 y posteriores pasa tu propio valor por defecto: scores.FirstOrDefault(s => s > 100, -1).

Single es para "exactamente uno": lanza una excepción si no hay ninguno o si hay más de uno, lo que lo convierte tanto en una aserción como en una consulta.

Any, All, Count y Contains

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] ages = { 17, 22, 35, 41, 16 };

        Console.WriteLine(ages.Any());                 // is it non-empty?
        Console.WriteLine(ages.Any(a => a < 18));      // at least one minor?
        Console.WriteLine(ages.All(a => a >= 16));     // everyone 16 or older?
        Console.WriteLine(ages.Count(a => a >= 18));   // how many adults?
        Console.WriteLine(ages.Contains(35));

        int[] none = { };
        Console.WriteLine(none.All(a => a > 100));      // true for an empty sequence
    }
}

Salida:

True
True
True
3
True
True

Any() se detiene en la primera coincidencia, así que items.Any() es la forma correcta de preguntar "¿hay algo?". items.Count() > 0 lee la propiedad Count cuando el origen es una colección como una lista o un array, pero en una consulta u otra secuencia perezosa recorre antes todos los elementos. All sobre una secuencia vacía devuelve true, porque no hay ningún elemento que incumpla la condición.

Sum, Average, Min y Max

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var cart = new List<(string Item, decimal Price, int Qty)>
        {
            ("Tea", 4.50m, 2), ("Honey", 7.25m, 1), ("Cups", 3.00m, 4),
        };

        Console.WriteLine("Total: " + cart.Sum(c => c.Price * c.Qty));
        Console.WriteLine("Items: " + cart.Sum(c => c.Qty));
        Console.WriteLine("Priciest: " + cart.Max(c => c.Price));
        Console.WriteLine("Average price: " + cart.Average(c => c.Price).ToString("F2"));

        var empty = new List<int>();
        Console.WriteLine(empty.Sum());
        try
        {
            empty.Average();
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Average: " + e.GetType().Name);
        }
    }
}

Salida:

Total: 28.25
Items: 7
Priciest: 7.25
Average price: 4.92
0
Average: InvalidOperationException

Sum de una secuencia vacía es 0, pero Average, Min y Max de una secuencia vacía de números lanzan InvalidOperationException: no hay una respuesta con sentido. Protégete con Any(), o usa antes DefaultIfEmpty(): empty.DefaultIfEmpty(0).Average().

Distinct, Take y Skip

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] visits = { "home", "shop", "home", "cart", "shop", "home" };
        Console.WriteLine(string.Join(", ", visits.Distinct()));

        int[] ids = Enumerable.Range(1, 23).ToArray(); // 1..23
        int pageSize = 10;
        for (int page = 0; page * pageSize < ids.Length; page++)
        {
            var items = ids.Skip(page * pageSize).Take(pageSize);
            Console.WriteLine("Page " + (page + 1) + ": " + string.Join(" ", items));
        }

        int[] temps = { 12, 15, 21, 24, 19, 11 };
        Console.WriteLine(string.Join(", ", temps.TakeWhile(t => t < 20)));
    }
}

Salida:

home, shop, cart
Page 1: 1 2 3 4 5 6 7 8 9 10
Page 2: 11 12 13 14 15 16 17 18 19 20
Page 3: 21 22 23
12, 15

Distinct conserva en orden la primera aparición de cada valor. Skip(n).Take(m) es el patrón habitual de paginación, y TakeWhile/SkipWhile se detienen o empiezan en el primer elemento que incumple una condición. Enumerable.Range(start, count) genera una secuencia de enteros sin necesidad de un array.

GroupBy

GroupBy reparte los elementos en cubos según una clave. Cada grupo tiene una Key y es a su vez una secuencia, así que puedes agregarlo.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var sales = new List<(string Region, string Rep, int Amount)>
        {
            ("North", "Ana", 300), ("South", "Ben", 150), ("North", "Chloe", 200),
            ("East", "Dev", 350), ("South", "Eli", 250), ("North", "Ana", 100),
        };

        foreach (var g in sales.GroupBy(s => s.Region))
        {
            Console.WriteLine(g.Key + ": " + g.Count() + " sales, total " + g.Sum(s => s.Amount));
        }

        var top = sales
            .GroupBy(s => s.Rep)
            .Select(g => new { Rep = g.Key, Total = g.Sum(s => s.Amount) })
            .OrderByDescending(x => x.Total)
            .First();
        Console.WriteLine("Top rep: " + top.Rep + " " + top.Total);

        var byRegion =
            from s in sales
            group s.Rep by s.Region into g
            select g.Key + " -> " + string.Join("/", g);
        Console.WriteLine(string.Join("; ", byRegion));
    }
}

Salida:

North: 3 sales, total 600
South: 2 sales, total 400
East: 1 sales, total 350
Top rep: Ana 400
North -> Ana/Chloe/Ana; South -> Ben/Eli; East -> Dev

Los grupos salen en el orden en que sus claves aparecen por primera vez en el origen (North, South, East), no ordenados; añade OrderBy(g => g.Key) si lo necesitas. En la sintaxis de consulta, group X by K elige qué va en cada grupo (aquí solo el nombre del comercial) e into g da nombre al grupo para que la consulta pueda continuar.

ToList, ToArray y ToDictionary

Los métodos To... ejecutan la consulta y guardan los resultados.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var users = new List<(int Id, string Email)>
        {
            (1, "ana@x.com"), (2, "ben@x.com"), (3, "cy@x.com"),
        };

        Dictionary<int, string> byId = users.ToDictionary(u => u.Id, u => u.Email);
        Console.WriteLine(byId[2]);

        var wordCounts = "to be or not to be".Split(' ')
            .GroupBy(w => w)
            .ToDictionary(g => g.Key, g => g.Count());
        Console.WriteLine(wordCounts["be"]);

        try
        {
            users.ToDictionary(u => u.Email.Length); // two emails of length 9
        }
        catch (ArgumentException e)
        {
            Console.WriteLine("ToDictionary: " + e.GetType().Name);
        }
    }
}

Salida:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary lanza ArgumentException cuando dos elementos producen la misma clave, igual que Dictionary.Add. Si se esperan duplicados, agrupa primero (como hace wordCounts) o usa ToLookup, que asocia cada clave a una secuencia de valores.

Ejecución diferida

Where, Select, OrderBy, GroupBy y la mayoría de los demás operadores devuelven un objeto consulta y no hacen ningún trabajo hasta que algo lo enumera. Eso tiene dos consecuencias que conviene ver:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var prices = new List<int> { 10, 25, 40 };

        IEnumerable<int> expensive = prices.Where(p => p > 20); // nothing runs yet
        prices.Add(99);                                        // added after the query
        Console.WriteLine(string.Join(", ", expensive));        // runs now, sees 99

        IEnumerable<int> logged = prices.Select(p =>
        {
            Console.WriteLine("  converting " + p);
            return p * 100;
        });

        Console.WriteLine("Count: " + logged.Count());          // runs the query once
        Console.WriteLine("Max: " + logged.Max());              // and again

        List<int> cached = logged.ToList();                     // run once, keep results
        Console.WriteLine("Cached: " + cached.Count + ", " + cached.Max());
    }
}

Salida:

25, 40, 99
  converting 10
  converting 25
  converting 40
  converting 99
Count: 4
  converting 10
  converting 25
  converting 40
  converting 99
Max: 9900
  converting 10
  converting 25
  converting 40
  converting 99
Cached: 4, 9900

La primera consulta vio el 99 aunque se añadió después de escribir la consulta: el filtro se ejecutó cuando string.Join la enumeró. La segunda consulta imprimió sus conversiones dos veces porque Count() y Max() la enumeraron cada uno desde cero. Con una lambda barata, eso solo es trabajo desperdiciado; con una consulta a una base de datos, una lectura de archivo o un número aleatorio dentro de la lambda, las dos pasadas pueden devolver datos distintos. Cuando vayas a usar un resultado más de una vez, materialízalo con ToList() o ToArray().

Los operadores que devuelven un solo valor (Count, Sum, First, Any, Max) y los métodos To... se ejecutan de inmediato. Consulta IEnumerable y yield para ver cómo se construye esa pereza.

Referencia rápida

Operador	Hace	Devuelve
`Where(x => cond)`	Filtrar	Secuencia (diferida)
`Select(x => expr)`	Transformar cada uno	Secuencia (diferida)
`SelectMany(x => seq)`	Aplanar secuencias anidadas	Secuencia (diferida)
`OrderBy`, `ThenBy` (+`Descending`)	Ordenar, estable	Secuencia (diferida)
`GroupBy(x => key)`	Repartir por clave	Secuencia de grupos (diferida)
`Distinct`, `Take`, `Skip`	Quitar duplicados, paginar	Secuencia (diferida)
`First`, `Single`, `Last`	Un elemento, excepción si no hay	Elemento
`FirstOrDefault` etc.	Un elemento o el valor por defecto	Elemento
`Any`, `All`, `Contains`	Comprobar	`bool`
`Count`, `Sum`, `Min`, `Max`, `Average`	Agregar	Número
`ToList`, `ToArray`, `ToDictionary`	Ejecutar y guardar	Colección

Errores comunes

First() sobre una secuencia que puede estar vacía. Lanza "Sequence contains no elements"; usa FirstOrDefault y comprueba.
Dos llamadas a OrderBy. La segunda clave pasa a ser la principal; usa ThenBy.
Enumerar una consulta varias veces. El trabajo se repite; llama a ToList() una vez.
Esperar que una consulta haga una instantánea de su origen. Lee el origen cuando se enumera, no cuando se escribe.
Average, Min, Max sobre una secuencia vacía. Lanzan una excepción; protégete con Any() o DefaultIfEmpty.
Count() > 0 para comprobar si hay elementos. Any() se detiene en el primero.

Preguntas frecuentes

¿Qué es LINQ en C#?

LINQ (Language Integrated Query) es un conjunto de métodos de extensión de System.Linq, como Where, Select, OrderBy y GroupBy, que funcionan con cualquier IEnumerable<T>: arrays, listas, diccionarios y resultados de otras consultas. C# tiene también una sintaxis de consulta (from x in items where ... select ...) que el compilador traduce a las mismas llamadas a métodos.

¿Qué diferencia hay entre Select y Where en LINQ?

Where filtra: conserva los elementos para los que la lambda devuelve true y los deja sin cambios. Select proyecta: transforma cada elemento en otra cosa, como una propiedad o un objeto nuevo, y mantiene el mismo número de elementos. Suelen encadenarse: people.Where(p => p.Age >= 18).Select(p => p.Name).

¿Qué diferencia hay entre First y FirstOrDefault?

First() devuelve el primer elemento (o la primera coincidencia de un predicado) y lanza InvalidOperationException ("Sequence contains no elements" o "no matching element") cuando no hay ninguno. FirstOrDefault() devuelve en su lugar el valor por defecto del tipo: null en las clases y 0 en int, así que comprueba el resultado antes de usarlo.

¿Cómo ordeno por dos campos con LINQ?

Encadena ThenBy después de OrderBy: orders.OrderBy(o => o.Customer).ThenByDescending(o => o.Total). Llamar dos veces a OrderBy no funciona: la segunda llamada vuelve a ordenar toda la secuencia, así que su clave pasa a ser la principal y la primera solo deshace empates, lo contrario de lo que se pretendía.

¿Cómo funciona GroupBy en LINQ?

GroupBy(x => key) devuelve un grupo por cada clave distinta. Cada grupo es un IGrouping<TKey, TElement>: tiene una propiedad Key y es a su vez una secuencia de los elementos con esa clave, así que puedes llamar a Count(), Sum() o Select sobre él. Los grupos salen en el orden en que aparecen por primera vez sus claves.

¿Qué es la ejecución diferida en LINQ?

La mayoría de los operadores de LINQ no se ejecutan cuando los llamas; devuelven una consulta que se ejecuta cada vez que se enumera (con foreach, ToList(), Count(), etc.). Por eso una consulta ve los cambios hechos en el origen después de definirla, y enumerarla dos veces hace el trabajo dos veces. Llama a ToList() o ToArray() para ejecutarla una vez y conservar los resultados.

Conceptos relacionados