C# Academy · Leçon

Compiler et exécuter des expressions

Transformez des arbres d’expressions en délégués exécutables.

Compiler et exécuter des expressions est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

De l’arbre au délégué

Un arbre d’expression reste des données tant que vous ne le compilez pas. Expression<TDelegate>.Compile() transforme l’arbre en véritable délégué que vous pouvez invoquer.

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

Compiler un arbre construit manuellement

Les arbres que vous construisez manuellement se compilent de la même manière et produisent un délégué fonctionnel.

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

Invoquer le résultat

Le délégué compilé se comporte comme n’importe quel autre : appelez-le, stockez-le ou transmettez-le.

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

Compile n’est pas gratuit

La compilation a un coût lors de l’exécution. Mettez donc en cache le délégué obtenu et réutilisez-le au lieu de compiler à chaque appel.

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();

Construire dynamiquement des prédicats

Il est courant de construire des prédicats de filtrage lors de l’exécution à partir des entrées de l’utilisateur, puis de les compiler en Func.

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

Combiner des conditions

Utilisez Expression.AndAlso / OrElse pour combiner les prédicats avant de les compiler.

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

Compiler des calculs

Vous pouvez assembler des formules arithmétiques lors de l’exécution, ce qui est utile pour les moteurs de règles et les calculatrices.

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 pour les lambdas sans type

Si vous avez utilisé un Expression.Lambda non générique, compilez-le en Delegate, puis appelez DynamicInvoke.

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

Remarque sur les performances

Après la compilation unique, une expression compilée s’exécute à une vitesse proche de celle d’un délégué. Pour les chemins très sollicités, compilez-la une fois au démarrage et stockez le délégué.

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

Les erreurs apparaissent lors de Compile

Si l’arbre est mal formé, par exemple s’il lui manque un paramètre, Compile() lève une exception. Validez donc les arbres avant de vous y fier.

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");
}

Mise en pratique

Construisez, compilez et exécutez une petite formule en une seule séquence.

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

Vérification rapide

Vérifiez comment exécuter un arbre d’expression.

Récapitulatif

Vous avez appris à compiler et à exécuter des arbres d’expression.

Compile() transforme un arbre en délégué appelable.
Mettez le délégué en cache ; la compilation a un coût unique.
Construisez dynamiquement des prédicats et des formules, puis compilez-les.
Les arbres mal formés provoquent une exception lors de Compile().

Questions Fréquemment Posées

La leçon « Compiler et exécuter des expressions » est-elle gratuite ?

Oui — le texte complet de « Compiler et exécuter des expressions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Compiler et exécuter des expressions » ?

Transformez des arbres d’expressions en délégués exécutables. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Compiler et exécuter des expressions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Que sont les arbres d’expressions
Construire manuellement des expressions
Compiler et exécuter des expressions
Arbres d’expressions dans les fournisseurs LINQ

← Retour à C# Academy