C# Academy · Aula

Construindo expressões manualmente

Construa árvores de expressão com a API Expression.

Construindo expressões manualmente é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 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.

Construindo árvores manualmente

Além de permitir que o compilador construa uma árvore a partir de uma lambda, você pode criar uma por conta própria usando os 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

Criando um parâmetro

Expression.Parameter(type, name) cria um nó de parâmetro que você pode referenciar no corpo e associar a uma lambda.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
Console.WriteLine(x.Name + " : " + x.Type); // x : System.Int32

Criando uma constante

Expression.Constant(value) incorpora um literal. Opcionalmente, você pode especificar o 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

Adição de expressões

Os operadores binários têm fábricas como Expression.Add. Elas recebem duas expressões operandas e constroem uma 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)

Outros operadores binários

Há fábricas para o conjunto completo: Subtract, Multiply, Divide, GreaterThan, Equal e outros.

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)

Encapsulando em uma lambda

Expression.Lambda reúne um corpo e parâmetros em uma Expression<TDelegate> que você pode compilar posteriormente.

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)

Compondo expressões aninhadas

As fábricas podem ser aninhadas livremente, permitindo construir expressões complexas, como (x + 1) * 2, passo a passo.

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)

Acesso a membros

Expression.Property e Expression.Field constroem nós de acesso a membros.

using System;
using System.Linq.Expressions;

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

Chamadas de métodos

Expression.Call constrói um nó de invocação com o destino, o método e os argumentos fornecidos.

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

Verificação de tipos durante a construção

As fábricas validam os tipos dos operandos durante a construção. Tipos incompatíveis geram uma exceção imediatamente, identificando erros antecipadamente.

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

Reunindo tudo

Construa a lambda x => (x + 1) * 2 inteiramente à mão.

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)

Verificação rápida

Confirme como funciona a construção manual de expressões.

Recapitulação

Você aprendeu a construir árvores de expressões manualmente.

Expression.Parameter e Expression.Constant criam nós folha.
Expression.Add e seus semelhantes constroem operações binárias.
Expression.Property e Expression.Call tratam de membros e métodos.
Expression.Lambda monta uma árvore chamável.

Perguntas Frequentes

A aula “Construindo expressões manualmente” é grátis?

Sim — o texto completo de “Construindo expressões manualmente” é 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 “Construindo expressões manualmente”?

Construa árvores de expressão com a API Expression. 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 2 de 4.

Quanto tempo leva a aula “Construindo expressões manualmente”?

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