0Pricing
C# Academy · Lección

Qué son los árboles de expresiones

Comprenda el código representado como una estructura de datos.

Qué son los árboles de expresiones es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 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.

El código como datos

Un árbol de expresiones representa el código como una estructura de datos que puede inspeccionar en tiempo de ejecución, en lugar de representarlo como instrucciones compiladas que solo puede ejecutar. C# modela este concepto con Expression<TDelegate>.

Lambda como delegado frente a árbol

Si asigna una lambda a un Func<...>, obtiene código ejecutable. Si asigna la misma lambda a Expression<Func<...>>, el compilador construye un árbol que la describe.

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)

Inspeccionar el árbol

Como es información, puede leer las partes de un árbol de expresiones: sus parámetros, cuerpo y tipo de 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 jerarquía de Expression

Cada nodo deriva de System.Linq.Expressions.Expression. Entre los tipos habituales se incluyen BinaryExpression, ParameterExpression, ConstantExpression y 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

Solo se admiten lambdas de expresión

Solo puede convertir una lambda de una única expresión en un árbol. Las lambdas con cuerpo de instrucciones (con llaves) no pueden convertirse en árboles de expresiones.

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)

Por qué es importante

Los árboles de expresiones permiten que las bibliotecas comprendan su código en lugar de limitarse a ejecutarlo. Los proveedores de LINQ los traducen a SQL, consultas dinámicas u otros destinos.

NodeType indica la operación

La propiedad NodeType es un valor de la enumeración ExpressionType que identifica la operación de ese nodo.

using System;
using System.Linq.Expressions;

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

Constantes y parámetros

Un ParameterExpression representa una entrada; un ConstantExpression contiene un valor literal insertado en el código.

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

Llamadas a métodos en los árboles

Una lambda que llama a un método se convierte en un MethodCallExpression, que expone el método y sus argumentos.

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

Los árboles son inmutables

Los árboles de expresiones son inmutables. Para «cambiar» uno, debe construir un árbol nuevo a partir de sus partes; así es como funcionan los visitantes y los reescritores.

Integración

Aquí examinaremos de principio a fin un pequeño árbol de predicado: parámetro, operador y constante.

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

Comprobación rápida

Confirme qué hace especial a un árbol de expresiones.

Resumen

Ha aprendido qué son los árboles de expresiones.

  • Expression<TDelegate> representa el código como datos que se pueden inspeccionar.
  • Los nodos incluyen parámetros, constantes, operaciones binarias y llamadas a métodos.
  • Solo son válidas las lambdas de una única expresión.
  • Los árboles son inmutables; la reescritura crea árboles nuevos.

Preguntas frecuentes

¿La lección «Qué son los árboles de expresiones» es gratis?

Sí — el texto completo de «Qué son los árboles 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 «Qué son los árboles de expresiones»?

Comprenda el código representado como una estructura de datos. 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 1 de 4.

¿Cuánto tiempo toma la lección «Qué son los árboles 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