0Pricing
C# Academy · Leçon

Que sont les arbres d’expressions

Comprenez comment du code peut être représenté comme une structure de données.

Que sont les arbres d’expressions est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Le code comme données

Un arbre d’expression représente le code sous forme de structure de données que vous pouvez examiner lors de l’exécution, plutôt que sous forme d’instructions compilées que vous pouvez uniquement exécuter. C# le modélise avec Expression<TDelegate>.

D’une lambda à un délégué ou à un arbre

Affectez une lambda à un Func<...> pour obtenir du code exécutable. Affectez la même lambda à Expression<Func<...>> pour que le compilateur construise un arbre qui la décrit.

using System;
using System.Linq.Expressions;

Func<int, int> runnable = x => x + 1;          // compiled delegate
Expression<Func<int, int>> tree = x => x + 1;  // data structure

Console.WriteLine(runnable(5));   // 6
Console.WriteLine(tree);          // x => (x + 1)

Examiner l’arbre

Puisqu’il s’agit de données, vous pouvez lire les différentes parties d’un arbre d’expression : ses paramètres, son corps et son type de nœud.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x + 1;
Console.WriteLine(tree.Parameters[0].Name); // x
Console.WriteLine(tree.Body.NodeType);      // Add
Console.WriteLine(tree.ReturnType);         // System.Int32

La hiérarchie des expressions

Chaque nœud dérive de System.Linq.Expressions.Expression. Parmi les types courants figurent BinaryExpression, ParameterExpression, ConstantExpression et MethodCallExpression.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x + 1;
var body = (BinaryExpression)tree.Body;
Console.WriteLine(body.Left);  // x
Console.WriteLine(body.Right); // 1

Seules les lambdas sous forme d’expression sont autorisées

Vous pouvez convertir en arbre uniquement une lambda constituée d’une seule expression. Les lambdas dont le corps contient des instructions, avec des accolades, ne peuvent pas être des arbres d’expression.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> ok = x => x * 2;    // fine
// Expression<Func<int,int>> bad = x => { return x*2; }; // compile error
Console.WriteLine(ok); // x => (x * 2)

Pourquoi est-ce important

Les arbres d’expression permettent aux bibliothèques de comprendre votre code au lieu de simplement l’exécuter. Les fournisseurs LINQ les traduisent en SQL, en requêtes dynamiques ou vers d’autres cibles.

NodeType indique l’opération

La propriété NodeType est une valeur d’énumération ExpressionType qui identifie l’opération correspondant à ce nœud.

using System;
using System.Linq.Expressions;

Expression<Func<int, bool>> tree = x => x > 10;
Console.WriteLine(tree.Body.NodeType); // GreaterThan

Constantes et paramètres

Un ParameterExpression représente une entrée ; un ConstantExpression contient une valeur littérale intégrée au code.

using System;
using System.Linq.Expressions;

Expression<Func<int, int>> tree = x => x + 5;
var body = (BinaryExpression)tree.Body;
Console.WriteLine(body.Left.GetType().Name);  // ParameterExpression (or TypedParameterExpression)
Console.WriteLine(((ConstantExpression)body.Right).Value); // 5

Appels de méthodes dans les arbres

Une lambda qui appelle une méthode devient un MethodCallExpression, qui expose la méthode et ses arguments.

using System;
using System.Linq.Expressions;

Expression<Func<string, int>> tree = s => s.Length;
// member access here; a call example:
Expression<Func<string, string>> call = s => s.ToUpper();
var mc = (MethodCallExpression)call.Body;
Console.WriteLine(mc.Method.Name); // ToUpper

Les arbres sont immuables

Les arbres d’expression sont immuables. Pour en « modifier » un, vous construisez un nouvel arbre à partir de ses composants ; c’est ainsi que fonctionnent les visiteurs et les réécrivains.

Mise en pratique

Nous examinons ici un petit arbre de prédicat de bout en bout : paramètre, opérateur et constante.

using System;
using System.Linq.Expressions;

Expression<Func<int, bool>> isAdult = age => age >= 18;
var body = (BinaryExpression)isAdult.Body;
Console.WriteLine(isAdult.Parameters[0].Name);          // age
Console.WriteLine(body.NodeType);                       // GreaterThanOrEqual
Console.WriteLine(((ConstantExpression)body.Right).Value); // 18

Vérification rapide

Vérifiez ce qui rend un arbre d’expression particulier.

Récapitulatif

Vous avez appris ce que sont les arbres d’expression.

  • Expression<TDelegate> représente le code sous forme de données que vous pouvez examiner.
  • Les nœuds comprennent les paramètres, les constantes, les opérations binaires et les appels de méthodes.
  • Seules les lambdas constituées d’une seule expression sont admissibles.
  • Les arbres sont immuables ; leur réécriture construit de nouveaux arbres.

Questions Fréquemment Posées

La leçon « Que sont les arbres d’expressions » est-elle gratuite ?

Oui — le texte complet de « Que sont les arbres d’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 « Que sont les arbres d’expressions » ?

Comprenez comment du code peut être représenté comme une structure de données. 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 1 sur 4.

Combien de temps prend la leçon « Que sont les arbres d’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