C# Academy · Lektion

Expressions manuell erstellen

Erstellen Sie Expression Trees mit der Expression API.

Expressions manuell erstellen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Bäume manuell erstellen

Neben der Möglichkeit, den Compiler aus einem Lambda-Ausdruck einen Baum erstellen zu lassen, können Sie selbst einen mithilfe der statischen Factory-Methoden von Expression erstellen.

using System;
using System.Linq.Expressions;

var five = Expression.Constant(5);
Console.WriteLine(five);          // 5
Console.WriteLine(five.Type);     // System.Int32

Expression.Parameter

Expression.Parameter(type, name) erstellt einen Parameterknoten, auf den Sie im Rumpf verweisen und den Sie in einem Lambda-Ausdruck binden können.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
Console.WriteLine(x.Name + " : " + x.Type); // x : System.Int32

Expression.Constant

Expression.Constant(value) bettet einen Literalwert ein. Optional können Sie den Typ angeben.

using System;
using System.Linq.Expressions;

var c = Expression.Constant(42);
var typed = Expression.Constant(3.14, typeof(double));
Console.WriteLine(c + " " + typed); // 42 3.14

Expression.Add

Für binäre Operatoren gibt es Factory-Methoden wie Expression.Add. Sie übernehmen zwei Operandenausdrücke und erstellen einen BinaryExpression.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var sum = Expression.Add(x, Expression.Constant(1));
Console.WriteLine(sum); // (x + 1)

Weitere binäre Operatoren

Für die vollständige Menge gibt es Factory-Methoden: Subtract, Multiply, Divide, GreaterThan, Equal und weitere.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var gt = Expression.GreaterThan(x, Expression.Constant(10));
var mul = Expression.Multiply(x, Expression.Constant(2));
Console.WriteLine(gt + " | " + mul); // (x > 10) | (x * 2)

In einen Lambda-Ausdruck einschließen

Expression.Lambda verbindet einen Rumpf und Parameter zu einem Expression<TDelegate>, das Sie später kompilieren können.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Add(x, Expression.Constant(1));
var lambda = Expression.Lambda<Func<int, int>>(body, x);
Console.WriteLine(lambda); // x => (x + 1)

Verschachtelte Ausdrücke zusammensetzen

Factory-Methoden können beliebig verschachtelt werden, sodass Sie komplexe Ausdrücke wie (x + 1) * 2 schrittweise erstellen können.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var addOne = Expression.Add(x, Expression.Constant(1));
var timesTwo = Expression.Multiply(addOne, Expression.Constant(2));
Console.WriteLine(timesTwo); // ((x + 1) * 2)

Zugriff auf Member

Expression.Property und Expression.Field erstellen Knoten für den Zugriff auf Member.

using System;
using System.Linq.Expressions;

var s = Expression.Parameter(typeof(string), "s");
var lengthAccess = Expression.Property(s, "Length");
Console.WriteLine(lengthAccess); // s.Length

Methodenaufrufe

Expression.Call erstellt einen Aufrufknoten anhand des Ziels, der Methode und der Argumente.

using System;
using System.Linq.Expressions;

var s = Expression.Parameter(typeof(string), "s");
var toUpper = typeof(string).GetMethod("ToUpper", Type.EmptyTypes);
var call = Expression.Call(s, toUpper);
Console.WriteLine(call); // s.ToUpper()

Typprüfung beim Erstellen

Die Factory-Methoden prüfen die Operandentypen bereits beim Erstellen. Nicht übereinstimmende Typen lösen sofort eine Ausnahme aus, sodass Fehler früh erkannt werden.

using System;
using System.Linq.Expressions;

try {
    var bad = Expression.Add(
        Expression.Constant(1),
        Expression.Constant("text")); // int + string
} catch (InvalidOperationException) {
    Console.WriteLine("type mismatch rejected");
}

Alles zusammenführen

Erstellen Sie den Lambda-Ausdruck x => (x + 1) * 2 vollständig manuell.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Multiply(
    Expression.Add(x, Expression.Constant(1)),
    Expression.Constant(2));
var lambda = Expression.Lambda<Func<int, int>>(body, x);
Console.WriteLine(lambda); // x => ((x + 1) * 2)

Schnelltest

Überprüfen Sie, wie das manuelle Erstellen von Ausdrücken funktioniert.

Zusammenfassung

Sie haben gelernt, Ausdrucksbäume manuell zu erstellen.

Expression.Parameter und Expression.Constant erstellen Blattknoten.
Expression.Add und ähnliche Methoden erstellen binäre Operationen.
Expression.Property und Expression.Call verarbeiten Member und Methoden.
Expression.Lambda setzt einen aufrufbaren Baum zusammen.

Häufig gestellte Fragen

Ist die Lektion „Expressions manuell erstellen“ kostenlos?

Ja — der vollständige Text von „Expressions manuell erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Expressions manuell erstellen“?

Erstellen Sie Expression Trees mit der Expression API. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Expressions manuell erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy