System.Data.Common.CommandTrees.Internal.ExpressionDumper.End(System.Data.Common.CommandTrees.DbExpression)

Here are the examples of the csharp api class System.Data.Common.CommandTrees.Internal.ExpressionDumper.End(System.Data.Common.CommandTrees.DbExpression) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

public override void Visit(DbExpression e)
        {
            Begin(e);
            End(e);
        }

public override void Visit(DbNullExpression e)
        {
            Begin(e);
            End(e);
        }

public override void Visit(DbComparisonExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbIsNullExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbAndExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbOrExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbNotExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbDistinctExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbElementExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbIsEmptyExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbUnionAllExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbIntersectExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbExceptExpression e)
        {
            BeginBinary(e);
            End(e);
        }

public override void Visit(DbTreatExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbCastExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbRefExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbDerefExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbRefKeyExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbEntityRefExpression e)
        {
            BeginUnary(e);
            End(e);
        }

public override void Visit(DbConstantExpression e)
        {
            Dictionary<string, object> attrs = new Dictionary<string,object>();
            attrs.Add("Value", e.Value);
            Begin(e, attrs);
            End(e);
        }

public override void Visit(DbVariableReferenceExpression e)
        {
            Dictionary<string, object> attrs = new Dictionary<string, object>();
            attrs.Add("VariableName", e.VariableName);
            Begin(e, attrs);
            End(e);
        }

public override void Visit(DbParameterReferenceExpression e)
        {
            Dictionary<string, object> attrs = new Dictionary<string, object>();
            attrs.Add("ParameterName", e.ParameterName);
            Begin(e, attrs);
            End(e);
        }

public override void Visit(DbLikeExpression e)
        {
            Begin(e);
            Dump(e.Argument, "Argument");
            Dump(e.Pattern, "Pattern");
            Dump(e.Escape, "Escape");
            End(e);
        }

public override void Visit(DbLimitExpression e)
        {
            Begin(e, "WithTies", e.WithTies);
            Dump(e.Argument, "Argument");
            Dump(e.Limit, "Limit");
            End(e);
        }

public override void Visit(DbArithmeticExpression e)
        {
            Begin(e);
            Dump(e.Arguments, "Arguments", "Argument");
            End(e);
        }

public override void Visit(DbIsOfExpression e)
        {
            BeginUnary(e);
            Dump(e.OfType, "OfType") ;
            End(e);
        }

public override void Visit(DbOfTypeExpression e)
        {
            BeginUnary(e);
            Dump(e.OfType, "OfType");
            End(e);
        }

public override void Visit(DbApplyExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Apply, "Apply");
            End(e);
        }

public override void Visit(DbFunctionExpression e)
        {
            Begin(e);
            Dump(e.Function);
            Dump(e.Arguments, "Arguments", "Argument");
            End(e);
        }

public override void Visit(DbLambdaExpression expression)
        {
            Begin(expression);
            Dump(expression.Lambda);
            Dump(expression.Arguments, "Arguments", "Argument");
            End(expression);
        }

public override void Visit(DbFilterExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Predicate, "Predicate");
            End(e);
        }

public override void Visit(DbProjectExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Projection, "Projection");
            End(e);
        }

public override void Visit(DbJoinExpression e)
        {
            Begin(e);
            Dump(e.Left, "Left");
            Dump(e.Right, "Right");
            Dump(e.JoinCondition, "JoinCondition");
            End(e);
        }

public override void Visit(DbSortExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.SortOrder);
            End(e);
        }

public override void Visit(DbQuantifierExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Predicate, "Predicate");
            End(e);
        }

public override void Visit(DbNewInstanceExpression e)
        {
            Begin(e);
            Dump(e.Arguments, "Arguments", "Argument");
            if (e.HasRelatedEntityReferences)
            {
                Begin("RelatedEntityReferences");
                foreach (DbRelatedEntityRef relatedRef in e.RelatedEntityReferences)
                {
                    Begin("DbRelatedEntityRef");
                    Dump(relatedRef.SourceEnd, "SourceEnd");
                    Dump(relatedRef.TargetEnd, "TargetEnd");
                    Dump(relatedRef.TargetEntityReference, "TargetEntityReference");
                    End("DbRelatedEntityRef");
                }
                End("RelatedEntityReferences");
            }
            End(e);
        }

public override void Visit(DbRelationshipNavigationExpression e)
        {
            Begin(e);
            Dump(e.NavigateFrom, "NavigateFrom");
            Dump(e.NavigateTo, "NavigateTo");
            Dump(e.Relationship, "Relationship");
            Dump(e.NavigationSource, "NavigationSource");
            End(e);
        }

public override void Visit(DbScanExpression e)
        {
            Begin(e);
            Begin("Target", "Name", e.Target.Name, "Container", e.Target.EntityContainer.Name);
            Dump(e.Target.ElementType, "TargetElementType");
            End("Target");
            End(e);
        }

public override void Visit(DbCrossJoinExpression e)
        {
            Begin(e);
            Begin("Inputs");
            foreach (DbExpressionBinding binding in e.Inputs)
            {
                Dump(binding, "Input");
            }
            End("Inputs");
            End(e);
        }

public override void Visit(DbSkipExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.SortOrder);
            Dump(e.Count, "Count");
            End(e);
        }

public override void Visit(DbPropertyExpression e)
        {
            //
            // Currently the DbPropertyExpression.EdmProperty member property may only be either:
            // - EdmProperty 
            // - RelationshipEndMember
            // - NavigationProperty
            //
            Begin(e);
            RelationshipEndMember end = e.Property as RelationshipEndMember;
            if (end != null)
            {
                Dump(end, "Property");
            }
            else if (Helper.IsNavigationProperty(e.Property))
            {
                Dump((NavigationProperty)e.Property, "Property");
            }
            else
            {
                Dump((EdmProperty)e.Property);
            }
                        
            if (e.Instance != null)
            {
                Dump(e.Instance, "Instance");
            }
            End(e);
        }

public override void Visit(DbGroupByExpression e)
        {
            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Keys, "Keys", "Key");
            Begin("Aggregates");
            foreach (DbAggregate agg in e.Aggregates)
            {
                DbFunctionAggregate funcAgg = agg as DbFunctionAggregate;

                if (funcAgg != null)
                {
                    Begin("DbFunctionAggregate");
                    Dump(funcAgg.Function);
                    Dump(funcAgg.Arguments, "Arguments", "Argument");
                    End("DbFunctionAggregate"); 
                }
                else
                {
                    DbGroupAggregate groupAgg = agg as DbGroupAggregate;
                    Debug.Assert(groupAgg != null, "Invalid DbAggregate");
                    Begin("DbGroupAggregate");
                    Dump(groupAgg.Arguments, "Arguments", "Argument");
                    End("DbGroupAggregate");
                }
            }
            End("Aggregates");
            End(e);
        }