C# IExpression.GetType方法代码示例

        private void PrintNode(IExpression node, int indent)
        {
            if (node == null)
                return;

            AppendLine(indent, "{" + node.GetType().Name + "}");

            if (node is BinaryExpression)
                PrintResolvedBinaryExpression((BinaryExpression)node, indent + 1);
            else if (node is Cast)
                PrintResolvedCast((Cast)node, indent + 1);
            else if (node is Constant)
                PrintResolvedConstant((Constant)node, indent + 1);
            else if (node is FieldAccess)
                PrintResolvedFieldAccess((FieldAccess)node, indent + 1);
            else if (node is Index)
                PrintResolvedIndex((Index)node, indent + 1);
            else if (node is MethodCall)
                PrintResolvedMethodCall((MethodCall)node, indent + 1);
            else if (node is UnaryExpression)
                PrintResolvedUnaryExpression((UnaryExpression)node, indent + 1);
            else if (node is VariableAccess)
                PrintResolvedVariableAccess((VariableAccess)node, indent + 1);
            else if (node is TypeAccess)
                PrintResolvedTypeAccess((TypeAccess)node, indent + 1);
            else
                throw new NotSupportedException();
        }

		public IExpression Parse(Parser parser, IExpression left, Token<TokenType> token)
		{
			IExpression right = parser.TakeExpression(Predecence.Assign);

			if (!(left is NameExpression)) // TODO: should the parser do this check?
				throw new ParseException(left.GetLocation(), String.Format("Assign must be to a name (got {0})", left.GetType().Name));

			return new AssignExpression(left as NameExpression, right, token);
		}

 /// <returns>this</returns>
 public virtual PolyadicOperatorExpression AppendOperand(IExpression operand)
 {
     if (operand == null)
     {
         return this;
     }
     if (GetType().IsAssignableFrom(operand.GetType()))
     {
         var sub = (PolyadicOperatorExpression)operand;
         operands.AddRange(sub.operands);
     }
     else
     {
         operands.Add(operand);
     }
     return this;
 }

        /// <summary>
        /// Converts a single Expression to SQL (mapping the columns as appropriate) and appends
        /// to the given string builder.
        /// 
        /// The expression's SQL will already be wrapped in parends, so you do not need to add them
        /// here.
        /// </summary>
        /// <param name="queryToAddTo">Query we're adding the expression to.</param>
        /// <param name="expr">The expression.  NOTE: It should NOT be null. This method does not check.</param>
        /// <param name="mapping">Class mapping for the class we're dealing with.</param>
        /// <param name="colPrefix">What to prefix column names with, I.E. "Table." for "Table.Column".
        ///                         May be null if no prefix is desired.  May be something other than
        ///                         the table name if the tables are being aliased.</param>
        /// <param name="booleanOperator">The boolean operator (AND or OR) to insert before
        ///                               this expression.  Blank ("") if we don't need one.</param>
        /// <returns>Whether or not this expression modified the sql string.
        ///          Typically true, but may be false for special query types 
        ///          that use other parameters for certain types of expressions.</returns>
        protected override bool ExpressionToQuery(SqlDaQuery queryToAddTo, IExpression expr,
            ClassMapping mapping, string colPrefix, string booleanOperator)
        {
            // All the spatial expressions we support modify the sql.
            bool retVal = true;
            bool trueOrNot = expr.TrueOrNot();
            if (expr is IntersectsExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                IntersectsExpression intersects = (IntersectsExpression)expr;
                queryToAddTo.Sql.Append("ST_Intersects(ST_GeomFromEWKT(?),");
                queryToAddTo.Params.Add(_ewktWriter.Write(intersects.Shape));
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[intersects.Property]);
                queryToAddTo.Sql.Append(")");
            }
            else if (expr is WithinExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                WithinExpression within = (WithinExpression)expr;
                queryToAddTo.Sql.Append("ST_Contains(ST_GeomFromEWKT(?),");
                queryToAddTo.Params.Add(_ewktWriter.Write(within.Shape));
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[within.Property]);
                queryToAddTo.Sql.Append(")");
            }
            else if (expr is ContainsExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                ContainsExpression contains = (ContainsExpression)expr;
                queryToAddTo.Sql.Append("ST_Contains(");
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[contains.Property]);
                queryToAddTo.Sql.Append(",ST_GeomFromEWKT(?)");
                queryToAddTo.Params.Add(_ewktWriter.Write(contains.Shape));
                queryToAddTo.Sql.Append(")");
            }
            else if (expr is AbstractDistanceExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                AbstractDistanceExpression dist = (AbstractDistanceExpression)expr;

                queryToAddTo.Sql.Append("ST_Distance(");
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[dist.Property]);
                queryToAddTo.Sql.Append(", ST_GeomFromEWKT(?))");
                queryToAddTo.Params.Add(EWKTWriter.ToPoint((IPoint)dist.Shape));
                if (dist is LesserDistanceExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " < ?" : " >= ?");
                }
                else if (expr is GreaterDistanceExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " > ?" : " <= ?");
                }
                else
                {
                    throw new ArgumentException("Distance expression type " +
                                                expr.GetType() + " not supported.", "expr");
                }
                queryToAddTo.Params.Add(dist.Distance);
            }
            else if (expr is AbstractDistanceSphereExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                AbstractDistanceSphereExpression dist = (AbstractDistanceSphereExpression)expr;
                if (!(dist.Shape is IPoint))
                {
                    throw new ArgumentException("Spherical distance from a non-point is not supported.");
                }

                queryToAddTo.Sql.Append("ST_distance_sphere(");
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[dist.Property]);
                queryToAddTo.Sql.Append(", ST_GeomFromEWKT(?))");
                queryToAddTo.Params.Add(EWKTWriter.ToPoint((IPoint)dist.Shape));
                if (dist is LesserDistanceSphereExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " < ?" : " >= ?");
                }
                else if (expr is GreaterDistanceSphereExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " > ?" : " <= ?");
                }
                else
                {
                    throw new ArgumentException("Distance expression type " +
//.........这里部分代码省略.........

		protected override IExpression VisitUnknown(IExpression expression)
		{
			if ((object)expression == null)
				throw new ArgumentNullException(nameof(expression));

			if ((object)expression == VoidExpression.Instance)
			{
				this.Strings.Append(string.Empty);
				return expression;
			}

			throw new NotSupportedException(string.Format("The unknown expression of type '{0}' is not supported.", expression.GetType()));
		}

        public static string GetRefUrlFor(IExpression e)
        {
            var url = "expression.html#";

            if (e is SimpleUnaryExpression || e is UnaryExpression_Type)
                url += "UnaryExpression";
            else if (e is AnonymousClassExpression)
                url += "NewAnonClassExpression";
            else if (e is PostfixExpression) {
                if (e is PostfixExpression_Index)
                    url += "IndexExpression";
                else if (e is PostfixExpression_Slice)
                    url += "SliceExpression";
                else
                    url += "PostfixExpression";
            } else if (e is PrimaryExpression) {
                if (e is TemplateInstanceExpression)
                    url = "template.html#TemplateInstance";
                else if (e is TokenExpression) {
                    var token = (e as TokenExpression).Token;

                    if (token == DTokens.This)
                        url += "this";
                    else if (token == DTokens.Super)
                        url += "super";
                    else if (token == DTokens.Null)
                        url += "null";
                    else
                        url += "PrimaryExpression";
                } else if (e is IdentifierExpression) {
                    var id = e as IdentifierExpression;

                    if (id.Format == LiteralFormat.Scalar)
                        url = "lex.html#IntegerLiteral";
                    else if (id.Format.HasFlag (LiteralFormat.FloatingPoint))
                        url = "lex.html#FloatLiteral";
                    else if (id.Format == LiteralFormat.CharLiteral)
                        url += "CharacterLiteral";
                    else if (id.Format == LiteralFormat.StringLiteral)
                        url += "StringLiterals";
                } else if (e is ArrayLiteralExpression)
                    url += "ArrayLiteral";
                else if (e is AssocArrayExpression)
                    url += "AssocArrayLiteral";
                else if (e is FunctionLiteral)
                    url += "FunctionLiteral";
                else if (e is AssertExpression)
                    url += "AssertExpression";
                else if (e is MixinExpression)
                    url += "MixinExpression";
                else if (e is ImportExpression)
                    url += "ImportExpression";
                else if (e is TypeidExpression)
                    url += "TypeidExpression";
                else if (e is IsExpression)
                    url += "IsExpression";
                else if (e is TraitsExpression)
                    url = "traits.html#TraitsExpression";
                else
                    url += "PrimaryExpression";
            } else if (e is TypeDeclarationExpression)
                return GetRefUrlFor ((e as TypeDeclarationExpression).Declaration);
            else
                url += e.GetType ().Name;

            return url;
        }

//.........这里部分代码省略.........
                if (_connDesc.HasCaseInsensitiveLikeOperator())
                {
                    string iLikeOperator = _connDesc.CaseInsensitiveLikeOperator();
                    queryToAddTo.Sql.Append(col);
                    queryToAddTo.Sql.Append(trueOrNot
                                                ? String.Format(" {0} ", iLikeOperator)
                                                : String.Format(" NOT {0} ", iLikeOperator));
                    dbDataType = mapping.DataColTypesByObjAttr[ilike.Property];
                    AppendParameter(queryToAddTo, ilike.Value, dbDataType);
                }
                else
                {
                    string lower = _connDesc.LowerCaseFunction();
                    queryToAddTo.Sql.Append(lower).Append("(");
                    queryToAddTo.Sql.Append(col).Append(") ");
                    queryToAddTo.Sql.Append(trueOrNot ? "LIKE " : "NOT LIKE ").Append(lower).Append("(");
                    dbDataType = mapping.DataColTypesByObjAttr[ilike.Property];
                    AppendParameter(queryToAddTo, ilike.Value, dbDataType);
                    queryToAddTo.Sql.Append(")");
                }

            }
            else if (expr is PropertyInListExpression)
            {
                PropertyInListExpression inList = (PropertyInListExpression)expr;
                IEnumerable listVals = inList.Values;
                queryToAddTo.Sql.Append(colPrefix);
                queryToAddTo.Sql.Append(mapping.AllDataColsByObjAttrs[inList.Property]);
                dbDataType = mapping.DataColTypesByObjAttr[inList.Property];
                queryToAddTo.Sql.Append(trueOrNot ? " IN (" : " NOT IN (");
                bool firstIn = true;
                foreach (object val in listVals)
                {
                    if (val == null)
                    {
                        throw new NullReferenceException(
                            "Cannot include a null value in a list of possible values for " +
                            inList.Property + ".");
                    }
                    if (firstIn)
                    {
                        firstIn = false;
                    }
                    else
                    {
                        queryToAddTo.Sql.Append(", ");
                    }
                    AppendParameter(queryToAddTo, val, dbDataType);
                }
                if (firstIn)
                {
                    throw new ArgumentException("Cannot query for " + inList.Property +
                                                " values in an empty list.");
                }
                queryToAddTo.Sql.Append(")");
            }
            else if (expr is CriteriaExpression)
            {
                CriteriaExpression critExp = (CriteriaExpression)expr;
                queryToAddTo.Sql.Append(trueOrNot ? "(" : " NOT (");
                // This is slightly hacky, but basically even though we're now partway through
                // assembling a SQL statement, we might have an empty nested expression.  So rather
                // than having "AND () AND" which isn't valid, we put "1=1" for empty nested criteria.
                if ((critExp.NestedCriteria.Expressions != null) && (critExp.NestedCriteria.Expressions.Count > 0))
                {
                    ExpressionListToQuery(queryToAddTo, critExp.NestedCriteria.BoolType,
                                          critExp.NestedCriteria.Expressions, mapping, colPrefix);
                }
                else
                {
                    queryToAddTo.Sql.Append("1=1");
                }
                queryToAddTo.Sql.Append(")");
            }
            else if (expr is HandWrittenExpression)
            {
                if (!trueOrNot)
                {
                    throw new ArgumentException("You'll have to manually NOT your custom SQL.");
                }
                HandWrittenExpression hand = (HandWrittenExpression)expr;
                // We'll assume it's SQL, hopefully parameterized.
                queryToAddTo.Sql.Append(hand.Expression);
                // If there are any parameters, add 'em.
                if (hand.Parameters != null)
                {
                    foreach (object aParam in hand.Parameters)
                    {
                        queryToAddTo.Params.Add(aParam);
                    }
                }
            }
            else
            {
                throw new NotSupportedException("Expression type '" + expr.GetType() + "' is not supported.");
            }
            // Remember to close the parend.
            queryToAddTo.Sql.Append(")");
            return true;
        }

        /// <summary>
        /// Converts a single Expression to SQL (mapping the columns as appropriate) and appends
        /// to the given string builder.
        /// 
        /// The expression's SQL will already be wrapped in parens, so you do not need to add them
        /// here.
        /// </summary>
        /// <param name="queryToAddTo">Query we're adding the expression to.</param>
        /// <param name="expr">The expression.  NOTE: It should NOT be null. This method does not check.</param>
        /// <param name="mapping">Class mapping for the class we're dealing with.</param>
        /// <param name="colPrefix">What to prefix column names with, I.E. "Table." for "Table.Column".
        ///                         May be null if no prefix is desired.  May be something other than
        ///                         the table name if the tables are being aliased.</param>
        /// <param name="booleanOperator">The boolean operator (AND or OR) to insert before
        ///                               this expression.  Blank ("") if we don't need one.</param>
        /// <returns>Whether or not this expression modified the sql string.
        ///          Typically true, but may be false for special query types 
        ///          that use other parameters for certain types of expressions.</returns>
        protected override bool ExpressionToQuery(SqlDaQuery queryToAddTo, IExpression expr,
                                                  ClassMapping mapping, string colPrefix, string booleanOperator)
        {
            // All the spatial expressions we support modify the sql.
            bool retVal = true;
            bool trueOrNot = expr.TrueOrNot();
            if (expr is IntersectsExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                IntersectsExpression intersects = (IntersectsExpression)expr;

                const string intersectsFormatString = "SDE.ST_Intersects({0}, {1}) = 1";

                // It is important that the input geometry is the second parameter, otherwise the
                // spatial index does not get used.
                queryToAddTo.Sql.Append(string.Format(intersectsFormatString,
                    colPrefix + mapping.AllDataColsByObjAttrs[intersects.Property],    // Shape column name
                    string.Format("SDE.ST_Geometry(?,{0})", intersects.Shape.SRID))); // geom param converted from WKT
                queryToAddTo.Params.Add(_wktWriter.Write(intersects.Shape));
            }
            else if (expr is WithinExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                WithinExpression within = (WithinExpression)expr;

                const string withinFormatString = "SDE.ST_Within({0}, {1}) = 1";

                // It is important that the input geometry is the second parameter, otherwise the
                // spatial index does not get used.
                queryToAddTo.Sql.Append(string.Format(withinFormatString,
                    colPrefix + mapping.AllDataColsByObjAttrs[within.Property],    // Shape column name
                    string.Format("SDE.ST_Geometry(?,{0})", within.Shape.SRID))); // geom param converted from WKT
                queryToAddTo.Params.Add(_wktWriter.Write(within.Shape));
            }
            else if (expr is ContainsExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                ContainsExpression contains = (ContainsExpression)expr;
                const string containsFormatString = "SDE.ST_Contains({0}, {1}) = 1";

                // It is important that the input geometry is the second parameter, otherwise the
                // spatial index does not get used.
                queryToAddTo.Sql.Append(string.Format(containsFormatString,
                    colPrefix + mapping.AllDataColsByObjAttrs[contains.Property],    // Shape column name
                    string.Format("SDE.ST_Geometry(?,{0})", contains.Shape.SRID))); // geom param converted from WKT
                queryToAddTo.Params.Add(_wktWriter.Write(contains.Shape));
            }
            else if (expr is AbstractDistanceExpression)
            {
                queryToAddTo.Sql.Append(booleanOperator);
                AbstractDistanceExpression dist = (AbstractDistanceExpression)expr;

                queryToAddTo.Sql.Append("SDE.ST_Distance(");
                queryToAddTo.Sql.Append(colPrefix).Append(mapping.AllDataColsByObjAttrs[dist.Property]);
                queryToAddTo.Sql.Append(string.Format("SDE.ST_Contains(SDE.ST_Geometry(?,{0}),", dist.Shape.SRID));
                queryToAddTo.Params.Add(WKTWriter.ToPoint(((IPoint)dist.Shape).Coordinate));
                if (dist is LesserDistanceExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " < ?" : " >= ?");
                }
                else if (expr is GreaterDistanceExpression)
                {
                    queryToAddTo.Sql.Append(trueOrNot ? " > ?" : " <= ?");
                }
                else
                {
                    throw new ArgumentException("Distance expression type " +
                                                expr.GetType() + " not supported.", "expr");
                }
                queryToAddTo.Params.Add(dist.Distance);
            }
            else if (expr is AbstractDistanceSphereExpression)
            {
                throw new ArgumentException("Distance expression type " +
                                                expr.GetType() + " not supported.", "expr");
            }
            else
            {
                // The expression type does not required special handling by this subclass
                retVal = base.ExpressionToQuery(queryToAddTo, expr, mapping, colPrefix, booleanOperator);
            }
            return retVal;
//.........这里部分代码省略.........

		public virtual string GetSql (IExpression expr)
		{
			if (expr == null)
				throw new ArgumentNullException ("expr");
			
			Type type = expr.GetType ();
			if (type == typeof (AliasedIdentifierExpression))
				return GetExpressionSql (expr as AliasedIdentifierExpression);
			else if (type == typeof (IdentifierExpression))
				return GetExpressionSql (expr as IdentifierExpression);	
			else if (type == typeof (BooleanExpression))
				return GetExpressionSql (expr as BooleanExpression);
			else if (type == typeof (OperatorExpression))
				return GetExpressionSql (expr as OperatorExpression);
			else if (type == typeof (ParameterExpression))
				return GetExpressionSql (expr as ParameterExpression);
			else
				throw new NotImplementedException (type.FullName);
		}

        /// <summary>
        /// Translate recursive
        /// </summary>
        /// <param name="exps">Expressions</param>
        /// <param name="lastExp">Last expression</param>
        /// <returns></returns>
        Stack<IExpression> RecursiveTranslate(Stack<IExpression> exps, IExpression lastExp)
        {
            IExpression actualExp = Peek();

            if (lastExp == null)
            {
                actualExp = Pop();
            }
            else if (lastExp.GetType() == typeof(ConstructorExpression))
            {
                actualExp = Pop();
                exps.Push((lastExp as ConstructorExpression).Evaluate());
            }
            else if (lastExp.GetType() == typeof(Value))
            {
                actualExp = Pop();
                if ((lastExp as Value).VariableType == VariableType.CUSTOM)
                {
                    if (actualExp.GetType() == typeof(VariableExpression))
                    {
                        actualExp = Pop();
                        Expressions.Push(new VariableExpression((actualExp as VariableExpression).Name, lastExp.Evaluate().ObjectValue as CustomObject));
                        actualExp = Pop();
                    }
                    else if (actualExp.GetType() == typeof(MethodCallExpression))
                    {
                        actualExp = Pop();
                        exps.Push((actualExp as MethodCallExpression).Evaluate(lastExp.Evaluate().ObjectValue as CustomObject));
                    }
                }
                else
                    exps.Push(lastExp);
            }
            else if (lastExp.GetType() == typeof(VariableExpression))
            {
                if (actualExp.GetType() == typeof(VariableExpression))
                {
                    actualExp = Pop();
                    Expressions.Push(new VariableExpression((actualExp as VariableExpression).Name, lastExp.Evaluate().ObjectValue as CustomObject));
                    actualExp = Pop();
                }
                else if (actualExp.GetType() == typeof(MethodCallExpression))
                {
                    actualExp = Pop();
                    exps.Push((actualExp as MethodCallExpression).Evaluate(lastExp.Evaluate().ObjectValue as CustomObject));
                }
                else
                {
                    actualExp = Pop();
                    exps.Push(lastExp.Evaluate());
                }
            }
            else if (lastExp.GetType() == typeof(OperatorExpression))
            {
                actualExp = Pop();
                exps.Push(lastExp);
            }
            else if (lastExp.GetType() == typeof(MethodCallExpression))
            {
                actualExp = Pop();
                exps.Push((lastExp as MethodCallExpression).Evaluate());
            }

            if (HasNextExp())
                return RecursiveTranslate(exps, actualExp);

            if (actualExp.GetType() == typeof(OperatorExpression))
                exps.Push(actualExp);
            else
                exps.Push(actualExp.Evaluate());

            return exps;
        }

        protected override IExpression VisitUnknown(IExpression expression)
        {
            if ((object)expression == null)
                throw new ArgumentNullException("expression");

            throw new NotSupportedException(string.Format("The unknown expression of type '{0}' is not supported.", expression.GetType()));
        }

//.........这里部分代码省略.........
            }

            if (value is IArrayIndexerExpression)
            {
                this.VisitArrayIndexerExpression(value as IArrayIndexerExpression);
                return;
            }

            if (value is IDelegateInvokeExpression)
            {
                this.VisitDelegateInvokeExpression(value as IDelegateInvokeExpression);
                return;
            }

            if (value is IObjectCreateExpression)
            {
                this.VisitObjectCreateExpression(value as IObjectCreateExpression);
                return;
            }

            if (value is IAddressOfExpression)
            {
                this.VisitAddressOfExpression(value as IAddressOfExpression);
                return;
            }

            if (value is IAddressReferenceExpression)
            {
                this.VisitAddressReferenceExpression(value as IAddressReferenceExpression);
                return;
            }

            if (value is IAddressOutExpression)
            {
                this.VisitAddressOutExpression(value as IAddressOutExpression);
                return;
            }

            if (value is IAddressDereferenceExpression)
            {
                this.VisitAddressDereferenceExpression(value as IAddressDereferenceExpression);
                return;
            }

            if (value is ISizeOfExpression)
            {
                this.VisitSizeOfExpression(value as ISizeOfExpression);
                return;
            }

            if (value is ITypedReferenceCreateExpression)
            {
                this.VisitTypedReferenceCreateExpression(value as ITypedReferenceCreateExpression);
                return;
            }

            if (value is ITypeOfTypedReferenceExpression)
            {
                this.VisitTypeOfTypedReferenceExpression(value as ITypeOfTypedReferenceExpression);
                return;
            }

            if (value is IValueOfTypedReferenceExpression)
            {
                this.VisitValueOfTypedReferenceExpression(value as IValueOfTypedReferenceExpression);
                return;
            }

            if (value is IStackAllocateExpression)
            {
                this.VisitStackAllocateExpression(value as IStackAllocateExpression);
                return;
            }

            if (value is IGenericDefaultExpression)
            {
                this.VisitGenericDefaultExpression(value as IGenericDefaultExpression);
                return;
            }

            if (value is IQueryExpression)
            {
                this.VisitQueryExpression(value as IQueryExpression);
                return;
            }

            if (value is ILambdaExpression)
            {
                this.VisitLambdaExpression(value as ILambdaExpression);
                return;
            }

            if (value is ISnippetExpression)
            {
                this.VisitSnippetExpression(value as ISnippetExpression);
                return;
            }

            throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Invalid expression type '{0}'.", value.GetType().Name));
        }