LINQ w C#: Where, Select, OrderBy, GroupBy i nie tylko

LINQ (Language Integrated Query) to biblioteka metod do filtrowania, przekształcania, sortowania, grupowania i podsumowywania sekwencji. Dodaj using System.Linq;, a każda tablica, List<T>, Dictionary i inny IEnumerable<T> zyskuje metody takie jak Where, Select i OrderBy, z których każda przyjmuje lambdę mówiącą, co zrobić z jednym elementem.

Pierwsze zapytanie: składnia metod i składnia zapytań

LINQ ma dwie notacje. Składnia metod łączy wywołania w łańcuch; składnia zapytań przypomina SQL. Kompilator zamienia składnię zapytań na te same wywołania metod, więc dają identyczne wyniki.

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

Wynik:

95, 91, 88
95, 91, 88

Składnia metod jest częstsza we współczesnym kodzie, a niektóre operatory (Take, Distinct, Count, First, ToList) istnieją tylko jako metody. Składnia zapytań błyszczy przy złączeniach i zapytaniach, które wprowadzają zmienne pośrednie przez let. Reszta tej strony używa składni metod, a składnię zapytań pokazuje tam, gdzie coś wnosi.

Where i Select: filtrowanie i projekcja

Where zachowuje elementy spełniające warunek. Select zamienia każdy element na coś innego. Razem pokrywają większość codziennych zapytań.

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

Wynik:

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 nigdy nie zmienia elementów, a Select nigdy nie zmienia ich liczby. new { p.Name, WithTax = ... } tworzy typ anonimowy, czyli klasę, którą kompilator pisze za ciebie, a jej właściwości odczytujesz zwykłą składnią z kropką. Nie ma nazwy, którą można zapisać, więc zmienną, która go przechowuje, trzeba zadeklarować przez var; pasuje do wyników, które nie wychodzą poza jedną metodę.

OrderBy, ThenBy i sortowanie według kilku kluczy

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

Wynik:

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

OrderBy jest stabilne: elementy z równymi kluczami zachowują pierwotną kolejność. Do drugiego klucza użyj ThenBy albo ThenByDescending. Drugie OrderBy posortowałoby wszystko od nowa według własnego klucza, a pierwszy klucz zostałby tylko rozstrzygaczem remisów: priorytet odwrotny do zamierzonego. W składni zapytań klucze oddziela się przecinkami: orderby o.Customer, o.Total descending.

W przeciwieństwie do List<T>.Sort, OrderBy nie rusza źródła i zwraca nową sekwencję.

First, Single, Last i ich wersje OrDefault

Zwracają jeden element zamiast sekwencji. Zwykłe wersje rzucają wyjątek, gdy nie ma czego zwrócić; wersje OrDefault zwracają wartość domyślną typu.

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"
    }
}

Wynik:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

Wyjątek z First na pustej sekwencji to InvalidOperationException z komunikatem "Sequence contains no elements" (albo "Sequence contains no matching element", gdy predykat nic nie dopasował), jeden z najczęściej wyszukiwanych błędów C#. Używaj FirstOrDefault, gdy "brak" to normalny wynik, i sprawdzaj null.

Ostatnia linia pokazuje pułapkę typów wartościowych: dla sekwencji int metoda FirstOrDefault zwraca 0, gdy nic nie pasuje, a tego nie da się odróżnić od prawdziwego 0. Filtruj przez Where i najpierw sprawdź Any() albo, w .NET 6 i nowszych, przekaż własną wartość domyślną: scores.FirstOrDefault(s => s > 100, -1).

Single służy do przypadku "dokładnie jeden": rzuca wyjątek, gdy nie ma żadnego albo jest więcej niż jeden, co czyni go w równym stopniu asercją, co zapytaniem.

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

Wynik:

True
True
True
3
True
True

Any() zatrzymuje się na pierwszym dopasowaniu, więc items.Any() to właściwy sposób, by zapytać "czy coś tu jest?". items.Count() > 0 odczytuje właściwość Count, gdy źródło jest kolekcją, taką jak lista lub tablica, ale na zapytaniu albo innej leniwej sekwencji najpierw przechodzi przez każdy element. All na pustej sekwencji zwraca true, bo nie ma elementu, który nie spełnia warunku.

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

Wynik:

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

Sum pustej sekwencji to 0, ale Average, Min i Max pustej sekwencji liczb rzucają InvalidOperationException: nie ma sensownej odpowiedzi. Zabezpiecz się przez Any() albo najpierw użyj DefaultIfEmpty(): empty.DefaultIfEmpty(0).Average().

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

Wynik:

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 zachowuje pierwsze wystąpienie każdej wartości w kolejności. Skip(n).Take(m) to standardowy wzorzec stronicowania, a TakeWhile/SkipWhile kończą lub zaczynają na pierwszym elemencie, który nie spełnia warunku. Enumerable.Range(start, count) generuje sekwencję liczb całkowitych bez tablicy.

GroupBy

GroupBy rozkłada elementy do kubełków według klucza. Każda grupa ma Key i sama jest sekwencją, więc możesz ją agregować.

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

Wynik:

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

Grupy pojawiają się w kolejności pierwszego wystąpienia ich kluczy w źródle (North, South, East), a nie posortowane; dodaj OrderBy(g => g.Key), jeśli tego potrzebujesz. W składni zapytań group X by K wybiera, co trafia do każdej grupy (tu tylko imię przedstawiciela), a into g nadaje grupie nazwę, żeby zapytanie mogło być kontynuowane.

ToList, ToArray i ToDictionary

Metody To... wykonują zapytanie i zapisują wyniki.

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

Wynik:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary rzuca ArgumentException, gdy dwa elementy dają ten sam klucz, tak jak Dictionary.Add. Jeśli spodziewasz się duplikatów, najpierw pogrupuj (jak robi to wordCounts) albo użyj ToLookup, które mapuje każdy klucz na sekwencję wartości.

Wykonanie odroczone

Where, Select, OrderBy, GroupBy i większość innych operatorów zwraca obiekt zapytania i nic nie robi, dopóki coś go nie wyliczy. Ma to dwie konsekwencje, które warto zobaczyć:

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

Wynik:

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

Pierwsze zapytanie zobaczyło 99, choć dodano je po napisaniu zapytania: filtr wykonał się, gdy string.Join je wyliczył. Drugie zapytanie wypisało swoje konwersje dwa razy, bo Count() i Max() wyliczyły je od początku, każde osobno. Przy taniej lambdzie to tylko zmarnowana praca; przy zapytaniu do bazy danych, odczycie pliku albo liczbie losowej w lambdzie oba przejścia mogą zwrócić różne dane. Gdy użyjesz wyniku więcej niż raz, zmaterializuj go przez ToList() albo ToArray().

Operatory zwracające pojedynczą wartość (Count, Sum, First, Any, Max) oraz metody To... wykonują się natychmiast. Jak zbudowana jest ta leniwość, pokazuje strona o IEnumerable i yield.

Ściągawka

Typowe błędy

• First() na sekwencji, która może być pusta. Rzuca "Sequence contains no elements"; użyj FirstOrDefault i sprawdź wynik.
• Dwa wywołania OrderBy. Drugi klucz staje się głównym; użyj ThenBy.
• Wielokrotne wyliczanie zapytania. Praca się powtarza; wywołaj raz ToList().
• Oczekiwanie, że zapytanie zrobi migawkę źródła. Czyta źródło w chwili wyliczenia, a nie zapisania.
• Average, Min, Max na pustej sekwencji. Rzucają wyjątek; zabezpiecz się przez Any() albo DefaultIfEmpty.
• Count() > 0 do sprawdzania, czy są elementy. Any() zatrzymuje się na pierwszym.