Como: Modificar as árvores de expressão (C# e Visual Basic)

Este tópico mostra como modificar uma árvore de expressão. Árvores de expressão são imutáveis, o que significa que eles não podem ser modificados diretamente. Para alterar uma árvore de expressão, você deve criar uma cópia de uma árvore de expressão existente e quando você cria a cópia, faça as alterações necessárias. Você pode usar o ExpressionVisitor para percorrer uma árvore de expressão existente e copiar a cada nó de classe que ele visitas.

Observação
Você pode encontrar o código-fonte para o ExpressionVisitor classe a CodePlex site da Web.

Para modificar uma árvore de expressão

1. Em Visual Studio, crie uma nova Aplicativo de Console project.

2. Adicionar o AndAlsoModifier classe ao seu projeto.

   Esta classe herda de ExpressionVisitor de classe e é especializado para modificar as expressões que representam condicional AND as operações. Ele se altera essas operações de uma condicional AND para uma condicional OR. Para fazer isso, as substituições de classe de VisitBinary o método do tipo base, porque condicional AND expressões são representadas como expressões binários. No VisitBinary método, se a expressão que é passada para ele representa uma condicional AND operação, o código constrói uma nova expressão que contém o condicional OR o operador em vez da condicional AND operador. Se a expressão que é passada para VisitBinary não representa uma condicional AND o método de operação, adia a implementação da classe base. Os métodos de classe base, nós de construção são como as árvores de expressão são passadas em, mas os nós têm suas árvores de sub substituídos com as árvores de expressão são produzidos recursivamente pelo visitante.

   Adicionar um using diretiva (ou Imports instrução em Visual Basic) o arquivo para o System.Linq.Expressions namespace.

   Public Class AndAlsoModifier
       Inherits ExpressionVisitor
   
       Public Function Modify(ByVal expr As Expression) As Expression
           Return Visit(expr)
       End Function
   
       Protected Overrides Function VisitBinary(ByVal b As BinaryExpression) As Expression
           If b.NodeType = ExpressionType.AndAlso Then
               Dim left = Me.Visit(b.Left)
               Dim right = Me.Visit(b.Right)
   
               ' Make this binary expression an OrElse operation instead 
               ' of an AndAlso operation.
               Return Expression.MakeBinary(ExpressionType.OrElse, left, right, _
                                            b.IsLiftedToNull, b.Method)
           End If
   
           Return MyBase.VisitBinary(b)
       End Function
   End Class
   

   public class AndAlsoModifier : ExpressionVisitor
   {
       public Expression Modify(Expression expression)
       {
           return Visit(expression);
       }
   
       protected override Expression VisitBinary(BinaryExpression b)
       {
           if (b.NodeType == ExpressionType.AndAlso)
           {
               Expression left = this.Visit(b.Left);
               Expression right = this.Visit(b.Right);
   
               // Make this binary expression an OrElse operation instead of an AndAlso operation.
               return Expression.MakeBinary(ExpressionType.OrElse, left, right, b.IsLiftedToNull, b.Method);
           }
   
           return base.VisitBinary(b);
       }
   }
   

3. Adicione código para o Main método no arquivo Program. cs (Module1. vb no Visual Basic) para criar uma árvore de expressão e passá-lo para o método que irá modificar o proprietário.

   O código a seguir cria uma expressão que contenha uma condicional AND operação. Ele cria uma instância da AndAlsoModifier de classe e passa a expressão para o Modify método nesta classe. As árvores de expressão modificado e originais são saídas para mostrar a alteração.

   Adicionar um using diretiva (ou Imports instrução em Visual Basic) o arquivo para o System.Linq.Expressions namespace.

           Dim expr As Expression(Of Func(Of String, Boolean)) = _
               Function(name) name.Length > 10 AndAlso name.StartsWith("G")
   
           Console.WriteLine(expr)
   
           Dim modifier As New AndAlsoModifier()
           Dim modifiedExpr = modifier.Modify(CType(expr, Expression))
   
           Console.WriteLine(modifiedExpr)
   
           ' This code produces the following output:
           ' name => ((name.Length > 10) && name.StartsWith("G"))
           ' name => ((name.Length > 10) || name.StartsWith("G"))
   
   

               Expression<Func<string, bool>> expr = name => name.Length > 10 && name.StartsWith("G");
               Console.WriteLine(expr);
   
               AndAlsoModifier treeModifier = new AndAlsoModifier();
               Expression modifiedExpr = treeModifier.Modify((Expression) expr);
   
               Console.WriteLine(modifiedExpr);
   
               /*  This code produces the following output:
   
                   name => ((name.Length > 10) && name.StartsWith("G"))
                   name => ((name.Length > 10) || name.StartsWith("G"))
               */
   
   

4. Compile e execute o aplicativo.

Consulte também

Tarefas

Como: Executar as árvores de expressão (C# e Visual Basic)

Conceitos

Árvores de expressão (C# e Visual Basic)