C# LINQ: Where, Select, OrderBy, GroupBy und mehr

LINQ (Language Integrated Query) ist eine Bibliothek von Methoden zum Filtern, Transformieren, Sortieren, Gruppieren und Zusammenfassen von Sequenzen. Füge using System.Linq; hinzu, und jedes Array, jede List<T>, jedes Dictionary und jedes andere IEnumerable<T> bekommt Methoden wie Where, Select und OrderBy, die jeweils ein Lambda nehmen, das sagt, was mit einem Element passieren soll.

Eine erste Abfrage: Methodensyntax und Abfragesyntax

LINQ hat zwei Schreibweisen. Die Methodensyntax verkettet Aufrufe; die Abfragesyntax liest sich wie SQL. Der Compiler macht aus der Abfragesyntax dieselben Methodenaufrufe, beide liefern also identische Ergebnisse.

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

Ausgabe:

95, 91, 88
95, 91, 88

Die Methodensyntax ist in modernem Code verbreiteter, und einige Operatoren (Take, Distinct, Count, First, ToList) gibt es nur als Methoden. Die Abfragesyntax glänzt bei Joins und bei Abfragen, die mit let Zwischenvariablen einführen. Der Rest dieser Seite verwendet die Methodensyntax und zeigt die Abfragesyntax dort, wo sie etwas beiträgt.

Where und Select: filtern und projizieren

Where behält die Elemente, die eine Bedingung erfüllen. Select verwandelt jedes Element in etwas anderes. Zusammen decken sie die meisten Alltagsabfragen ab.

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

Ausgabe:

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 ändert nie Elemente, und Select ändert nie ihre Anzahl. new { p.Name, WithTax = ... } erzeugt einen anonymen Typ, eine Klasse, die der Compiler für dich schreibt und deren Properties du mit normaler Punktsyntax liest. Er hat keinen Namen, den du schreiben könntest, eine Variable, die einen enthält, muss also mit var deklariert werden, und er passt zu Ergebnissen, die innerhalb einer Methode bleiben.

OrderBy, ThenBy und Sortieren nach mehreren Schlüsseln

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

Ausgabe:

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

OrderBy ist stabil: Elemente mit gleichen Schlüsseln bleiben in ihrer ursprünglichen Reihenfolge. Nimm ThenBy oder ThenByDescending für einen zweiten Schlüssel. Ein zweites OrderBy würde alles nach seinem eigenen Schlüssel neu sortieren und den ersten Schlüssel nur noch bei Gleichstand entscheiden lassen: die umgekehrte Priorität. In der Abfragesyntax werden die Schlüssel durch Kommas getrennt: orderby o.Customer, o.Total descending.

Anders als List<T>.Sort lässt OrderBy die Quelle unangetastet und gibt eine neue Sequenz zurück.

First, Single, Last und ihre OrDefault-Varianten

Diese geben ein Element statt einer Sequenz zurück. Die einfachen Varianten werfen, wenn es nichts zurückzugeben gibt; die Varianten mit OrDefault geben den Standardwert des Typs zurück.

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

Ausgabe:

Ana
Ben
Bea
True
First: InvalidOperationException
Single: InvalidOperationException
0

Die Exception von First auf einer leeren Sequenz ist eine InvalidOperationException mit der Meldung „Sequence contains no elements“ (oder „Sequence contains no matching element“, wenn ein Prädikat auf nichts passte), einer der meistgesuchten C#-Fehler. Nimm FirstOrDefault, wenn „keines“ ein normales Ergebnis ist, und prüfe auf null.

Die letzte Zeile zeigt die Falle bei Werttypen: Bei einer int-Sequenz gibt FirstOrDefault 0 zurück, wenn nichts passt, und das lässt sich nicht von einer echten 0 unterscheiden. Filtere mit Where und prüfe zuerst Any(), oder übergib ab .NET 6 deinen eigenen Standardwert: scores.FirstOrDefault(s => s > 100, -1).

Single steht für „genau eines“: Es wirft, wenn es keines oder mehr als eines gibt, und ist damit ebenso eine Zusicherung wie eine Abfrage.

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

Ausgabe:

True
True
True
3
True
True

Any() hört beim ersten Treffer auf, items.Any() ist also der richtige Weg zu fragen „gibt es überhaupt etwas?“. items.Count() > 0 liest die Property Count, wenn die Quelle eine Collection wie eine Liste oder ein Array ist, durchläuft bei einer Abfrage oder einer anderen verzögerten Sequenz aber zuerst jedes Element. All gibt bei einer leeren Sequenz true zurück, weil es kein Element gibt, das die Bedingung verletzt.

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

Ausgabe:

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

Sum einer leeren Sequenz ist 0, aber Average, Min und Max einer leeren Zahlensequenz werfen InvalidOperationException: Es gibt keine sinnvolle Antwort. Sichere mit Any() ab oder nimm vorher DefaultIfEmpty(): empty.DefaultIfEmpty(0).Average().

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

Ausgabe:

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 behält das erste Vorkommen jedes Werts in der Reihenfolge. Skip(n).Take(m) ist das Standardmuster für Seitenaufteilung, und TakeWhile/SkipWhile hören beim ersten Element auf oder beginnen dort, das eine Bedingung verletzt. Enumerable.Range(start, count) erzeugt eine Folge von Ganzzahlen ohne Array.

GroupBy

GroupBy sortiert Elemente nach einem Schlüssel in Gruppen. Jede Gruppe hat einen Key und ist selbst eine Sequenz, du kannst sie also aggregieren.

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

Ausgabe:

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

Die Gruppen erscheinen in der Reihenfolge, in der ihre Schlüssel zuerst in der Quelle auftauchen (North, South, East), nicht sortiert; ergänze OrderBy(g => g.Key), wenn du das brauchst. In der Abfragesyntax wählt group X by K, was in jede Gruppe kommt (hier nur der Name des Vertreters), und into g benennt die Gruppe, damit die Abfrage weitergehen kann.

ToList, ToArray und ToDictionary

Die Methoden To... führen die Abfrage aus und speichern die Ergebnisse.

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

Ausgabe:

ben@x.com
2
ToDictionary: ArgumentException

ToDictionary wirft ArgumentException, wenn zwei Elemente denselben Schlüssel erzeugen, genau wie Dictionary.Add. Wenn Duplikate zu erwarten sind, gruppiere zuerst (wie es wordCounts tut) oder nimm ToLookup, das jeden Schlüssel auf eine Sequenz von Werten abbildet.

Verzögerte Ausführung

Where, Select, OrderBy, GroupBy und die meisten anderen Operatoren geben ein Abfrageobjekt zurück und tun nichts, bis etwas es durchläuft. Das hat zwei Folgen, die man gesehen haben sollte:

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

Ausgabe:

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

Die erste Abfrage hat 99 gesehen, obwohl es erst nach dem Schreiben der Abfrage hinzugefügt wurde: Der Filter lief, als string.Join sie durchlief. Die zweite Abfrage hat ihre Umwandlungen zweimal ausgegeben, weil Count() und Max() sie jeweils von vorn durchlaufen haben. Bei einem billigen Lambda ist das nur verschwendete Arbeit; bei einer Datenbankabfrage, einem Dateizugriff oder einer Zufallszahl im Lambda können die beiden Durchläufe unterschiedliche Daten liefern. Wenn du ein Ergebnis mehr als einmal verwendest, materialisiere es mit ToList() oder ToArray().

Operatoren, die einen einzelnen Wert zurückgeben (Count, Sum, First, Any, Max), und die Methoden To... laufen sofort. Wie diese Verzögerung gebaut ist, steht unter IEnumerable und yield.

Kurzübersicht

Häufige Fehler

• First() auf einer Sequenz, die leer sein kann. Wirft „Sequence contains no elements“; nimm FirstOrDefault und prüfe.
• Zwei OrderBy-Aufrufe. Der zweite Schlüssel wird zum Hauptschlüssel; nimm ThenBy.
• Eine Abfrage mehrmals durchlaufen. Die Arbeit wiederholt sich; rufe einmal ToList() auf.
• Erwarten, dass eine Abfrage eine Momentaufnahme ihrer Quelle macht. Sie liest die Quelle beim Durchlaufen, nicht beim Schreiben.
• Average, Min, Max auf einer leeren Sequenz. Sie werfen; sichere mit Any() oder DefaultIfEmpty ab.
• Count() > 0, um auf Elemente zu prüfen. Any() hört beim ersten auf.