LINQ em C#: Where, Select, OrderBy, GroupBy e mais

O LINQ (Language Integrated Query) é uma biblioteca de métodos para filtrar, transformar, ordenar, agrupar e resumir sequências. Adicione using System.Linq; e todo array, List<T>, Dictionary e outro IEnumerable<T> ganha métodos como Where, Select e OrderBy, cada um recebendo uma lambda que diz o que fazer com um elemento.

Uma primeira consulta: sintaxe de métodos e sintaxe de consulta

O LINQ tem duas notações. A sintaxe de métodos encadeia chamadas; a sintaxe de consulta se parece com SQL. O compilador transforma a sintaxe de consulta nas mesmas chamadas de métodos, então elas produzem 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));
    }
}

Saída:

95, 91, 88
95, 91, 88

A sintaxe de métodos é mais comum em código moderno, e alguns operadores (Take, Distinct, Count, First, ToList) só existem como métodos. A sintaxe de consulta brilha em joins e em consultas que introduzem variáveis intermediárias com let. O resto desta página usa a sintaxe de métodos e mostra a sintaxe de consulta onde ela acrescenta algo.

Where e Select: filtrar e projetar

Where mantém os elementos que atendem a uma condição. Select transforma cada elemento em outra coisa. Juntos, eles cobrem a maioria das consultas do dia a dia.

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));
    }
}

Saída:

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 muda os elementos, e Select nunca muda quantos eles são. new { p.Name, WithTax = ... } cria um tipo anônimo, uma classe que o compilador escreve para você, cujas propriedades você lê com a sintaxe de ponto normal. Ele não tem um nome que você possa escrever, então uma variável que guarda um precisa ser declarada com var, e ele serve para resultados que ficam dentro de um método.

OrderBy, ThenBy e ordenação por várias chaves

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));
    }
}

Saída:

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

OrderBy é estável: elementos com chaves iguais ficam na ordem original. Use ThenBy ou ThenByDescending para uma segunda chave. Um segundo OrderBy reordenaria tudo pela própria chave, deixando a primeira chave só como desempate: a prioridade oposta. Na sintaxe de consulta, as chaves são separadas por vírgula: orderby o.Customer, o.Total descending.

Ao contrário de List<T>.Sort, OrderBy não mexe na origem e retorna uma nova sequência.

First, Single, Last e as versões OrDefault

Estes retornam um elemento em vez de uma sequência. As versões simples lançam exceção quando não há nada para retornar; as versões OrDefault retornam o valor padrão do 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"
    }
}

Saída:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

A exceção de First em uma sequência vazia é InvalidOperationException com a mensagem "Sequence contains no elements" (ou "Sequence contains no matching element" quando um predicado não encontrou nada), um dos erros de C# mais pesquisados. Use FirstOrDefault quando "nenhum" é um resultado normal e verifique se é null.

A última linha mostra a armadilha dos tipos de valor: para uma sequência de int, FirstOrDefault retorna 0 quando nada corresponde, o que não dá para distinguir de um 0 de verdade. Filtre com Where e verifique Any() antes, ou no .NET 6 em diante passe o seu próprio padrão: scores.FirstOrDefault(s => s > 100, -1).

Single é para "exatamente um": lança exceção se não houver nenhum ou houver mais de um, o que o torna tanto uma afirmação quanto uma consulta.

Any, All, Count e 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
    }
}

Saída:

True
True
True
3
True
True

Any() para na primeira correspondência, então items.Any() é a forma certa de perguntar "existe alguma coisa?". items.Count() > 0 lê a propriedade Count quando a origem é uma coleção como uma lista ou um array, mas em uma consulta ou outra sequência preguiçosa ele percorre todos os elementos antes. All em uma sequência vazia retorna true, porque não existe elemento que falhe na condição.

Sum, Average, Min e 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);
        }
    }
}

Saída:

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

Sum de uma sequência vazia é 0, mas Average, Min e Max de uma sequência vazia de números lançam InvalidOperationException: não existe uma resposta razoável. Proteja com Any(), ou use DefaultIfEmpty() antes: empty.DefaultIfEmpty(0).Average().

Distinct, Take e 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)));
    }
}

Saída:

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 mantém a primeira ocorrência de cada valor, em ordem. Skip(n).Take(m) é o padrão clássico de paginação, e TakeWhile/SkipWhile param ou começam no primeiro elemento que falha em uma condição. Enumerable.Range(start, count) gera uma sequência de inteiros sem um array.

GroupBy

GroupBy distribui os elementos em grupos por uma chave. Cada grupo tem uma Key e é em si uma sequência, então você pode agregá-lo.

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));
    }
}

Saída:

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

Os grupos saem na ordem em que as chaves aparecem pela primeira vez na origem (North, South, East), não ordenados; adicione OrderBy(g => g.Key) se precisar disso. Na sintaxe de consulta, group X by K escolhe o que entra em cada grupo (aqui só o nome do vendedor) e into g dá nome ao grupo para que a consulta possa continuar.

ToList, ToArray e ToDictionary

Os métodos To... executam a consulta e guardam os 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);
        }
    }
}

Saída:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary lança ArgumentException quando dois elementos produzem a mesma chave, igual a Dictionary.Add. Se duplicatas são esperadas, agrupe antes (como wordCounts faz) ou use ToLookup, que mapeia cada chave para uma sequência de valores.

Execução adiada

Where, Select, OrderBy, GroupBy e a maioria dos outros operadores retornam um objeto de consulta e não fazem nenhum trabalho até que algo o enumere. Isso tem duas consequências que vale a pena 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());
    }
}

Saída:

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

A primeira consulta viu o 99 mesmo ele tendo sido adicionado depois de a consulta ser escrita: o filtro executou quando string.Join a enumerou. A segunda consulta imprimiu suas conversões duas vezes porque Count() e Max() a enumeraram do zero cada um. Com uma lambda barata isso é só trabalho desperdiçado; com uma consulta a banco de dados, uma leitura de arquivo ou um número aleatório dentro da lambda, as duas passadas podem retornar dados diferentes. Quando você vai usar um resultado mais de uma vez, materialize-o com ToList() ou ToArray().

Operadores que retornam um único valor (Count, Sum, First, Any, Max) e os métodos To... executam imediatamente. Veja IEnumerable e yield para entender como essa preguiça é construída.

Referência rápida

Erros comuns

• First() em uma sequência que pode estar vazia. Lança "Sequence contains no elements"; use FirstOrDefault e verifique.
• Duas chamadas a OrderBy. A segunda chave vira a principal; use ThenBy.
• Enumerar uma consulta várias vezes. O trabalho se repete; chame ToList() uma vez.
• Esperar que uma consulta tire uma foto da origem. Ela lê a origem quando é enumerada, não quando é escrita.
• Average, Min, Max em uma sequência vazia. Eles lançam exceção; proteja com Any() ou DefaultIfEmpty.
• Count() > 0 para testar se há elementos. Any() para no primeiro.