Ausführbare C#-Docs: Lambda-Ausdrücke

Q: Was ist ein Lambda-Ausdruck in C#?

Eine anonyme Funktion, geschrieben mit dem Operator =>: x => x 2 nimmt x und gibt x 2 zurück. Ein Lambda hat keinen eigenen Namen; es wird in einen Delegate-Typ wie Func oder Action umgewandelt und kann in einer Variable gespeichert, an eine Methode übergeben oder aus einer zurückgegeben werden.

Q: Wie schreibe ich ein Lambda mit mehreren Parametern oder ohne Parameter?

Setze die Parameter in Klammern: (a, b) => a + b für zwei, () => DateTime.Now für keinen. Nur ein einzelner Parameter darf ohne Klammern stehen (x => x + 1). Du kannst die Typen auch explizit angeben: (int a, int b) => a + b.

Q: Warum sehen Lambdas in einer for-Schleife alle denselben Wert?

Eine for-Schleife hat eine einzige Schleifenvariable für die ganze Schleife, jedes darin erzeugte Lambda erfasst also dasselbe i und sieht seinen Endwert, wenn es später läuft. Kopiere es im Rumpf in eine lokale Variable (int copy = i;) und erfasse die Kopie. foreach hat dieses Problem seit C# 5 nicht, weil es pro Durchlauf eine neue Variable erzeugt.

Ein Lambda-Ausdruck ist eine kleine anonyme Funktion, die mit dem Operator => („geht über zu“) direkt im Code geschrieben wird. Die Parameter stehen links, das Ergebnis rechts:

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

class Program
{
    static void Main()
    {
        Func<decimal, decimal> addVat = price => price * 1.2m;
        Func<int, int, int> max = (a, b) => a > b ? a : b;
        Action<string> shout = text => Console.WriteLine(text.ToUpper() + "!");

        Console.WriteLine(addVat(50m));
        Console.WriteLine(max(7, 12));
        shout("order shipped");

        var prices = new List<decimal> { 12.5m, 80m, 5m, 150m };
        var expensive = prices.Where(p => p > 50m).Select(p => addVat(p));
        Console.WriteLine(string.Join(", ", expensive));
    }
}

Ausgabe:

60.0
12
ORDER SHIPPED!
96.0, 180.0

Ein Lambda hat keinen eigenen Typ. Es wird zu einem Delegate (einem Objekt, das auf eine Funktion zeigt) des Delegate-Typs, den der Kontext erwartet: hier Func<decimal, decimal>, ein Predicate<T> für List.FindAll, ein EventHandler für ein Event. Func-Delegates geben einen Wert zurück, Action-Delegates nicht; die Seite zu Func und Action listet die ganze Familie auf.

Syntaxformen

x => x * x                         // one parameter: parentheses optional
(x, y) => x + y                    // several parameters
() => DateTime.Now.Year            // no parameters
(int x, string s) => s.Length > x  // explicit parameter types
order =>                           // statement lambda: a block with return
{
    decimal subtotal = order.Qty * order.Price;
    return subtotal > 100m ? subtotal * 0.9m : subtotal;
}

Ein Ausdruckslambda hat nach => einen einzigen Ausdruck, und dessen Wert ist das Ergebnis. Ein Anweisungslambda hat einen Block in geschweiften Klammern, der beliebige Anweisungen enthalten kann und auf jedem Pfad mit return einen Wert zurückgeben muss, wenn der Delegate einen Wert zurückgibt (sonst CS1643, Not all code paths return a value in lambda expression).

Neuere Versionen haben weitere Formen hinzugefügt, alle optional:

C# 9: Discard-Parameter, sodass mehrere ungenutzte Parameter alle _ sein können ((_, _) => Save()), und static-Lambdas, denen das Erfassen von Variablen verboten ist.
C# 10: ein „natürlicher Typ“, sodass var square = (int x) => x * x; den Typ Func<int, int> ableitet. Davor scheitert var f = x => x * 2;; auch in C# 10 scheitert es ohne Parametertyp weiterhin, mit CS8917 The delegate type could not be inferred.
C# 12: Standardwerte für Parameter, (int x, int y = 1) => x + y.

Lambdas an Methoden übergeben

Jede Methode mit einem Delegate-Parameter akzeptiert ein Lambda. So übergibst du Verhalten, nicht nur Daten:

using System;
using System.Collections.Generic;

class Program
{
    static List<string> Filter(List<string> items, Func<string, bool> keep)
    {
        var result = new List<string>();
        foreach (string item in items)
        {
            if (keep(item)) result.Add(item);
        }
        return result;
    }

    static void Main()
    {
        var files = new List<string> { "report.pdf", "photo.jpg", "cv.txt", "scan.pdf" };

        var pdfs = Filter(files, f => f.EndsWith(".pdf"));
        var shortNames = Filter(files, f => f.Length <= 9);

        Console.WriteLine(string.Join(", ", pdfs));
        Console.WriteLine(string.Join(", ", shortNames));

        files.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine(string.Join(", ", files));
    }
}

Ausgabe:

report.pdf, scan.pdf
photo.jpg, cv.txt, scan.pdf
cv.txt, scan.pdf, photo.jpg, report.pdf

Filter weiß nicht, was „behalten“ bedeutet; der Aufrufer entscheidet es mit einem Lambda. List.Sort funktioniert genauso: Das Lambda ist ein Vergleich, der einen negativen Wert, null oder einen positiven Wert zurückgibt, und Sort ruft es so oft auf, wie nötig.

Lambdas in LINQ

In LINQ begegnen die meisten C#-Programme Lambdas. Jeder Abfrageoperator nimmt eines: Where eine Bedingung, Select eine Projektion, OrderBy einen Schlüssel, Sum einen Wert zum Aufsummieren:

using System;
using System.Linq;

class Order
{
    public string Customer;
    public int Qty;
    public decimal Price;
}

class Program
{
    static void Main()
    {
        Order[] orders =
        {
            new Order { Customer = "Ana", Qty = 2, Price = 30m },
            new Order { Customer = "Ben", Qty = 1, Price = 250m },
            new Order { Customer = "Ana", Qty = 5, Price = 4m },
            new Order { Customer = "Cy",  Qty = 3, Price = 15m },
        };

        var bigOrders = orders
            .Where(o => o.Qty * o.Price >= 45m)
            .OrderByDescending(o => o.Qty * o.Price)
            .Select(o => $"{o.Customer}: {o.Qty * o.Price}");

        foreach (string line in bigOrders) Console.WriteLine(line);

        var perCustomer = orders
            .GroupBy(o => o.Customer)
            .Select(g => new { Name = g.Key, Total = g.Sum(o => o.Qty * o.Price) });

        foreach (var c in perCustomer) Console.WriteLine($"{c.Name} spent {c.Total}");
    }
}

Ausgabe:

Ben: 250
Ana: 60
Cy: 45
Ana spent 80
Ben spent 250
Cy spent 45

Die Lambdas laufen nicht dort, wo sie geschrieben stehen. LINQ speichert sie und ruft sie auf, wenn die Abfrage durch foreach, ToList() oder Sum() durchlaufen wird, was verzögerte Ausführung heißt. Die LINQ-Seite behandelt die Operatoren selbst.

Closures: erfasste Variablen

Ein Lambda kann lokale Variablen und Parameter der Methode verwenden, in der es geschrieben ist. Es erfasst die Variable, nicht ihren aktuellen Wert, und die Variable lebt so lange weiter wie das Lambda:

using System;

class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;      // count outlives MakeCounter
    }

    static void Main()
    {
        Func<int> next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());

        Func<int> other = MakeCounter();
        Console.WriteLine(other());

        decimal rate = 0.1m;
        Func<decimal, decimal> discount = price => price * rate;
        rate = 0.5m;                       // changed after the lambda was created
        Console.WriteLine(discount(100m)); // uses the current value
    }
}

Ausgabe:

Jeder Aufruf von MakeCounter erzeugt ein neues count, die beiden Zähler sind also unabhängig. Das Rabatt-Lambda hat rate gelesen, als es lief, nicht als es geschrieben wurde, und daher 50 % angewendet. Der Compiler setzt das um, indem er erfasste Variablen in eine versteckte Klasse verschiebt, die sich Methode und Lambda teilen.

Die Falle beim Erfassen in Schleifen

Beim Erfassen einer Schleifenvariable beißen Closures zu. Eine for-Schleife hat eine Variable für die ganze Schleife, jedes darin erzeugte Lambda teilt sich also diese Variable:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            actions.Add(() => Console.Write($"{i} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, shared i");

        actions.Clear();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;                       // a new variable each iteration
            actions.Add(() => Console.Write($"{copy} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, copied");

        actions.Clear();
        foreach (int n in new[] { 0, 1, 2 })
        {
            actions.Add(() => Console.Write($"{n} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- foreach");
    }
}

Ausgabe:

3 3 3 <- for loop, shared i
0 1 2 <- for loop, copied
0 1 2 <- foreach

Alle drei Lambdas der ersten Schleife liefen, nachdem die Schleife beendet war, als i 3 war. i in eine im Rumpf deklarierte Variable zu kopieren gibt jedem Lambda seine eigene. foreach macht es von selbst richtig: Seit C# 5 ist seine Iterationsvariable bei jedem Durchlauf eine neue Variable. Vor C# 5 hatte es denselben Bug, weshalb ältere Antworten im Netz die Kopie auch für foreach noch empfehlen.

Dieselbe Falle gilt für alles, was später läuft: Event-Handler, Timer, Task.Run und LINQ-Abfragen, die in einer Schleife gebaut und danach durchlaufen werden.

Lambdas, anonyme Methoden und lokale Funktionen

Lambdas haben die Syntax der anonymen Methoden aus C# 2 abgelöst, die aber weiterhin kompiliert:

Func<int, bool> isEven = delegate (int n) { return n % 2 == 0; };   // C# 2 anonymous method
Func<int, bool> isEven2 = n => n % 2 == 0;                          // lambda

Für eine Hilfsfunktion, die nur in einer Methode verwendet wird, bietet C# 7.0 außerdem lokale Funktionen, die einen Namen haben, rekursiv sein können und keinen Delegate allokieren, solange du sie nicht in einen umwandelst. Nimm ein Lambda, wenn du Verhalten an etwas übergibst (LINQ, Sort, ein Event); nimm eine lokale Funktion oder eine private Methode, wenn du sie selbst aufrufst.

Ein weiterer Unterschied zeigt sich bei LINQ-Providern wie Entity Framework: Ein Lambda, das einem Expression<Func<T, bool>> zugewiesen wird, wird gar nicht zu Code kompiliert, sondern zu einer Datenstruktur, die den Code beschreibt und die der Provider in SQL übersetzt. Die Syntax ist identisch; der Parametertyp der aufgerufenen Methode entscheidet, was du bekommst.

Häufig gestellte Fragen

Was ist ein Lambda-Ausdruck in C#?

Eine anonyme Funktion, geschrieben mit dem Operator =>: x => x * 2 nimmt x und gibt x * 2 zurück. Ein Lambda hat keinen eigenen Namen; es wird in einen Delegate-Typ wie Func<int, int> oder Action<string> umgewandelt und kann in einer Variable gespeichert, an eine Methode übergeben oder aus einer zurückgegeben werden.

Wie schreibe ich ein Lambda mit mehreren Parametern oder ohne Parameter?

Setze die Parameter in Klammern: (a, b) => a + b für zwei, () => DateTime.Now für keinen. Nur ein einzelner Parameter darf ohne Klammern stehen (x => x + 1). Du kannst die Typen auch explizit angeben: (int a, int b) => a + b.

Was ist eine Closure bei einem C#-Lambda?

Ein Lambda, das eine lokale Variable der umgebenden Methode verwendet, erfasst diese Variable, keine Momentaufnahme ihres Werts. Die Variable lebt so lange wie das Lambda, und wenn eine Seite sie später ändert, sieht die andere die Änderung. Das lässt Zähler und Callbacks funktionieren und verursacht den klassischen Bug beim Erfassen in for-Schleifen.

Warum sehen Lambdas in einer for-Schleife alle denselben Wert?

Eine for-Schleife hat eine einzige Schleifenvariable für die ganze Schleife, jedes darin erzeugte Lambda erfasst also dasselbe i und sieht seinen Endwert, wenn es später läuft. Kopiere es im Rumpf in eine lokale Variable (int copy = i;) und erfasse die Kopie. foreach hat dieses Problem seit C# 5 nicht, weil es pro Durchlauf eine neue Variable erzeugt.

Warum kompiliert var f = x => x * 2 nicht?

Der Compiler kann nicht erkennen, welchen Delegate-Typ du willst oder welchen Typ x hat, daher meldet er CS8917 The delegate type could not be inferred (vor C# 10 CS0815). Deklariere den Typ (Func<int, int> f = x => x * 2;) oder, ab C# 10, typisiere den Parameter: var f = (int x) => x * 2;.

Verwandte Konzepte