C# Academy · Aula

O que são árvores de expressão

Entenda o código representado como uma estrutura de dados.

O que são árvores de expressão é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Código como dados

Uma árvore de expressões representa código como uma estrutura de dados que você pode inspecionar em tempo de execução, em vez de instruções compiladas que só podem ser executadas. O C# modela isso com Expression<TDelegate>.

Lambda para um delegado ou uma árvore

Atribua uma lambda a um Func<...> para obter código executável. Atribua a mesma lambda a Expression<Func<...>> para que o compilador construa uma árvore que a descreva.

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)

Inspecionando a árvore

Como ela é composta por dados, você pode ler as partes de uma árvore de expressões: seus parâmetros, corpo e tipo de nó.

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

A hierarquia de expressões

Cada nó deriva de System.Linq.Expressions.Expression. Os tipos comuns incluem BinaryExpression, ParameterExpression, ConstantExpression e 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

Somente lambdas de expressão são permitidas

Você só pode transformar uma lambda de expressão única em uma árvore. Lambdas com corpo de instruções (com chaves) não podem ser árvores de expressões.

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 que isso é importante

As árvores de expressões permitem que as bibliotecas entendam seu código, em vez de apenas executá-lo. Os provedores LINQ as traduzem para SQL, consultas dinâmicas ou outros destinos.

NodeType informa a operação

A propriedade NodeType é um valor da enumeração ExpressionType que identifica a operação naquele nó.

using System;
using System.Linq.Expressions;

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

Constantes e parâmetros

Um ParameterExpression representa uma entrada; um ConstantExpression contém um valor literal incorporado ao 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

Chamadas de métodos em árvores

Uma lambda que chama um método se torna uma MethodCallExpression, expondo o método e seus 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

As árvores são imutáveis

As árvores de expressões são imutáveis. Para alterar uma, você constrói uma nova árvore a partir de suas partes; é assim que visitantes e reescritores funcionam.

Reunindo tudo

Aqui examinamos uma pequena árvore de predicado de ponta a ponta: parâmetro, operador e 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

Verificação rápida

Confirme o que torna uma árvore de expressões especial.

Recapitulação

Você aprendeu o que são árvores de expressões.

Expression<TDelegate> representa código como dados que podem ser inspecionados.
Os nós incluem parâmetros, constantes, operações binárias e chamadas de métodos.
Apenas lambdas de expressão única são qualificadas.
As árvores são imutáveis; a reescrita constrói novas árvores.

Perguntas Frequentes

A aula “O que são árvores de expressão” é grátis?

Sim — o texto completo de “O que são árvores de expressão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “O que são árvores de expressão”?

Entenda o código representado como uma estrutura de dados. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “O que são árvores de expressão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy