C# Academy · Lezione

Cosa sono gli alberi di espressioni

Comprenda il codice rappresentato come struttura dati.

Lezione 1 di 413 passaggi

Cosa sono gli alberi di espressioni è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Il codice come dati

Un albero delle espressioni rappresenta il codice come una struttura di dati ispezionabile a runtime, anziché come istruzioni compilate che è possibile solo eseguire. C# lo modella con Expression<TDelegate>.

Da lambda a delegato o albero

Assegnando una lambda a un Func<...> si ottiene codice eseguibile. Assegnando la stessa lambda a Expression<Func<...>>, il compilatore crea un albero che la descrive.

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)

Ispezionare l'albero

Poiché è costituito da dati, è possibile leggere le parti di un albero delle espressioni: i parametri, il corpo e il tipo di nodo.

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 gerarchia di Expression

Ogni nodo deriva da System.Linq.Expressions.Expression. Tra i tipi più comuni vi sono BinaryExpression, ParameterExpression, ConstantExpression e 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

Sono consentite solo lambda a espressione

È possibile trasformare in un albero solo una lambda costituita da una singola espressione. Le lambda con corpo costituito da istruzioni (racchiuse tra parentesi graffe) non possono essere alberi delle espressioni.

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)

Perché è importante

Gli alberi delle espressioni consentono alle librerie di comprendere il codice, anziché limitarsi a eseguirlo. I provider LINQ li traducono in SQL, query dinamiche o altri linguaggi di destinazione.

NodeType indica l'operazione

La proprietà NodeType è un valore dell'enumerazione ExpressionType che identifica l'operazione eseguita in quel nodo.

using System;
using System.Linq.Expressions;

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

Costanti e parametri

Un ParameterExpression rappresenta un input; un ConstantExpression contiene un valore letterale incorporato nel codice.

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

Chiamate di metodi negli alberi

Una lambda che chiama un metodo diventa un MethodCallExpression, che espone il metodo e i relativi argomenti.

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

Gli alberi sono immutabili

Gli alberi delle espressioni sono immutabili. Per "modificarne" uno è necessario creare un nuovo albero a partire dai suoi componenti: è così che funzionano visitor e riscrittori.

Mettere tutto insieme

Qui si esamina dall'inizio alla fine un piccolo albero di predicato: parametro, operatore e costante.

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

Verifica rapida

Verifichi che cosa rende speciale un albero delle espressioni.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato che cosa sono gli alberi delle espressioni.

Expression<TDelegate> rappresenta il codice come dati ispezionabili.
I nodi includono parametri, costanti, operatori binari e chiamate di metodi.
Sono ammesse solo lambda costituite da una singola espressione.
Gli alberi sono immutabili; la riscrittura crea nuovi alberi.

Gratis per iniziare

Impara C# con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 93
Lezioni: 346

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Cosa sono gli alberi di espressioni» è gratuita?

Sì — il testo completo di «Cosa sono gli alberi di espressioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Cosa sono gli alberi di espressioni»?

Comprenda il codice rappresentato come struttura dati. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Cosa sono gli alberi di espressioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Cosa sono gli alberi di espressioni
Creazione manuale delle espressioni
Compilazione ed esecuzione delle espressioni
Alberi di espressioni nei provider LINQ

← Torna a C# Academy