0Pricing
C# Academy · Lección

Compilación y ejecución de expresiones

Convierta árboles de expresiones en delegates ejecutables.

Compilación y ejecución de expresiones es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Del árbol al delegado

Un árbol de expresiones son datos hasta que lo compila. Expression<TDelegate>.Compile() convierte el árbol en un delegado real que puede invocar.

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

Compilar un árbol construido manualmente

Los árboles que construye manualmente se compilan de la misma forma y producen un delegado funcional.

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

Invocar el resultado

El delegado compilado se comporta como cualquier otro: puede llamarlo, almacenarlo y pasarlo a otras partes del código.

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

Compile no es gratuito

La compilación tiene un coste en tiempo de ejecución, así que debe almacenar en caché el delegado resultante y reutilizarlo en lugar de compilarlo en cada llamada.

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

Construir predicados dinámicamente

Un uso habitual consiste en construir predicados de filtrado en tiempo de ejecución a partir de la entrada del usuario y compilarlos después en 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

Combinar condiciones

Utilice Expression.AndAlso / OrElse para combinar predicados antes de compilarlos.

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

Compilar cálculos

Puede ensamblar fórmulas aritméticas en tiempo de ejecución, algo útil para motores de reglas y calculadoras.

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 para lambdas sin tipo

Si ha utilizado un Expression.Lambda no genérico, compile el resultado en un Delegate y llame a 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 sobre el rendimiento

Una expresión compilada se ejecuta aproximadamente a la velocidad de un delegado después de la compilación inicial. En rutas críticas, compílela una vez al iniciar la aplicación y almacene el delegado.

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

Los errores aparecen en tiempo de compilación

Si el árbol no es válido (por ejemplo, si falta un parámetro), Compile() produce una excepción, por lo que debe validar los árboles antes de depender de ellos.

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

Integración

Construya, compile y ejecute una pequeña fórmula en un solo flujo.

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

Comprobación rápida

Confirme cómo ejecutar un árbol de expresiones.

Resumen

Ha aprendido a compilar y ejecutar árboles de expresiones.

  • Compile() convierte un árbol en un delegado invocable.
  • Almacene el delegado en caché; la compilación tiene un coste inicial único.
  • Construya predicados y fórmulas dinámicamente y compílelos después.
  • Los árboles no válidos producen una excepción en Compile().

Preguntas frecuentes

¿La lección «Compilación y ejecución de expresiones» es gratis?

Sí — el texto completo de «Compilación y ejecución de expresiones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Compilación y ejecución de expresiones»?

Convierta árboles de expresiones en delegates ejecutables. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Compilación y ejecución de expresiones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Qué son los árboles de expresiones
  2. Construcción manual de expresiones
  3. Compilación y ejecución de expresiones
  4. Árboles de expresiones en proveedores LINQ
← Volver a C# Academy