LINQ-Syntax: Method Syntax vs Query Syntax

1. Einführung

In der LINQ-Welt gibt es zwei große "Schulen" beim Schreiben von Queries, zwei Stile, die auf den ersten Blick total unterschiedlich wirken. Das sind Query Syntax (Abfrage-Syntax) und Method Syntax (Methoden-Syntax). Und falls du dachtest, Programmieren sei nur Logik, dann bringen wir heute ein bisschen Kunst ins Spiel – denn die Wahl der Syntax ist oft wie die Wahl zwischen Pinsel und Bleistift: Beide malen, aber einer bringt die Farbe besser rüber, der andere die Kontur.

Warum brauchen wir zwei Syntaxen? Gute Frage! Stell dir vor, du willst einen Kaffee bestellen. Du kannst sagen: "Könnte ich bitte einen Espresso mit Milch und einem Löffel Zucker haben?". Oder du schreibst auf einen Zettel: "Espresso. Milch. 1 Zucker". Beides verständlich, aber das eine ist gesprächiger, das andere kürzer.

So ist es auch mit LINQ. Eine Syntax wurde so gebaut, dass sie möglichst wie SQL aussieht, die andere ist mehr "C#-like" und flexibler. Am Ende wandelt der C#-Compiler beide Stile in dasselbe um: Methodenaufrufe. Die Wahl ist also oft eine Frage der Lesbarkeit und persönlicher Vorliebe.

Schauen wir uns beide mal an.

2. Method Syntax

Das ist die Variante, bei der du LINQ-Extension-Methoden hintereinander mit Punkt aufrufst. Dieser Ansatz ist bei .NET-Entwicklern besonders beliebt, weil man easy neue Operationen dranhängen kann, das Ergebnis immer ein IEnumerable<T> ist und man direkt im Code schreiben kann.

Beispiel: Produkte filtern und sortieren

var gefilterteProdukte = products
    .Where(p => p.Price < 1000)          // Nach Preis filtern
    .OrderBy(p => p.Name)                // Nach Name sortieren
    .ToList();                           // Zu List<Product> umwandeln

Where, OrderBy und ToList sind LINQ-Extension-Methoden, jede gibt eine neue Datenmenge zurück, die du weiterverarbeiten kannst.

Schaubild

graph LR
A[products] --> B[Where]
B --> C[OrderBy]
C --> D[ToList]

Was ist cool an Method Syntax

• Super flexibel: Du kannst easy komplexe Ketten aus vielen Operationen bauen.
• Alle Methoden sind einfach C#-Methoden, die IDE hilft mit Autovervollständigung.
• Du kannst fast alles machen, was LINQ bietet (und sogar mehr).

Noch ein Beispiel: Namen aller User über 18 auswählen

Angenommen, wir haben eine Klasse User:

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Jetzt holen wir die Namen der erwachsenen User:

List<User> users = ... // irgendwo deklariert

var erwachseneNamen = users
    .Where(u => u.Age >= 18)
    .Select(u => u.Name)
    .ToList();

3. Query Syntax (SQL-ähnliche Syntax)

Diese Syntax wurde extra erfunden, damit sich C#-Entwickler wie zu Hause fühlen, wenn sie schon mal mit SQL gearbeitet haben. Sie sieht aus wie eine Datenbankabfrage und startet mit dem Schlüsselwort from.

Beispiel: derselbe Filter und Sortierung

var gefilterteProdukte = 
    from p in products
    where p.Price < 1000
    orderby p.Name
    select p;

Hier liest sich alles wie eine klassische Abfrage: "aus der Collection products nimm p, wo p.Price < 1000, sortiere nach p.Name, wähle p".

Schaubild

flowchart TD
    A[products] -->|from p in products| B[where p.Price < 1000]
    B --> C[orderby p.Name]
    C --> D[select p]

Was ist cool an Query Syntax

• Sieht aus wie SQL, also verständlicher für alle, die schon mit Datenbanken gearbeitet haben.
• Lesbarer bei langen Abfragen mit mehreren Bedingungen, Gruppierungen, Joins (join).

Noch ein Beispiel: Namen der erwachsenen User auswählen

var erwachseneNamen = 
    from u in users
    where u.Age >= 18
    select u.Name;

Achtung: Hier kannst du direkt nach select nicht das ganze Objekt, sondern ein bestimmtes Feld auswählen – zum Beispiel nur den Namen.

4. Vergleich: Method Syntax vs Query Syntax

users.Where(...).Select(...)

from u in users where ... select ...

Sum

Count

IEnumerable<T>

IEnumerable<T>

.ToList()

Fun Fact aus dem echten Leben

Die meisten Beispiele in der offiziellen Microsoft-Doku zu LINQ gibt's direkt in beiden Stilen. Aber im echten Code sieht man immer öfter Method Syntax – das ist einfach praktischer, wenn man Extension-Methoden wie Where, Select, OrderBy usw. nutzt.

Mischen oder nicht mischen? Welchen Stil wählen

Du kannst beide Syntaxen locker im selben Projekt (und sogar in einer Query – sieht aber komisch aus) mischen. Hauptsache, du machst keinen Syntax-Salat. Meist nimmt man einen Stil für das ganze Modul oder Projekt, damit der Code lesbarer bleibt.

Method Syntax ist top für sequentielle Transformationen und für alle LINQ-Methoden, die es nur als Methoden gibt (Sum, Count, Any und ein paar andere).

Query Syntax ist super praktisch für Aufgaben mit join, group by oder komplexen, mehrstufigen Bedingungen – da gewinnt sie bei der Lesbarkeit.

5. Umwandlung zwischen den Stilen: Gleiches Ziel, anderer Weg

LINQ in C# verwandelt jede SQL-ähnliche Query (Query Syntax) intern in eine Kette von Methodenaufrufen (Method Syntax). Egal, was du schreibst – C# macht daraus beim Kompilieren Extension-Methoden.

Beispiel 1 – Filtern:

Query Syntax:

var erwachsene = from u in users
                 where u.Age >= 18
                 select u;

Method Syntax (äquivalent):

var erwachsene = users.Where(u => u.Age >= 18);

Beispiel 2 – Felder auswählen (Select):

Query Syntax:

var namen = from u in users
            select u.Name;

Method Syntax:

var namen = users.Select(u => u.Name);

7. Gruppierungen und Joins (join, group by)

Neue Objekte erstellen

Lass uns in unserer Lern-App die Möglichkeit einbauen, eine Liste von Usern nach Alter gruppiert auszugeben. Hier sieht man den Unterschied in der Syntax besonders deutlich.

Query Syntax (Gruppierung):

var userNachAlter = 
    from u in users
    group u by u.Age into alterGruppe
    select new { Age = alterGruppe.Key, Users = alterGruppe.ToList() };

Wir gruppieren die User nach Alter (group u by u.Age). Nach into gibt's die Variable alterGruppe – das ist dann die Gruppe selbst.

Method Syntax (äquivalent):

var userNachAlter = users
    .GroupBy(u => u.Age)
    .Select(alterGruppe => new { Age = alterGruppe.Key, Users = alterGruppe.ToList() });

Noch schwieriger: Join (join)

Angenommen, wir haben eine Liste von Bestellungen (orders) und eine Liste von Usern (users). Wir wollen die Namen der User und die Summe ihrer Bestellungen bekommen.

Query Syntax:

var userBestellungen =
    from user in users
    join order in orders on user.Id equals order.UserId
    select new { user.Name, order.Amount };

Method Syntax:

var userBestellungen = users.Join(
    orders,
    user => user.Id,
    order => order.UserId,
    (user, order) => new { user.Name, order.Amount }
);

8. Häufige Fehler, Stolperfallen und Lifehacks

Einer der häufigsten Irrtümer: Wenn du kein .ToList() dranhängst, ist das Ergebnis keine Liste, sondern eine "Lazy Query" (lazy query), die erst beim ersten Durchlaufen ausgeführt wird. Das ist praktisch, kann aber zu unerwarteten Ergebnissen führen, wenn sich die Ursprungs-Collection nach dem Schreiben der Query noch ändert. Mehr zu "Lazy Execution" gibt's später (nachdem wir die LINQ-Methoden kennengelernt haben).

Viele Anfänger verwechseln, dass nicht alle LINQ-Methoden in Query Syntax nutzbar sind. Zum Beispiel kannst du nicht einfach select sum(u.Age) schreiben, sondern musst zu Method Syntax wechseln (users.Sum(u => u.Age)).

2

Aufgabe

C# SELF, Level 31, Lektion 1

Gesperrt

Verwendung von Query Syntax für Filter und Sortierung

Verwendung von Query Syntax für Filter und Sortierung

Öffnen