C# LINQ filtern und transformieren: Einfach erklärt mit Beispielen

Stell dir vor, dein Ausbilder oder Teamleiter stellt dir diese Aufgabe: „Aus dieser Liste mit 200 Bestellungen brauche ich alle über 500 Euro aus dem letzten Monat." Als Anfänger schreibst du vermutlich eine `foreach`-Schleife mit einer `if`-Abfrage und füllst eine neue Liste. Funktioniert - aber dann zeigt dir ein erfahrener Kollege, dass dasselbe in C# in einer einzigen Zeile geht. Das Zauberwort heißt LINQ.

Genau das schauen wir uns jetzt an: Daten mit LINQ in C# filtern und transformieren. Ob du Azubi, Student oder Berufseinsteiger bist - wer in C# Daten verarbeitet, kommt an LINQ nicht vorbei.

Was ist LINQ in C#?

LINQ (Language Integrated Query) ist eine Abfragesprache, die direkt in C# eingebaut ist. Damit fragst du Daten aus Listen, Arrays, Datenbanken oder XML-Dateien ab - ohne jede Abfrage neu zu erfinden.

Stell dir LINQ wie einen Kaffeefilter vor: Du schüttest alles rein (deine Liste), und am Ende kommt nur das durch, was du haben willst. Der Filter selbst bleibt unverändert - du bekommst immer ein neues Ergebnis.

Die offizielle Dokumentation findest du bei Microsoft Learn.

Mit Where filtern: Nur das behalten, was passt

`Where` filtert eine Sammlung nach einer Bedingung und gibt nur die Elemente zurück, die die Bedingung erfüllen. Die Quelle selbst bleibt unverändert.

Hier siehst du den direkten Vergleich - erst die klassische Schleife, dann LINQ:

List<int> zahlen = new List<int> { 3, 12, 7, 25, 8, 42, 15 };

// Klassisch mit Schleife
List<int> ergebnisSchleife = new List<int>();
foreach (int z in zahlen)
{
  if (z > 10)
  {
    ergebnisSchleife.Add(z);
  }
}

// Mit LINQ - eine Zeile
IEnumerable<int> ergebnisLinq = zahlen.Where(z => z > 10);

Beide Varianten liefern `12, 25, 42, 15`. Der Unterschied: Bei LINQ sagst du was du willst, nicht wie der Computer es Schritt für Schritt machen soll.

Das `z => z > 10` ist eine Lambda Expression - eine kurze, anonyme Funktion. Wenn dir die Syntax noch fremd vorkommt, lies zuerst unseren Artikel zur C# Lambda Expression.

Merke: `Where` verändert nie die ursprüngliche Liste. Es liefert immer eine neue Abfrage über die gefilterten Elemente.

Mit Select transformieren: Daten in eine neue Form bringen

`Select` projiziert jedes Element einer Sammlung in eine neue Form. Du wandelst die Daten also um - in eine andere Klasse, einen Ausschnitt davon oder einen völlig neuen Wert.

Denk an ein Fließband: Oben kommt ein Rohprodukt rein, unten kommt etwas anderes raus. Aus einer Liste von Mitarbeitern machst du zum Beispiel eine Liste von Namen.

List<string> namen = new List<string> { "anna meier", "ben schulz" };

// Grossbuchstaben statt Kleinbuchstaben
IEnumerable<string> gross = namen.Select(n => n.ToUpper());
// Ergebnis: "ANNA MEIER", "BEN SCHULZ"

Besonders praktisch: Mit `Select` und anonymen Typen pickst du dir genau die Felder heraus, die du brauchst. Angenommen, du hast eine Liste von `Mitarbeiter`-Objekten mit vielen Eigenschaften:

var kurzfassung = mitarbeiter.Select(m => new { m.Name, m.Gehalt });

Mehr dazu findest du in unserem Artikel zu anonymen Typen und Lambdas in C#.

Merke: `Where` reduziert die Anzahl der Elemente, `Select` verändert ihre Form. Beide kombinierst du beliebig.

Welche LINQ-Methoden brauchst du im Alltag?

LINQ besteht aus Dutzenden Methoden - diese acht decken den Alltag ab:

Die vollständige Referenz aller Methoden gibt es bei Microsoft Learn.

Praxisbeispiel: Mitarbeiter filtern, sortieren und ausgeben

Jetzt kombinieren wir alles - mit dem wichtigsten Prinzip: Method Chaining. Die Methoden lassen sich mit Punktnotation aneinanderreihen. Jede Methode nimmt das Ergebnis der vorherigen und verarbeitet es weiter.

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

class Program
{
  static void Main()
  {
    List<Mitarbeiter> 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 = 47000 },
      new Mitarbeiter { Name = "Elena", Abteilung = "Entwicklung", Gehalt = 45000 }
    };

    // Filtern -> Sortieren -> Transformieren
    var ergebnis = team
      .Where(m => m.Abteilung == "Entwicklung")
      .OrderByDescending(m => m.Gehalt)
      .Select(m => new { m.Name, m.Gehalt });

    foreach (var person in ergebnis)
    {
      Console.WriteLine(person.Name + ": " + person.Gehalt + " Euro");
    }
    // Ausgabe: Clara: 61000, Anna: 52000, Elena: 45000
  }
}

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

Lies die Kette von oben nach unten wie einen Satz: „Nimm das Team, wo die Abteilung Entwicklung ist, sortiere es absteigend nach Gehalt und wähle nur Name und Gehalt aus."

Grundlagen zu Listen und Collections findest du in unserem C# Collections Überblick.

Was ist verzögerte Ausführung (Deferred Execution)?

Bei LINQ wird die Abfrage erst ausgeführt, wenn du über das Ergebnis iterierst - nicht schon beim Erstellen. Das nennt sich verzögerte Ausführung (Deferred Execution).

Analogie: Eine LINQ-Abfrage ist wie ein Rezept. Solange du nicht kochst (also `foreach` oder `ToList()` aufrufst), passiert gar nichts.

List<int> zahlen = new List<int> { 1, 5, 12 };
var abfrage = zahlen.Where(z => z > 3);  // Hier laeuft noch NICHTS

zahlen.Add(20);  // Liste wird nachtraeglich erweitert

foreach (int z in abfrage)  // Erst JETZT wird gefiltert
{
  Console.WriteLine(z);  // Ausgabe: 5, 12, 20
}

Willst du das Ergebnis sofort und unveränderlich einfrieren, hängst du `.ToList()` oder `.ToArray()` an.

Merke: Eine LINQ-Abfrage ohne `ToList()`, `ToArray()` oder `foreach` tut rein gar nichts - sie ist nur der Bauplan.

Welche Fehler machen Anfänger bei LINQ?

Fehler 1: Abfrage mehrfach ausführen. Wenn du dieselbe LINQ-Abfrage in zwei `foreach`-Schleifen verwendest, läuft sie auch zweimal - mit Performance-Kosten. Lösung: einmal `.ToList()` aufrufen und die Liste weiterverwenden.

Fehler 2: `First` auf eine leere Menge. `First()` wirft eine Exception, wenn kein Element passt. Wenn das passieren kann (und das kann es fast immer), nimm `FirstOrDefault()` und prüfe das Ergebnis auf `null`. Beispiel mit dem Team von oben:

// Falsch: crasht, weil niemand ueber 70000 verdient
Mitarbeiter top = team.First(m => m.Gehalt > 70000);

// Richtig: liefert null statt zu crashen
Mitarbeiter vielleicht = team.FirstOrDefault(m => m.Gehalt > 70000);
if (vielleicht != null)
{
  Console.WriteLine(vielleicht.Name);
}

Fehler 3: Denken, `Where` ändert die Liste. `Where` gibt ein neues, gefiltertes `IEnumerable<T>` zurück. Deine ursprüngliche Liste bleibt komplett unangetastet. Wer das vergisst, wundert sich, warum nach dem Filtern plötzlich doch alle Elemente wieder da sind.

Übungstipp: Bau dir deine eigene Abfrage

Nimm eine Liste von 10 Songtiteln mit Künstler und Jahr (einfach als Klasse anlegen). Übe dann drei Aufgaben:

1. Alle Songs vor 2000 mit `Where`

2. Nur die Songtitel mit `Select`

3. Die Kombination: ältester Song zuerst, nur Titel und Jahr

Warum eigene Daten? Weil du bei selbst ausgedachten Beispielen sofort siehst, ob das Ergebnis stimmt - bei abstrakten Übungsaufgaben aus dem Internet oft nicht. Schreib den Code dabei ruhig erst mal handschriftlich auf, das festigt die Syntax. Warum das hilft, erklären wir im Artikel Code handschriftlich üben.

FAQ: Häufige Fragen zu C# LINQ filtern

Was ist der Unterschied zwischen First und FirstOrDefault?

`First()` gibt das erste passende Element zurück und wirft eine Exception, wenn es keins gibt. `FirstOrDefault()` gibt stattdessen `null` (bei Referenztypen) bzw. den Standardwert zurück. Faustregel: Bei unsicheren Daten immer `FirstOrDefault()`.

Methodensyntax oder Query-Syntax - was soll ich nutzen?

C# kennt beide: `liste.Where(x => x > 5)` (Methodensyntax) und `from x in liste where x > 5 select x` (Query-Syntax). Beide liefern dasselbe. In der Praxis dominiert die Methodensyntax, weil sie kürzer ist und alle Operatoren unterstützt. Lerne beide zu lesen, schreibe selbst die Methodensyntax.

Ist LINQ langsamer als eine normale Schleife?

Für Alltagsaufgaben ist der Unterschied irrelevant - Lesbarkeit gewinnt. Nur in extrem performance-kritischen Schleifen (Millionen Iterationen) kann eine handgeschriebene `for`-Schleife minimal schneller sein. Das lohnt sich aber nicht, wenn dein Code dadurch komplexer und fehleranfälliger wird.

Funktioniert LINQ auch auf Datenbanken?

Ja - über Entity Framework wird LINQ in SQL übersetzt. Wichtig: Dort arbeitest du mit `IQueryable<T>` statt `IEnumerable<T>`, damit das Filtern in der Datenbank passiert und nicht erst alle Datensätze in den Speicher geladen werden.

Fazit

LINQ ersetzt dir Dutzende Zeilen Schleifen-Code durch eine lesbare, verkettete Abfrage: Mit `Where` filterst du, mit `Select` transformierst du, mit `OrderBy` sortierst du. Merk dir die verzögerte Ausführung und den Unterschied zwischen `First` und `FirstOrDefault` - damit vermeidest du die typischen Anfängerfehler.

Wenn du LINQ und die restlichen C#-Grundlagen wirklich sicher lernen willst, schau bei study-it.education vorbei. Dort bekommst du persönliche Nachhilfe, die genau auf deinen Stand zugeschnitten ist - egal ob du gerade deine IHK-Prüfung vorbereitest, im Studium hängst oder als Quereinsteiger durchstartest.