C# Lambda Expression einfach erklärt: Syntax & Beispiele

Du sitzt im Betrieb, öffnest zum ersten Mal den C#-Code eines echten Projekts - und überall stehen Zeilen wie `kunden.Where(k => k.Alter >= 18)`. Dieses komische `=>` siehst du zum ersten Mal und fragst dich, ob das überhaupt gültiger Code ist. Die Antwort: Ja, das ist eine C# Lambda Expression - und sie ist überall: in Firmenprojekten, in der IHK-Abschlussprüfung und in praktisch jedem LINQ-Tutorial.

Was ist eine Lambda Expression in C#?

Eine Lambda Expression ist eine anonyme Funktion, also eine Funktion ohne Namen, die du direkt an der Stelle definierst, wo du sie brauchst. Statt eine komplette Methode mit Name, Klammern und `return` zu schreiben, packst du die Logik in eine einzige Zeile.

Stell dir eine normale Methode als offiziellen Brief vor: Anrede, Hauptteil, Grußformel. Eine Lambda Expression ist dagegen ein Klebezettel - kurz, direkt und nur für diesen einen Zweck gedacht.

Merke: Eine Lambda Expression hat immer die Grundform `parameter => ausdruck`. Lies den Pfeil als „wird zu" oder „ergibt".

Die offizielle Beschreibung findest du in den Microsoft Learn Docs zu Lambda-Ausdrücken.

Wie funktioniert die Syntax? Der Operator => erklärt

Der Lambda-Operator `=>` trennt die Parameter (links) vom Funktionsrumpf (rechts). Links stehen die Eingabewerte, rechts steht, was daraus berechnet wird. `x => x * x` bedeutet also: Nimm `x` und gib `x` mal `x` zurück.

Hier siehst du dieselbe Logik einmal klassisch und einmal als Lambda:

using System;

// Klassische Methode
static int Quadrat(int x)
{
  return x * x;
}

// Dasselbe als Lambda
Func<int, int> quadrat = x => x * x;

Console.WriteLine(quadrat(5)); // Ausgabe: 25

Was ist `Func<int, int>`? Das ist ein fertiger Delegat-Typ aus dem .NET Framework. Ein Delegat ist dabei einfach ein Typ, der eine Methode speichern kann - wie eine Variable, die statt einer Zahl eine Funktion enthält. `Func<int, int>` bedeutet: Eingabe `int`, Ausgabe `int`. Der Compiler erkennt die Typen deiner Lambda-Parameter automatisch, deshalb musst du bei `x` keinen Typ mehr hinschreiben.

Ein Detail, das Anfängern entgeht: Ab zwei Parametern brauchst du Klammern - `(a, b) => a + b`. Ganz ohne Parameter schreibst du `() => ...`. Bei einem einzelnen Parameter wie `x` darfst du die Klammern weglassen.

Expression Lambda oder Statement Lambda?

Es gibt zwei Formen von Lambda Expressions. Das Expression Lambda besteht aus einem einzigen Ausdruck ohne geschweifte Klammern - das Ergebnis wird automatisch zurückgegeben. Das Statement Lambda enthält mehrere Anweisungen in `{}` und braucht ein explizites `return`.

// Expression Lambda: ein Ausdruck, Ergebnis automatisch zurueckgegeben
Func<int, int> verdoppeln = x => x * 2;

// Statement Lambda: mehrere Anweisungen, explizites return
Func<int, int> verdoppeln2 = x =>
{
  int ergebnis = x * 2;
  Console.WriteLine("Zwischenschritt: " + ergebnis);
  return ergebnis;
};

Faustregel: Passt die Logik in einen Ausdruck, nimm das Expression Lambda. Brauchst du mehrere Schritte, holst du dir die geschweiften Klammern.

Wo begegnen dir Lambdas im Alltag? Bei LINQ!

Der häufigste Anwendungsfall ist LINQ (Language Integrated Query) - eine Abfragesprache für Collections. Methoden wie `Where`, `Select` und `OrderBy` erwarten als Parameter eine Lambda Expression. Sie beschreibt, was mit jedem Element passieren soll.

Merke: LINQ-Methoden wie `Where`, `Select` und `OrderBy` erwarten eine Lambda Expression als Vorschrift für jedes Element. Intern ruft `Where` deine Lambda für jedes einzelne Element auf und behält die, für die `true` herauskommt.

var erwachsene = personen.Where(p => p.Alter >= 18);

Lies die Zeile so: „Von allen Personen diejenigen auswählen (*where*), bei denen das Alter mindestens 18 ist." Wie das genau mit `IEnumerable` und `foreach` zusammenspielt, haben wir im Artikel IEnumerable und foreach in C# verstehen aufgeschlüsselt.

Praxisbeispiel: Wie filterst du eine Mitarbeiter-Liste?

Hier ein vollständiges, lauffähiges Beispiel - so ähnlich könnte es auch in deinem Ausbildungsbetrieb aussehen. Das Beispiel nutzt LINQ auf einer Liste, wie wir sie im Überblick zu C# Collections beschreiben.

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

class Mitarbeiter
{
  public string Name { get; set; }
  public string Abteilung { get; set; }
  public int Gehalt { get; set; }
}

class Program
{
  static void Main()
  {
    var team = new List<Mitarbeiter>
    {
      new Mitarbeiter { Name = "Anna", Abteilung = "Entwicklung", Gehalt = 52000 },
      new Mitarbeiter { Name = "Ben", Abteilung = "Vertrieb", Gehalt = 41000 },
      new Mitarbeiter { Name = "Clara", Abteilung = "Entwicklung", Gehalt = 61000 },
      new Mitarbeiter { Name = "David", Abteilung = "Vertrieb", Gehalt = 38000 }
    };

    // Filtern: nur Entwicklung
    var entwickler = team.Where(m => m.Abteilung == "Entwicklung");

    // Sortieren: nach Gehalt absteigend
    var sortiert = entwickler.OrderByDescending(m => m.Gehalt);

    // Projizieren: nur die Namen extrahieren
    var namen = sortiert.Select(m => m.Name);

    foreach (var name in namen)
    {
      Console.WriteLine(name);
    }
    // Ausgabe: Clara, Anna
  }
}

Drei Lambdas, drei Aufgaben: filtern (`Where`), sortieren (`OrderByDescending`) und umwandeln (`Select`). Genau diese Kombination taucht in Klausuren, Coding-Challenges und Vorstellungsgesprächen immer wieder auf.

Welche typischen Fehler passieren bei Lambda Expressions?

Fehler 1: `=>` falsch schreiben

Anfänger tippen manchmal `= >` mit Leerzeichen oder drehen den Pfeil um zu `<=`. Der Compiler versteht nur exakt `=>` ohne Leerzeichen dazwischen. Prüfe das zuerst, wenn du die Fehlermeldung „; expected" bekommst.

Fehler 2: Mehrere Anweisungen ohne geschweifte Klammern

// Falsch: zwei Anweisungen ohne Block
Func<int, int> f = x => int y = x * 2; return y;

// Richtig: Block mit { } und explizitem return
Func<int, int> f = x =>
{
  int y = x * 2;
  return y;
};

Sobald mehr als ein Ausdruck kommt, sind Klammern Pflicht. Warum? Weil der Compiler sonst nicht weiß, wo der Rumpf endet.

Fehler 3: Deferred Execution vergessen

`Where` führt deine Lambda nicht sofort aus. Stattdessen liefert es eine Beschreibung der Abfrage zurück, die erst bei der tatsächlichen Iteration (z. B. `foreach`) ausgeführt wird - das nennt man Deferred Execution.

Merke: `Where` und `Select` führen die Abfrage erst bei der Iteration aus - außer du hängst `.ToList()` an. Dann läuft sie sofort.

Wer das nicht kennt, wundert sich, warum sich Änderungen an der Liste später doch noch im „Ergebnis" widerspiegeln.

Übungstipp: foreach-Schleifen umbauen

Nimm eine `foreach`-Schleife aus einem alten Übungsprojekt und baue sie in eine LINQ-Anweisung mit Lambda um. Beispiel: eine Schleife, die alle geraden Zahlen in eine neue Liste packt.

// Vorher
var gerade = new List<int>();
foreach (int zahl in zahlen)
{
  if (zahl % 2 == 0)
  {
    gerade.Add(zahl);
  }
}

// Nachher
var gerade2 = zahlen.Where(z => z % 2 == 0).ToList();

Mach das mit drei oder vier Schleifen, und das Lesen von Lambdas wird zur Routine. Wenn du den Stoff lieber handschriftlich verfestigst, hilft unser Tipp Code handschriftlich üben weiter.

FAQ: Häufige Fragen zu C# Lambda Expressions

Was bedeutet => in C#?

`=>` ist der Lambda-Operator. Links stehen die Parameter einer anonymen Funktion, rechts der Ausdruck oder Anweisungsblock, der zurückgegeben bzw. ausgeführt wird.

Was ist der Unterschied zwischen Func und Action?

`Func` ist ein Delegat-Typ mit Rückgabewert, `Action` einer ohne Rückgabewert (`void`). Beispiel: `Func<int, int>` nimmt und liefert einen `int`, `Action<string>` nimmt einen `string` und gibt nichts zurück.

Was ist der Unterschied zu anonymen Methoden?

Anonyme Methoden (mit dem `delegate`-Schlüsselwort, C# 2.0) sind die ältere, ausführlichere Form. Lambdas (C# 3.0) sind die moderne, kürzere Schreibweise und unterstützen Expression Trees - mehr dazu im Artikel Anonyme Typen und Lambdas in C#.

Wann sollte ich keine Lambda Expression verwenden?

Wenn die Logik lang, verschachtelt oder an mehreren Stellen nötig ist. Dann ist eine benannte Methode lesbarer und wiederverwendbarer - auch wenn eine Lambda technisch funktionieren würde.

Was ist eine Closure?

Eine Closure entsteht, wenn eine Lambda auf eine Variable außerhalb ihrer selbst zugreift. Die Lambda „merkt" sich diese Variable - auch dann noch, wenn der umgebende Code längst fertig ist. Das ist mächtig, kann aber zu schwer nachvollziehbaren Bugs führen, wenn du es unbeabsichtigt in Schleifen machst.

Fazit

Lambda Expressions sind kurze, namenlose Funktionen der Form `parameter => ausdruck`. Du brauchst sie vor allem für LINQ, Ereignisbehandlung und überall dort, wo Methoden als Parameter übergeben werden. Der Einstieg ist simpler, als er aussieht: Parameter links, Pfeil in die Mitte, Ergebnis rechts. Genau wie bei den anderen Konzepten gilt - erst lesen üben, dann schreiben.

Wenn du bei C#, LINQ oder einem anderen Thema aus deiner Ausbildung oder deines Studiums hängst, schau bei study-it.education vorbei. Dort bekommst du individuelle IT-Nachhilfe, die sich nach deinem Tempo richtet - egal ob Azubi, Student oder Quereinsteiger.