ExpressionVisitor抽象类源码

最新推荐文章于 2023-12-20 12:33:02 发布
最新推荐文章于 2023-12-20 12:33:02 发布
阅读量907 收藏
点赞数
分类专栏： .NET

ExpressionVisitor抽象类源码，仅为记住这个好类


//http://blogs.msdn.com/b/mattwar/archive/2007/07/31/linq-building-an-iqueryable-provider-part-ii.aspx
public abstract class ExpressionVisitor
    {
        protected virtual Expression Visit(Expression exp)
        {
            if (exp == null)
                return exp;
            switch (exp.NodeType)
            {
                case ExpressionType.Negate:
                case ExpressionType.NegateChecked:
                case ExpressionType.Not:
                case ExpressionType.Convert:
                case ExpressionType.ConvertChecked:
                case ExpressionType.ArrayLength:
                case ExpressionType.Quote:
                case ExpressionType.TypeAs:
                    return this.VisitUnary((UnaryExpression)exp);
                case ExpressionType.Add:
                case ExpressionType.AddChecked:
                case ExpressionType.Subtract:
                case ExpressionType.SubtractChecked:
                case ExpressionType.Multiply:
                case ExpressionType.MultiplyChecked:
                case ExpressionType.Divide:
                case ExpressionType.Modulo:
                case ExpressionType.And:
                case ExpressionType.AndAlso:
                case ExpressionType.Or:
                case ExpressionType.OrElse:
                case ExpressionType.LessThan:
                case ExpressionType.LessThanOrEqual:
                case ExpressionType.GreaterThan:
                case ExpressionType.GreaterThanOrEqual:
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                case ExpressionType.Coalesce:
                case ExpressionType.ArrayIndex:
                case ExpressionType.RightShift:
                case ExpressionType.LeftShift:
                case ExpressionType.ExclusiveOr:
                    return this.VisitBinary((BinaryExpression)exp);
                case ExpressionType.TypeIs:
                    return this.VisitTypeIs((TypeBinaryExpression)exp);
                case ExpressionType.Conditional:
                    return this.VisitConditional((ConditionalExpression)exp);
                case ExpressionType.Constant:
                    return this.VisitConstant((ConstantExpression)exp);
                case ExpressionType.Parameter:
                    return this.VisitParameter((ParameterExpression)exp);
                case ExpressionType.MemberAccess:
                    return this.VisitMemberAccess((MemberExpression)exp);
                case ExpressionType.Call:
                    return this.VisitMethodCall((MethodCallExpression)exp);
                case ExpressionType.Lambda:
                    return this.VisitLambda((LambdaExpression)exp);
                case ExpressionType.New:
                    return this.VisitNew((NewExpression)exp);
                case ExpressionType.NewArrayInit:
                case ExpressionType.NewArrayBounds:
                    return this.VisitNewArray((NewArrayExpression)exp);
                case ExpressionType.Invoke:
                    return this.VisitInvocation((InvocationExpression)exp);
                case ExpressionType.MemberInit:
                    return this.VisitMemberInit((MemberInitExpression)exp);
                case ExpressionType.ListInit:
                    return this.VisitListInit((ListInitExpression)exp);
                default:
                    throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
            }
        }

        protected virtual MemberBinding VisitBinding(MemberBinding binding)
        {
            switch (binding.BindingType)
            {
                case MemberBindingType.Assignment:
                    return this.VisitMemberAssignment((MemberAssignment)binding);
                case MemberBindingType.MemberBinding:
                    return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
                case MemberBindingType.ListBinding:
                    return this.VisitMemberListBinding((MemberListBinding)binding);
                default:
                    throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
            }
        }

        protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
        {
            ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);
            if (arguments != initializer.Arguments)
            {
                return Expression.ElementInit(initializer.AddMethod, arguments);
            }
            return initializer;
        }

        protected virtual Expression VisitUnary(UnaryExpression u)
        {
            Expression operand = this.Visit(u.Operand);
            if (operand != u.Operand)
            {
                return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
            }
            return u;
        }

        protected virtual Expression VisitBinary(BinaryExpression b)
        {
            Expression left = this.Visit(b.Left);
            Expression right = this.Visit(b.Right);
            Expression conversion = this.Visit(b.Conversion);
            if (left != b.Left || right != b.Right || conversion != b.Conversion)
            {
                if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
                    return Expression.Coalesce(left, right, conversion as LambdaExpression);
                else
                    return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
            }
            return b;
        }

        protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
        {
            Expression expr = this.Visit(b.Expression);
            if (expr != b.Expression)
            {
                return Expression.TypeIs(expr, b.TypeOperand);
            }
            return b;
        }

        protected virtual Expression VisitConstant(ConstantExpression c)
        {
            return c;
        }

        protected virtual Expression VisitConditional(ConditionalExpression c)
        {
            Expression test = this.Visit(c.Test);
            Expression ifTrue = this.Visit(c.IfTrue);
            Expression ifFalse = this.Visit(c.IfFalse);
            if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
            {
                return Expression.Condition(test, ifTrue, ifFalse);
            }
            return c;
        }

        protected virtual Expression VisitParameter(ParameterExpression p)
        {
            return p;
        }

        protected virtual Expression VisitMemberAccess(MemberExpression m)
        {
            Expression exp = this.Visit(m.Expression);
            if (exp != m.Expression)
            {
                return Expression.MakeMemberAccess(exp, m.Member);
            }
            return m;
        }

        protected virtual Expression VisitMethodCall(MethodCallExpression m)
        {
            Expression obj = this.Visit(m.Object);
            IEnumerable<Expression> args = this.VisitExpressionList(m.Arguments);
            if (obj != m.Object || args != m.Arguments)
            {
                return Expression.Call(obj, m.Method, args);
            }
            return m;
        }

        protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)
        {
            List<Expression> list = null;
            for (int i = 0, n = original.Count; i < n; i++)
            {
                Expression p = this.Visit(original[i]);
                if (list != null)
                {
                    list.Add(p);
                }
                else if (p != original[i])
                {
                    list = new List<Expression>(n);
                    for (int j = 0; j < i; j++)
                    {
                        list.Add(original[j]);
                    }
                    list.Add(p);
                }
            }
            if (list != null)
            {
                return list.AsReadOnly();
            }
            return original;
        }

        protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
        {
            Expression e = this.Visit(assignment.Expression);
            if (e != assignment.Expression)
            {
                return Expression.Bind(assignment.Member, e);
            }
            return assignment;
        }

        protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
        {
            IEnumerable<MemberBinding> bindings = this.VisitBindingList(binding.Bindings);
            if (bindings != binding.Bindings)
            {
                return Expression.MemberBind(binding.Member, bindings);
            }
            return binding;
        }

        protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)
        {
            IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(binding.Initializers);
            if (initializers != binding.Initializers)
            {
                return Expression.ListBind(binding.Member, initializers);
            }
            return binding;
        }

        protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)
        {
            List<MemberBinding> list = null;
            for (int i = 0, n = original.Count; i < n; i++)
            {
                MemberBinding b = this.VisitBinding(original[i]);
                if (list != null)
                {
                    list.Add(b);
                }
                else if (b != original[i])
                {
                    list = new List<MemberBinding>(n);
                    for (int j = 0; j < i; j++)
                    {
                        list.Add(original[j]);
                    }
                    list.Add(b);
                }
            }
            if (list != null)
                return list;
            return original;
        }

        protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)
        {
            List<ElementInit> list = null;
            for (int i = 0, n = original.Count; i < n; i++)
            {
                ElementInit init = this.VisitElementInitializer(original[i]);
                if (list != null)
                {
                    list.Add(init);
                }
                else if (init != original[i])
                {
                    list = new List<ElementInit>(n);
                    for (int j = 0; j < i; j++)
                    {
                        list.Add(original[j]);
                    }
                    list.Add(init);
                }
            }
            if (list != null)
                return list;
            return original;
        }

        protected virtual Expression VisitLambda(LambdaExpression lambda)
        {
            Expression body = this.Visit(lambda.Body);
            if (body != lambda.Body)
            {
                return Expression.Lambda(lambda.Type, body, lambda.Parameters);
            }
            return lambda;
        }

        protected virtual NewExpression VisitNew(NewExpression nex)
        {
            IEnumerable<Expression> args = this.VisitExpressionList(nex.Arguments);
            if (args != nex.Arguments)
            {
                if (nex.Members != null)
                    return Expression.New(nex.Constructor, args, nex.Members);
                else
                    return Expression.New(nex.Constructor, args);
            }
            return nex;
        }

        protected virtual Expression VisitMemberInit(MemberInitExpression init)
        {
            NewExpression n = this.VisitNew(init.NewExpression);
            IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings);
            if (n != init.NewExpression || bindings != init.Bindings)
            {
                return Expression.MemberInit(n, bindings);
            }
            return init;
        }

        protected virtual Expression VisitListInit(ListInitExpression init)
        {
            NewExpression n = this.VisitNew(init.NewExpression);
            IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);
            if (n != init.NewExpression || initializers != init.Initializers)
            {
                return Expression.ListInit(n, initializers);
            }
            return init;
        }

        protected virtual Expression VisitNewArray(NewArrayExpression na)
        {
            IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);
            if (exprs != na.Expressions)
            {
                if (na.NodeType == ExpressionType.NewArrayInit)
                {
                    return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
                }
                else
                {
                    return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
                }
            }
            return na;
        }

        protected virtual Expression VisitInvocation(InvocationExpression iv)
        {
            IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
            Expression expr = this.Visit(iv.Expression);
            if (args != iv.Arguments || expr != iv.Expression)
            {
                return Expression.Invoke(expr, args);
            }
            return iv;
        }
    }
移山小斗车
关注
专栏目录
《c#进阶》--04.表达式树
qq_43372178的博客
06-15 839
C#进阶语法表达式树，包括原生的方法描述的原理，底层方法，以及语法糖，相关的案例和应用场景，一些方法的封装
用C#实现Visitor模式
jotter的专栏
06-30 1320
Visitor模式：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。public abstract class Pet {  abstract public void Accept(Visitor v); } public class Cat:Pet {  private string state="";  public Cat(strin
C# Expression visitor
Rocky的专栏
05-17 305
C# Expression visitor /// <summary> /// Expression visitor /// (from http://blogs.msdn.com/mattwar/archive/2007/07/31/linq-building-an-iqueryable-provider-part-ii....
使用ExpressionVisitor进行lambadaExpression的动态拼接
weixin_30950237的博客
06-11 893
现有如下实体 public class User { public int Id { get; set; } public string Name { get; set; } } 根据这个实体创建一个Iqueryable<User>对象queryList List<User> dList = ...
Java抽象类和接口相关操作源码.rar
07-10
在这个“Java抽象类和接口相关操作源码”压缩包中，你可能会找到一系列的实例代码，帮助初学者更好地理解和运用这两种特性。 **抽象类（Abstract Class）** 抽象类在Java中是一种不能被实例化的类，它主要用于被...
java类源码-ComputerStore:一个简单的"电脑商店"Java源码,主要用来学习了解java的接口,抽象类以及类的继承关系
05-19
类源码 一个简单的 "电脑商店" Java源码 PC 的配置有各种组合, 相互组合为完整的电脑 CPU: Intel, AMD 硬盘: 希捷, 西部数据 等 显卡: 英伟达, AMD 等 主板电源内存等 这个程序比较简单, 只涉及了CPU和硬盘 可以查看...
Java集合（5）——List接口与AbstractList抽象类源码解析
想当厨子的程序媛
02-25 1692
List接口 List是一个有序、可以重复，可以有null元素的集合 类图 官方文档 List成员方法 其中“有序”，指的是存储的时候按照元素的添加顺序进行存储和获取。 有序的集合（也成为序列）。该接口的开发人员可以精确的控制列表中每个元素的插入位置。开发人员可以通过索引访问元素，并搜索列表中的元素 与Set不同的是，列表通常允许重复的元素。更正式的说，列表通...
阅读EnumSet抽象类
08-28
了解EnumSet抽象类的源码和实现机制 EnumSet抽象类是Java枚举类型的泛型容器，具有速度快、占用内存小、效率高等特性。EnumSet的设计是专门为枚举类的集合类，所有元素必须是枚举类型，集合元素是有序的，内部以位...
java写抽象类的测试_如何使用JUnit在Java中测试抽象类？
weixin_26907223的博客
02-23 2898
如何使用JUnit在Java中测试抽象类？我是JUnit的Java测试新手。 我必须使用Java，我想使用单元测试。我的问题是：我有一个带有一些抽象方法的抽象类。 但是有些方法并不是抽象的。 如何使用JUnit测试此类？ 示例代码(非常简单)：abstract class Car {public Car(int speed, int fuel) {this.speed = speed;this.f...
C# .Net学习笔记—— Expression 表达式目录树
最新发布
weixin_46711336的博客
12-20 1717
C#学习，表达式目录树
C# Expression 表达树
weixin_43602710的博客
11-22 892
什么是表达式树？ 表达式是对于一段可执行代码的文字形式，它本身是不可以执行的。如BinaryExpression，ConstantExpression，LambdaExpression 下面的例子把两个表达式组建成了一个表达式树 Expression firstArg = Expression.Constant(2); Expression secondArg = Expression.Con...
c#分页_C# 表达式树遍历（二）
weixin_39932611的博客
11-19 120
一、前言上一篇我们对表达式树有了初步的认识，这里我们将对表达式树进行遍历，只有弄清楚了他的运行原理，我们才可以对他进行定制化修改。表达式系列目录C# 表达式树讲解（一）C# 表达式树遍历（二） C# 表达式树分页扩展（三）C# 表达式树Lambda扩展（四）二、表达式树的遍历要查看表达式树的遍历，肯定不能直接用.Net Framework封装的方法，因为.Net Framework框架是闭源的，除...
Expression Trees--C#
mucangmang的博客
08-14 960
https://docs.microsoft.com/en-us/dotnet/csharp/expression-trees 一，表达式树能做什么   1）表达式树加强方法和参数的交互；   2）表达式树可以在运行时操作代码，比如检查运行的算法，增加新的功能。 二，表达式树是什么   以var sum = 1 + 2为例，该语句就可以看作表达式树： 声明变量(var sum) v...
（十一）.net表达式目录树Expression
lwy
11-25 1640
表达式目录树Expression拆解，动态拼装，生成sql等
Expression 表达式目录树
againknow的博客
01-31 396
Expression 表达式目录树
lambda表达式的解析（一） 序
guoyichao的专栏
07-27 6085
当你要把一个表达式字符串转换成一个lambda expression，本篇也许能帮到你。 把一个字符串解析成lambda要做的工作其实就2个，第一步把字符串通过语法解析转换一颗语法树，第二步就是遍历这棵树把它转换成.lambda expression。做一个C#语法解析器是件麻烦事，好在有一些现成的解析器可以使用，这里选用Irony来完成这个工作。 Irony的包里含有一个Sample的C#
表达式目录树的拼接AND、Or、Not
佛陀爱老虎的博客
05-29 2136
表达式目录树的拼接AND、Or、Not 表达式目录树的拼接AND、Or、Not 1.利用ExpressionVisitor统一参数 2. 合并表达式 expr1 AND expr2 3. 合并表达式 expr1 or expr2 4.Not 1.利用ExpressionVisitor统一参数 遍历表达式类型，当遇到参数类型表达式时，替换为我们自己定义的参数。 inte...
Java抽象类与接口详解
"接口和抽象类是面向对象编程中的重要概念，它们在Java等面向对象语言中被广泛使用。抽象类是一种特殊的类，它包含了抽象方法，这些方法只有声明而没有具体的实现。抽象方法需要使用`abstract`关键字来标识，同时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值