0Pricing
C# Academy · Lezione

Compilazione ed esecuzione delle espressioni

Trasformi gli alberi di espressioni in delegate eseguibili.

Compilazione ed esecuzione delle espressioni è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Dall'albero al delegato

Un albero delle espressioni è costituito da dati finché non lo si compila. Expression<TDelegate>.Compile() trasforma l'albero in un delegato reale che è possibile invocare.

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

Compilare un albero creato manualmente

Gli alberi creati manualmente vengono compilati nello stesso modo e producono un delegato funzionante.

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

Invocare il risultato

Il delegato compilato si comporta come qualsiasi altro: è possibile chiamarlo, memorizzarlo e passarlo ad altro codice.

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

La compilazione non è gratuita

La compilazione ha un costo a runtime, quindi è opportuno memorizzare nella cache il delegato risultante e riutilizzarlo, invece di compilare a ogni chiamata.

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

Creare predicati dinamicamente

Un uso comune consiste nel creare a runtime predicati di filtro a partire dall'input dell'utente e compilarli quindi in un 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

Combinare condizioni

Usi Expression.AndAlso / OrElse per combinare i predicati prima della compilazione.

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

Compilare calcoli

È possibile assemblare formule aritmetiche a runtime, una soluzione utile per motori di regole e calcolatrici.

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 per lambda senza tipo

Se ha usato un Expression.Lambda non generico, lo compili in un Delegate e chiami 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

Nota sulle prestazioni

Dopo la compilazione eseguita una sola volta, un'espressione compilata viene eseguita a una velocità simile a quella di un delegato. Nei percorsi più eseguiti, la compili all'avvio e memorizzi il delegato.

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

Gli errori emergono in fase di compilazione

Se l'albero non è valido, ad esempio perché manca un parametro, Compile() genera un'eccezione; convalidi quindi gli alberi prima di farvi affidamento.

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

Mettere tutto insieme

Crei, compili ed esegua una piccola formula in un unico flusso.

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

Verifica rapida

Verifichi come eseguire un albero delle espressioni.

Riepilogo

Ha imparato a compilare ed eseguire gli alberi delle espressioni.

  • Compile() trasforma un albero in un delegato invocabile.
  • Memorizzi il delegato nella cache: la compilazione ha un costo iniziale.
  • Crei dinamicamente predicati e formule, quindi li compili.
  • Gli alberi non validi generano un'eccezione in Compile().

Domande Frequenti

La lezione «Compilazione ed esecuzione delle espressioni» è gratuita?

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

Trasformi gli alberi di espressioni in delegate eseguibili. 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 3 di 4.

Quanto tempo richiede la lezione «Compilazione ed esecuzione 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

  1. Cosa sono gli alberi di espressioni
  2. Creazione manuale delle espressioni
  3. Compilazione ed esecuzione delle espressioni
  4. Alberi di espressioni nei provider LINQ
← Torna a C# Academy