C# Academy · Lezione

Creazione manuale delle espressioni

Costruisca alberi di espressioni con l'API Expression.

Creazione manuale delle espressioni è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Creare alberi manualmente

Oltre a consentire al compilatore di creare un albero a partire da una lambda, è possibile costruirne uno manualmente usando i metodi factory statici di 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) crea un nodo parametro a cui è possibile fare riferimento nel corpo e che può essere associato in una 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) incorpora un valore letterale. Facoltativamente, è possibile specificarne il tipo.

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

Gli operatori binari dispongono di factory come Expression.Add. Queste ricevono due espressioni operando e creano 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)

Altri operatori binari

Esistono factory per l'intero insieme: Subtract, Multiply, Divide, GreaterThan, Equal e altri.

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)

Racchiudere in una lambda

Expression.Lambda associa un corpo e i parametri in un Expression<TDelegate>, che è possibile compilare in seguito.

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)

Comporre espressioni annidate

Le factory possono essere annidate liberamente, consentendo di costruire passo dopo passo espressioni complesse come (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)

Accesso ai membri

Expression.Property e Expression.Field creano nodi di accesso ai membri.

using System;
using System.Linq.Expressions;

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

Chiamate di metodi

Expression.Call crea un nodo di chiamata, dato l'oggetto di destinazione, il metodo e gli argomenti.

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

Controllo dei tipi in fase di creazione

Le factory convalidano i tipi degli operandi durante la creazione. I tipi incompatibili generano immediatamente un'eccezione, consentendo di individuare subito gli errori.

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

Mettere tutto insieme

Costruisca interamente a mano 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)

Verifica rapida

Verifichi come funziona la creazione manuale delle espressioni.

Riepilogo

Ha imparato a creare manualmente gli alberi delle espressioni.

Expression.Parameter e Expression.Constant creano nodi foglia.
Expression.Add e i metodi analoghi creano operazioni binarie.
Expression.Property e Expression.Call gestiscono membri e metodi.
Expression.Lambda assembla un albero invocabile.

Domande Frequenti

La lezione «Creazione manuale delle espressioni» è gratuita?

Sì — il testo completo di «Creazione manuale delle 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 «Creazione manuale delle espressioni»?

Costruisca alberi di espressioni con l'API Expression. 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 2 di 4.

Quanto tempo richiede la lezione «Creazione manuale delle 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