---
title: "How to modify expression trees (C#)"
description: Learn how to modify an expression tree by creating a copy of an existing expression tree and making the required changes. 
ms.date: 07/20/2015
ms.assetid: 9b0cd8c2-457e-4833-9e36-31e79545f442
---
# How to modify expression trees (C#)

This topic shows you how to modify an expression tree.  Expression trees are immutable, which means that they cannot be modified directly.  To change an expression tree, you must create a copy of an existing expression tree and when you create the copy, make the required changes.  You can use the <xref:System. Linq. Expressions. ExpressionVisitor> class to traverse an existing expression tree and to copy each node that it visits.   
  
### To modify an expression tree  
  
1.  Create a new **Console Application** project.   
  
2.  Add a `using` directive to the file for the `System. Linq. Expressions` namespace.   
  
3.  Add the `AndAlsoModifier` class to your project.   
  
    ```csharp  
    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);  
        }  
    }  
    ```  
  
     This class inherits the <xref:System. Linq. Expressions. ExpressionVisitor> class and is specialized to modify expressions that represent conditional `AND` operations.  It changes these operations from a conditional `AND` to a conditional `OR`.  To do this, the class overrides the <xref:System. Linq. Expressions. ExpressionVisitor. VisitBinary%2A> method of the base type, because conditional `AND` expressions are represented as binary expressions.  In the `VisitBinary` method, if the expression that is passed to it represents a conditional `AND` operation, the code constructs a new expression that contains the conditional `OR` operator instead of the conditional `AND` operator.  If the expression that is passed to `VisitBinary` does not represent a conditional `AND` operation, the method defers to the base class implementation.  The base class methods construct nodes that are like the expression trees that are passed in, but the nodes have their sub trees replaced with the expression trees that are produced recursively by the visitor.   
  
4.  Add a `using` directive to the file for the `System. Linq. Expressions` namespace.   
  
5.  Add code to the `Main` method in the Program.cs file to create an expression tree and pass it to the method that will modify it.   
  
    ```csharp  
    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"))  
    */  
    ```  
  
     The code creates an expression that contains a conditional `AND` operation.  It then creates an instance of the `AndAlsoModifier` class and passes the expression to the `Modify` method of this class.  Both the original and the modified expression trees are outputted to show the change.   
  
6.  Compile and run the application.   
  
## See also

- [How to execute expression trees (C#)](./how-to-execute-expression-trees.md)
- [Expression Trees (C#)](./index.md)
