0Pricing
C# Academy · Lección

Construcción manual de expresiones

Construya árboles de expresiones con la API Expression.

Construcción manual de expresiones es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 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.

Construir árboles manualmente

Además de permitir que el compilador construya un árbol a partir de una lambda, puede construir uno usted mismo mediante los métodos de fábrica estáticos de 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 de parámetro al que puede hacer referencia en el cuerpo y asociar en 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) inserta un literal. De forma opcional, puede especificar el 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

Los operadores binarios tienen métodos de fábrica como Expression.Add. Estos reciben dos expresiones operandos y construyen 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)

Otros operadores binarios

Existen métodos de fábrica para todo el conjunto: Subtract, Multiply, Divide, GreaterThan, Equal y muchos más.

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)

Envolver en una lambda

Expression.Lambda combina un cuerpo y unos parámetros en un Expression<TDelegate> que después puede compilar.

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)

Componer expresiones anidadas

Los métodos de fábrica se pueden anidar libremente, por lo que puede construir paso a paso expresiones complejas como (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)

Acceso a miembros

Expression.Property y Expression.Field construyen nodos de acceso a miembros.

using System;
using System.Linq.Expressions;

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

Llamadas a métodos

Expression.Call construye un nodo de invocación a partir del destino, el método y los argumentos.

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

Comprobación de tipos durante la construcción

Los métodos de fábrica validan los tipos de los operandos durante la construcción. Los tipos incompatibles producen una excepción de inmediato, lo que permite detectar pronto los errores.

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

Integración

Construya completamente 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)

Comprobación rápida

Confirme cómo funciona la construcción manual de expresiones.

Resumen

Ha aprendido a construir árboles de expresiones manualmente.

  • Expression.Parameter y Expression.Constant crean nodos hoja.
  • Expression.Add y sus equivalentes construyen operaciones binarias.
  • Expression.Property y Expression.Call gestionan miembros y métodos.
  • Expression.Lambda ensambla un árbol invocable.

Preguntas frecuentes

¿La lección «Construcción manual de expresiones» es gratis?

Sí — el texto completo de «Construcción manual 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 «Construcción manual de expresiones»?

Construya árboles de expresiones con la API Expression. 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 2 de 4.

¿Cuánto tiempo toma la lección «Construcción manual 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