Lambda-Ausdrücke in C#

In C# ermöglichen Lambda-Ausdrücke, anonyme (namenlose) Methoden kurz und lesbar zu schreiben. Sie werden mit dem =>-Operator (Lambda-Operator) definiert. Lambda-Ausdrücke werden besonders häufig in LINQ-Abfragen, bei Event-Abonnements und im funktionalen Programmierstil verwendet.

Grundlegende Lambda-Syntax

Ein Lambda-Ausdruck besteht aus einer Parameterliste und einem Rumpf. Bei einfachen Ausdrücken sind keine geschweiften Klammern erforderlich; bei mehrzeiligen Rümpfen können Klammern und return verwendet werden.

// Ein Parameter, einzeiliger Ausdruck
Func<int, int> quadrat = x => x * x;
Console.WriteLine(quadrat(5)); // 25

// Lambda mit mehreren Parametern
Func<int, int, int> summe = (a, b) => a + b;
Console.WriteLine(summe(3, 4)); // 7

// Mehrzeiliges Lambda
Func<int, int, int> produkt = (a, b) =>
{
    Console.WriteLine($"Multipliziere: {a} * {b}");
    return a * b;
};
Console.WriteLine(produkt(2, 6)); // 12

Lambda mit Action und Func

Lambda-Ausdrücke werden oft zusammen mit den Typen Action und Func verwendet:

• Action: Repräsentiert Methoden ohne Rückgabewert.
• Func<T,..., TResult>: Repräsentiert Methoden mit einem Rückgabewert.

Action begruessen = () => Console.WriteLine("Hallo!");
begruessen(); // Hallo!

Func<string, int> laenge = s => s.Length;
Console.WriteLine(laenge("Lambda")); // 6

Lambda und LINQ

Lambda-Ausdrücke werden am häufigsten in LINQ-Abfragen verwendet. Sie erleichtern das Filtern, Sortieren und Projizieren von Sammlungen.

var zahlen = new List<int> { 1, 2, 3, 4, 5, 6 };

// Gerade Zahlen filtern
var gerade = zahlen.Where(x => x % 2 == 0);

Console.WriteLine(string.Join(", ", gerade)); // 2, 4, 6

// Quadrate berechnen
var quadrate = zahlen.Select(x => x * x);
Console.WriteLine(string.Join(", ", quadrate)); // 1, 4, 9, 16, 25, 36

Lambda bei Events

Lambda-Ausdrücke sind eine praktische Möglichkeit, Ereignisse zu behandeln. Dadurch kann ein Event kurz abgefangen werden, ohne eine separate Methode zu definieren.

public class Button
{
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Button geklickt!");
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Event mit Lambda abfangen
        btn.Click += (s, e) => Console.WriteLine("Ereignis: Button wurde geklickt.");

        btn.SimulateClick();
    }
}

Closures und Variablen-Capturing

Lambda-Ausdrücke können auf Variablen im Scope ihrer Definition zugreifen. Dies wird als Closure bezeichnet.

int zaehler = 0;

Action erhoehen = () =>
{
    zaehler++;
    Console.WriteLine($"Zähler: {zaehler}");
};

erhoehen(); // Zähler: 1
erhoehen(); // Zähler: 2

Hier „fängt“ der Lambda-Ausdruck die äußere Variable zaehler ein und arbeitet weiter mit ihr.

Beispiel: Filtern und Berichten

In einer Shop-Anwendung können Lambda-Ausdrücke verwendet werden, um Produkte nach Preis zu filtern und Berichte zu erstellen.

public class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

class Program
{
    static void Main()
    {
        var produkte = new List<Product>
        {
            new Product { Name = "Laptop", Price = 25000m },
            new Product { Name = "Maus", Price = 300m },
            new Product { Name = "Tastatur", Price = 600m },
            new Product { Name = "Monitor", Price = 4500m }
        };

        // Produkte über 1000 EUR finden
        var teureProdukte = produkte.Where(p => p.Price > 1000);

        foreach (var p in teureProdukte)
        {
            Console.WriteLine($"{p.Name} - {p.Price} EUR");
        }

        // Durchschnittspreis berechnen
        var avg = produkte.Average(p => p.Price);
        Console.WriteLine($"Durchschnittspreis: {avg:0.00} EUR");
    }
}

TL;DR

Ähnliche Artikel