Anonyme Typen und Lambdas in C#

Du sitzt an deiner ersten richtigen Anwendung - vielleicht am Betriebsprojekt in der Ausbildung, an einer Hausaufgabe im Studium oder am ersten Task im Job. Du hast eine Liste mit Produkten und sollst eine Übersicht ausgeben: nur Name und Preis, mehr nicht.

Jetzt überlegst du: „Schreibe ich extra eine Klasse mit zwei Properties? Nur für diese eine Ausgabe?" Die Antwort: Nein. Genau dafür gibt es anonyme Typen und Lambda-Ausdrücke in C#. Dieser Artikel zeigt, was beide sind und wann du sie einsetzt.

Was ist ein anonymer Typ in C#?

Ein anonymer Typ ist ein Datentyp, den der Compiler automatisch erzeugt, ohne dass du eine Klasse definierst. Du erstellst ihn direkt mit `new { ... }` und speicherst ihn in einer Variable mit `var`.

Stell dir vor, du brauchst kurz einen Zettel, um zwei Notizen zu parken - da fängst du auch nicht an, ein ganzes Notizbuch anzulegen. Genau so funktionieren anonyme Typen: schnelle, wegwerfbare Datenobjekte für Zwischenergebnisse.

var person = new { Name = "Anna", Alter = 27 };

Console.WriteLine(person.Name);  // Ausgabe: Anna
Console.WriteLine(person.Alter); // Ausgabe: 27

Der Compiler generiert im Hintergrund eine Klasse mit den Properties `Name` und `Alter`. Du siehst sie nie im Quellcode - deshalb „anonym". Die offizielle Beschreibung dazu findest du bei Microsoft Learn.

Merke: Ein anonymer Typ entsteht per `new { ... }` ohne Klassendefinition. Er ist nur innerhalb der Methode nutzbar, in der er erstellt wurde, und seine Properties sind read-only (nur lesbar).

Was ist ein Lambda-Ausdruck in C#?

Ein Lambda-Ausdruck ist eine kurze, namenlose Funktion, die du direkt dort hinschreibst, wo du sie brauchst. Du erkennst ihn an den Zeichen `=>` - gesprochen „geht zu" oder „becomes".

Stell dir eine Methode als Werkzeug vor, das du in der Werkzeugkiste aufbewahrst. Ein Lambda ist wie ein Einwegwerkzeug: Du benutzt es sofort und wirfst es weg. Kein Name, kein eigener Methodenkopf, kein Overhead.

// Normale Methode
int Verdoppeln(int x)
{
  return x * 2;
}

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

Console.WriteLine(verdoppeln(5)); // Ausgabe: 10

`Func<int, int>` bedeutet: eine Funktion, die einen `int` reinbekommt und einen `int` zurückgibt. Links vom `=>` stehen die Parameter (hier `x`, der Typ wird automatisch erschlossen), rechts der Ausdruck, der zurückgegeben wird. Brauchst du mehrere Anweisungen, setzt du sie in geschweifte Klammern und schreibst ein `return` dazu. Details liefert die offizielle Dokumentation zu Lambda-Ausdrücken.

Merke: `x => x * 2` liest sich als „nimm x und gib x mal 2 zurück". Lambdas ersetzen kurze Einweg-Methoden und sind Standard bei LINQ.

Warum verwendet man anonyme Typen und Lambdas zusammen?

Weil beide bei LINQ zusammenspielen - der Abfragesprache von C# für Listen und Datenquellen. Das Muster: Mit dem Lambda definierst du *was* du machst, mit dem anonymen Typ *in welcher Form* das Ergebnis daherkommt.

Merke: In einer LINQ-Kette entscheidet das Lambda über die Logik (filtern, sortieren) - der anonyme Typ entscheidet über die Form des Ergebnisses.

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

class Program
{
  static void Main()
  {
    var produkte = new List<Produkt>
    {
      new Produkt { Name = "Laptop", Preis = 999.99m },
      new Produkt { Name = "Maus", Preis = 25.50m },
      new Produkt { Name = "Monitor", Preis = 249.00m }
    };

    var uebersicht = produkte
      .Where(p => p.Preis < 300)             // Lambda als Filter
      .OrderBy(p => p.Preis)                 // Lambda als Sortierkriterium
      .Select(p => new { p.Name, p.Preis }); // Anonymer Typ als Ergebnisform

    foreach (var item in uebersicht)
    {
      Console.WriteLine($"{item.Name}: {item.Preis} Euro");
    }
  }
}

class Produkt
{
  public string Name { get; set; }
  public decimal Preis { get; set; }
}

Die Ausgabe:

Maus: 25,50 Euro
Monitor: 249,00 Euro

Ohne den anonymen Typ müsstest du eine Klasse `ProduktUebersicht` mit genau zwei Properties anlegen - nur für diese eine Abfrage. Diese Abkürzung gilt aber nur, solange das Ergebnis lokal bleibt: Sobald du es an andere Methoden weitergibst, ist eine echte Klasse (oder seit C# 9 ein `record`) die bessere Wahl, denn anonyme Typen verlassen ihre Methode nicht.

Anonymer Typ oder eigene Klasse - wann was?

Kurz gesagt: lokal und nur einmal gebraucht → anonymer Typ. Projektweit genutzt und wiederverwendbar → eigene Klasse. Die Entscheidung hängt also vom Nutzungszweck ab, nicht vom persönlichen Geschmack:

Ein Bonus am Rande: Der Compiler überschreibt für anonyme Typen automatisch `Equals`, `GetHashCode` und `ToString` - zwei Objekte mit gleichen Werten gelten also als gleich, und die Ausgabe bleibt lesbar. Warum diese Methoden bei Vergleichen entscheidend sind, erklärt der Beitrag zu ToString, Equals und GetHashCode in C#. Wer solide OOP-Grundlagen auffrischen will, wirft vorher einen Blick auf die OOP-Prinzipien in C#.

Faustregel: Anonymer Typ für lokale LINQ-Zwischenergebnisse - eigene Klasse oder `record` für alles, was die Methode verlässt.

3 typische Anfängerfehler

1. Properties verändern wollen

Anonyme Typen sind unveränderlich. Diese Zeile erzeugt einen Compiler-Fehler:

// Falsch: Property ist read-only
var person = new { Name = "Anna" };
person.Name = "Bernd"; // Fehler CS0200

Lösung: Ein neues Objekt erzeugen.

// Richtig: neues Objekt mit neuen Werten
var person = new { Name = "Anna" };
person = new { Name = "Bernd" };

2. Anonymen Typ aus der Methode herausreichen

Weil du den Typnamen nicht kennst, kannst du ihn nicht als Parameter- oder Rückgabetyp deklarieren. `var` funktioniert nur für lokale Variablen. Willst du das Ergebnis weitergeben, brauchst du eine Klasse, ein `record` oder ein Tuple wie `(string Name, decimal Preis)`.

3. `=>` mit `>=` verwechseln

`=>` gehört zum Lambda, `>=` ist der Vergleichsoperator „größer gleich". In einer Zeile wie `p => p.Preis >= 100` kommen beide vor - wer die Zeichen verwechselt, sucht lange nach kryptischen Fehlermeldungen.

Übungstipp: Bau es selbst

Nimm die Produktliste von oben und erweitere sie: Filtere alle Produkte, deren Name mit „M" beginnt (`p => p.Name.StartsWith("M")`), und projiziere das Ergebnis auf einen anonymen Typ mit `Name` und einer berechneten Property `PreisMitMwSt = p.Preis * 1.19m`. „Projizieren" heißt dabei nichts anderes als: in eine neue Form bringen. Das dauert zehn Minuten und trainiert genau die Kombination, die in Prüfungsaufgaben und im Berufsalltag ständig vorkommt.

FAQ: Häufige Fragen

Was ist ein anonymer Typ in C#?

Ein anonymer Typ ist ein vom Compiler generierter Datentyp, den du mit `new { Eigenschaft = wert, ... }` ohne Klassendefinition erstellst. Er ist nur lokal in der Methode nutzbar und seine Properties sind read-only.

Kann ich einen anonymen Typ als Rückgabewert einer Methode verwenden?

Nein. Da der Typname unbekannt ist, kannst du ihn nicht als Rückgabetyp angeben. Technisch ginge es noch über `object` oder `dynamic` - das ist aber schlechter Stil, weil du die Properties danach ohne Typsicherheit ansprichst.

Was bedeutet => in C#?

`=>` ist der Lambda-Operator. Er trennt die Parameter (links) vom Rückgabeausdruck (rechts). Beispiel: `x => x * 2` bedeutet „nimm x, gib x mal 2 zurück".

Was ist der Unterschied zwischen Lambda und anonymer Methode?

Beide erzeugen namenlose Funktionen. Die anonyme Methode mit dem Schlüsselwort `delegate` ist die ältere, ausführlichere Syntax (`delegate(int x) { return x * 2; }`). Lambdas sind die moderne, kürzere Schreibweise und heute Standard.

Sind anonyme Typen dasselbe wie Tupel?

Nein. Ein Tuple wie `(string Name, int Alter)` hat benannte, veränderbare Felder und kann Methoden verlassen. Ein anonymer Typ hat Properties, ist unveränderlich und bleibt lokal. Für Methodenrückgaben nimmst du Tupel oder besser ein `record`.

Fazit

Anonyme Typen und Lambdas in C# sind ein Dream-Team: Das Lambda sagt, *wie* gefiltert und sortiert wird, der anonyme Typ legt fest, *welche Form* das Ergebnis hat. Merke dir zwei Regeln: Anonyme Typen bleiben lokal und sind read-only - sobald Daten durchs Projekt wandern, greifst du zu Klassen oder Records. Wer aus Python schon Lambdas kennt, findet hier eine ähnliche Betrachtung: anonyme Funktionen in Python.

Wenn du bei C#, LINQ oder einem anderen IT-Thema festhängst - ob in der Ausbildung, im Studium oder beim Berufseinstieg - hole dir Unterstützung bei study-it.education. Individuelle Nachhilfe, die sich nach deinem Tempo richtet.