C# Academy · Lektion

Expressions kompilieren und ausführen

Wandeln Sie Expression Trees in ausführbare Delegates um.

Lektion 3 von 413 Schritte

Expressions kompilieren und ausführen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Vom Baum zum Delegate

Ein Ausdrucksbaum bleibt so lange eine Datenstruktur, bis Sie ihn kompilieren. Expression<TDelegate>.Compile() wandelt den Baum in ein echtes Delegate um, das Sie aufrufen können.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x + 1;
Func<int, int> fn = tree.Compile();
Console.WriteLine(fn(5)); // 6

Einen manuell erstellten Baum kompilieren

Bäume, die Sie manuell erstellen, werden auf dieselbe Weise kompiliert und ergeben ein funktionsfähiges Delegate.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Multiply(x, Expression.Constant(3));
var lambda = Expression.Lambda<Func<int, int>>(body, x);
var fn = lambda.Compile();
Console.WriteLine(fn(4)); // 12

Das Ergebnis aufrufen

Das kompilierte Delegate verhält sich wie jedes andere: Sie können es aufrufen, speichern und weitergeben.

using System;
using System.Linq.Expressions;

Expression<Func<int, int, int>> addExpr = (a, b) => a + b;
var add = addExpr.Compile();
Console.WriteLine(add(2, 3)); // 5
Console.WriteLine(add(10, 20)); // 30

Kompilieren ist nicht kostenlos

Die Kompilierung verursacht Laufzeitkosten. Cachen Sie daher das resultierende Delegate und verwenden Sie es wieder, statt es bei jedem Aufruf neu zu kompilieren.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x * x;
var square = tree.Compile(); // compile once
for (int i = 1; i <= 3; i++)
    Console.Write(square(i) + " "); // 1 4 9
Console.WriteLine();

Prädikate dynamisch erstellen

Eine häufige Anwendung besteht darin, Filterprädikate zur Laufzeit aus Benutzereingaben zu erstellen und sie anschließend in ein Func zu kompilieren.

using System;
using System.Linq.Expressions;

var n = Expression.Parameter(typeof(int), "n");
var isPositive = Expression.GreaterThan(n, Expression.Constant(0));
var pred = Expression.Lambda<Func<int, bool>>(isPositive, n).Compile();
Console.WriteLine(pred(5));  // True
Console.WriteLine(pred(-2)); // False

Bedingungen kombinieren

Verwenden Sie Expression.AndAlso bzw. OrElse, um Prädikate vor der Kompilierung zu kombinieren.

using System;
using System.Linq.Expressions;

var n = Expression.Parameter(typeof(int), "n");
var inRange = Expression.AndAlso(
    Expression.GreaterThanOrEqual(n, Expression.Constant(1)),
    Expression.LessThanOrEqual(n, Expression.Constant(10)));
var fn = Expression.Lambda<Func<int, bool>>(inRange, n).Compile();
Console.WriteLine(fn(5) + " " + fn(11)); // True False

Berechnungen kompilieren

Sie können arithmetische Formeln zur Laufzeit zusammenstellen, was für Regel-Engines und Taschenrechner nützlich ist.

using System;
using System.Linq.Expressions;

var p = Expression.Parameter(typeof(double), "p");
// price * 1.2 (add 20% tax)
var withTax = Expression.Multiply(p, Expression.Constant(1.2));
var calc = Expression.Lambda<Func<double, double>>(withTax, p).Compile();
Console.WriteLine(calc(100)); // 120

DynamicInvoke für typunabhängige Lambda-Ausdrücke

Wenn Sie ein nicht generisches Expression.Lambda verwendet haben, kompilieren Sie es in ein Delegate und rufen Sie DynamicInvoke auf.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Add(x, Expression.Constant(10));
Delegate d = Expression.Lambda(body, x).Compile();
Console.WriteLine(d.DynamicInvoke(5)); // 15

Hinweis zur Leistung

Nach der einmaligen Kompilierung wird ein kompilierter Ausdruck ungefähr so schnell wie ein Delegate ausgeführt. Kompilieren Sie ihn für häufig durchlaufene Pfade einmal beim Start und speichern Sie das Delegate.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x + x;
var doubler = tree.Compile();
int total = 0;
for (int i = 0; i < 5; i++) total += doubler(i);
Console.WriteLine(total); // 0+2+4+6+8 = 20

Fehler werden bei der Kompilierung sichtbar

Wenn der Baum fehlerhaft ist, beispielsweise weil ein Parameter fehlt, löst Compile() eine Ausnahme aus. Prüfen Sie Bäume daher, bevor Sie sich auf sie verlassen.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var y = Expression.Parameter(typeof(int), "y");
try {
    // body references y but lambda only declares x
    var lambda = Expression.Lambda<Func<int, int>>(Expression.Add(x, y), x);
    lambda.Compile();
} catch (InvalidOperationException) {
    Console.WriteLine("unbound parameter");
}

Alles zusammenführen

Erstellen, kompilieren und führen Sie eine kleine Formel in einem einzigen Ablauf aus.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var formula = Expression.Add(
    Expression.Multiply(x, Expression.Constant(2)),
    Expression.Constant(3)); // 2x + 3
var fn = Expression.Lambda<Func<int, int>>(formula, x).Compile();
Console.WriteLine(fn(4)); // 11

Schnelltest

Überprüfen Sie, wie ein Ausdrucksbaum ausgeführt wird.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gelernt, Ausdrucksbäume zu kompilieren und auszuführen.

Compile() wandelt einen Baum in ein aufrufbares Delegate um.
Verwenden Sie das Delegate aus dem Cache erneut, da die Kompilierung einmalige Kosten verursacht.
Erstellen Sie Prädikate und Formeln dynamisch und kompilieren Sie sie anschließend.
Fehlerhafte Bäume lösen bei Compile() eine Ausnahme aus.

Kostenlos starten

Lerne C# mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 93
Lektionen: 346

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Expressions kompilieren und ausführen“ kostenlos?

Ja — der vollständige Text von „Expressions kompilieren und ausführen“ 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 kompilieren und ausführen“?

Wandeln Sie Expression Trees in ausführbare Delegates um. 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 3 von 4.

Wie lange dauert die Lektion „Expressions kompilieren und ausführen“?

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