0Pricing
C# Academy · Leçon

Construire manuellement des expressions

Construisez des arbres d’expressions avec l’API Expression.

Construire manuellement des expressions est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Construire des arbres manuellement

En plus de permettre au compilateur de construire un arbre à partir d’une lambda, vous pouvez en créer un vous-même à l’aide des méthodes de fabrique statiques de Expression.

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) crée un nœud de paramètre que vous pouvez référencer dans le corps et lier dans une lambda.

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) intègre une valeur littérale. Vous pouvez éventuellement spécifier le type.

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

Les opérateurs binaires disposent de fabriques telles que Expression.Add. Elles prennent deux expressions opérandes et construisent un 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)

Autres opérateurs binaires

Il existe des fabriques pour l’ensemble des opérateurs : Subtract, Multiply, Divide, GreaterThan, Equal, entre autres.

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)

Encapsuler dans une lambda

Expression.Lambda associe un corps et des paramètres dans un Expression<TDelegate> que vous pourrez ensuite compiler.

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)

Composer des expressions imbriquées

Les fabriques peuvent être imbriquées librement ; vous pouvez donc construire progressivement des expressions complexes comme (x + 1) * 2.

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)

Accès aux membres

Expression.Property et Expression.Field construisent des nœuds d’accès aux membres.

using System;
using System.Linq.Expressions;

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

Appels de méthodes

Expression.Call construit un nœud d’invocation à partir de la cible, de la méthode et des arguments.

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

Vérification des types lors de la construction

Les fabriques valident les types des opérandes pendant la construction. Des types incompatibles provoquent immédiatement une exception, ce qui permet de détecter rapidement les erreurs.

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

Mise en pratique

Construisez entièrement à la main la lambda x => (x + 1) * 2.

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)

Vérification rapide

Vérifiez comment fonctionne la construction manuelle d’expressions.

Récapitulatif

Vous avez appris à construire manuellement des arbres d’expression.

  • Expression.Parameter et Expression.Constant créent les nœuds feuilles.
  • Expression.Add et les fabriques similaires construisent les opérations binaires.
  • Expression.Property et Expression.Call gèrent les membres et les méthodes.
  • Expression.Lambda assemble un arbre appelable.

Questions Fréquemment Posées

La leçon « Construire manuellement des expressions » est-elle gratuite ?

Oui — le texte complet de « Construire manuellement 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 « Construire manuellement des expressions » ?

Construisez des arbres d’expressions avec l’API Expression. 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 2 sur 4.

Combien de temps prend la leçon « Construire manuellement 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

  1. Que sont les arbres d’expressions
  2. Construire manuellement des expressions
  3. Compiler et exécuter des expressions
  4. Arbres d’expressions dans les fournisseurs LINQ
← Retour à C# Academy