using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Dynamic.Utils; using System.Reflection; using System.Runtime.CompilerServices; using Cpp2IlInjected; namespace System.Linq.Expressions { /// Provides the base class from which the classes that represent expression tree nodes are derived. It also contains ( in Visual Basic) factory methods to create the various node types. This is an class. // Token: 0x02000053 RID: 83 [Token(Token = "0x2000053")] public abstract class Expression { /// Creates a that represents an assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x06000251 RID: 593 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000251")] [Address(RVA = "0x543580", Offset = "0x542380", VA = "0x180543580")] public static BinaryExpression Assign(Expression left, Expression right) { return null; } // Token: 0x06000252 RID: 594 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000252")] [Address(RVA = "0x54B000", Offset = "0x549E00", VA = "0x18054B000")] private static BinaryExpression GetUserDefinedBinaryOperator(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull) { return null; } // Token: 0x06000253 RID: 595 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000253")] [Address(RVA = "0x5498C0", Offset = "0x5486C0", VA = "0x1805498C0")] private static BinaryExpression GetMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, bool liftToNull) { return null; } // Token: 0x06000254 RID: 596 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000254")] [Address(RVA = "0x549650", Offset = "0x548450", VA = "0x180549650")] private static BinaryExpression GetMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression conversion, bool liftToNull) { return null; } // Token: 0x06000255 RID: 597 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000255")] [Address(RVA = "0x54AD90", Offset = "0x549B90", VA = "0x18054AD90")] private static BinaryExpression GetUserDefinedBinaryOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull) { return null; } // Token: 0x06000256 RID: 598 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000256")] [Address(RVA = "0x54AB20", Offset = "0x549920", VA = "0x18054AB20")] private static BinaryExpression GetUserDefinedAssignOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, LambdaExpression conversion, bool liftToNull) { return null; } // Token: 0x06000257 RID: 599 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000257")] [Address(RVA = "0x54B330", Offset = "0x54A130", VA = "0x18054B330")] private static MethodInfo GetUserDefinedBinaryOperator(ExpressionType binaryType, Type leftType, Type rightType, string name) { return null; } // Token: 0x06000258 RID: 600 RVA: 0x00002898 File Offset: 0x00000A98 [Token(Token = "0x6000258")] [Address(RVA = "0x54C680", Offset = "0x54B480", VA = "0x18054C680")] private static bool IsLiftingConditionalLogicalOperator(Type left, Type right, MethodInfo method, ExpressionType binaryType) { return default(bool); } // Token: 0x06000259 RID: 601 RVA: 0x000028B0 File Offset: 0x00000AB0 [Token(Token = "0x6000259")] [Address(RVA = "0x552950", Offset = "0x551750", VA = "0x180552950")] internal static bool ParameterIsAssignable(ParameterInfo pi, Type argType) { return default(bool); } // Token: 0x0600025A RID: 602 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x600025A")] [Address(RVA = "0x556ED0", Offset = "0x555CD0", VA = "0x180556ED0")] private static void ValidateParamswithOperandsOrThrow(Type paramType, Type operandType, ExpressionType exprType, string name) { } // Token: 0x0600025B RID: 603 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x600025B")] [Address(RVA = "0x556DA0", Offset = "0x555BA0", VA = "0x180556DA0")] private static void ValidateOperator(MethodInfo method) { } // Token: 0x0600025C RID: 604 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x600025C")] [Address(RVA = "0x556A50", Offset = "0x555850", VA = "0x180556A50")] private static void ValidateMethodInfo(MethodInfo method, string paramName) { } // Token: 0x0600025D RID: 605 RVA: 0x000028C8 File Offset: 0x00000AC8 [Token(Token = "0x600025D")] [Address(RVA = "0x54C710", Offset = "0x54B510", VA = "0x18054C710")] private static bool IsNullComparison(Expression left, Expression right) { return default(bool); } // Token: 0x0600025E RID: 606 RVA: 0x000028E0 File Offset: 0x00000AE0 [Token(Token = "0x600025E")] [Address(RVA = "0x54C810", Offset = "0x54B610", VA = "0x18054C810")] private static bool IsNullConstant(Expression e) { return default(bool); } // Token: 0x0600025F RID: 607 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x600025F")] [Address(RVA = "0x5575E0", Offset = "0x5563E0", VA = "0x1805575E0")] private static void ValidateUserDefinedConditionalLogicOperator(ExpressionType nodeType, Type left, Type right, MethodInfo method) { } // Token: 0x06000260 RID: 608 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x6000260")] [Address(RVA = "0x558080", Offset = "0x556E80", VA = "0x180558080")] private static void VerifyOpTrueFalse(ExpressionType nodeType, Type left, MethodInfo opTrue, string paramName) { } // Token: 0x06000261 RID: 609 RVA: 0x000028F8 File Offset: 0x00000AF8 [Token(Token = "0x6000261")] [Address(RVA = "0x54CAD0", Offset = "0x54B8D0", VA = "0x18054CAD0")] private static bool IsValidLiftedConditionalLogicalOperator(Type left, Type right, ParameterInfo[] pms) { return default(bool); } /// Creates a , given the left operand, right operand and implementing method, by calling the appropriate factory method. /// The that specifies the type of binary operation. /// An that represents the left operand. /// An that represents the right operand. /// /// to set to ; to set to . /// A that specifies the implementing method. /// The that results from calling the appropriate factory method. /// /// does not correspond to a binary expression node. /// /// or is . // Token: 0x06000262 RID: 610 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000262")] [Address(RVA = "0x54E6F0", Offset = "0x54D4F0", VA = "0x18054E6F0")] public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a , given the left operand, right operand, implementing method and type conversion function, by calling the appropriate factory method. /// The that specifies the type of binary operation. /// An that represents the left operand. /// An that represents the right operand. /// /// to set to ; to set to . /// A that specifies the implementing method. /// A that represents a type conversion function. This parameter is used only if is or compound assignment.. /// The that results from calling the appropriate factory method. /// /// does not correspond to a binary expression node. /// /// or is . // Token: 0x06000263 RID: 611 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000263")] [Address(RVA = "0x54D5A0", Offset = "0x54C3A0", VA = "0x18054D5A0")] public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an equality comparison. The implementing method can be specified. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the equality operator is not defined for .Type and .Type. // Token: 0x06000264 RID: 612 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000264")] [Address(RVA = "0x548280", Offset = "0x547080", VA = "0x180548280")] public static BinaryExpression Equal(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a that represents a reference equality comparison. /// An to set the property equal to. /// An to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x06000265 RID: 613 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000265")] [Address(RVA = "0x553780", Offset = "0x552580", VA = "0x180553780")] public static BinaryExpression ReferenceEqual(Expression left, Expression right) { return null; } /// Creates a that represents an inequality comparison. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the inequality operator is not defined for .Type and .Type. // Token: 0x06000266 RID: 614 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000266")] [Address(RVA = "0x551C10", Offset = "0x550A10", VA = "0x180551C10")] public static BinaryExpression NotEqual(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a that represents a reference inequality comparison. /// An to set the property equal to. /// An to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x06000267 RID: 615 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000267")] [Address(RVA = "0x5538C0", Offset = "0x5526C0", VA = "0x1805538C0")] public static BinaryExpression ReferenceNotEqual(Expression left, Expression right) { return null; } // Token: 0x06000268 RID: 616 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000268")] [Address(RVA = "0x548FF0", Offset = "0x547DF0", VA = "0x180548FF0")] private static BinaryExpression GetEqualityComparisonOperator(ExpressionType binaryType, string opName, Expression left, Expression right, bool liftToNull) { return null; } /// Creates a that represents a "greater than" numeric comparison. The implementing method can be specified. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the "greater than" operator is not defined for .Type and .Type. // Token: 0x06000269 RID: 617 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000269")] [Address(RVA = "0x54BF30", Offset = "0x54AD30", VA = "0x18054BF30")] public static BinaryExpression GreaterThan(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a that represents a "less than" numeric comparison. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the "less than" operator is not defined for .Type and .Type. // Token: 0x0600026A RID: 618 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026A")] [Address(RVA = "0x54D490", Offset = "0x54C290", VA = "0x18054D490")] public static BinaryExpression LessThan(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a that represents a "greater than or equal" numeric comparison. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the "greater than or equal" operator is not defined for .Type and .Type. // Token: 0x0600026B RID: 619 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026B")] [Address(RVA = "0x54BE20", Offset = "0x54AC20", VA = "0x18054BE20")] public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } /// Creates a that represents a "less than or equal" numeric comparison. /// An to set the property equal to. /// An to set the property equal to. /// /// to set to ; to set to . /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the "less than or equal" operator is not defined for .Type and .Type. // Token: 0x0600026C RID: 620 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026C")] [Address(RVA = "0x54D380", Offset = "0x54C180", VA = "0x18054D380")] public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method) { return null; } // Token: 0x0600026D RID: 621 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026D")] [Address(RVA = "0x548E00", Offset = "0x547C00", VA = "0x180548E00")] private static BinaryExpression GetComparisonOperator(ExpressionType binaryType, string opName, Expression left, Expression right, bool liftToNull) { return null; } /// Creates a that represents a conditional operation that evaluates the second operand only if the first operand is resolved to true. The implementing method can be specified. /// A to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the bitwise operator is not defined for .Type and .Type.-or- /// is and .Type and .Type are not the same Boolean type. // Token: 0x0600026E RID: 622 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026E")] [Address(RVA = "0x542470", Offset = "0x541270", VA = "0x180542470")] public static BinaryExpression AndAlso(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a conditional operation that evaluates the second operand only if the first operand evaluates to . /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the bitwise operator is not defined for .Type and .Type.-or- /// is and .Type and .Type are not the same Boolean type. // Token: 0x0600026F RID: 623 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600026F")] [Address(RVA = "0x552270", Offset = "0x551070", VA = "0x180552270")] public static BinaryExpression OrElse(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a coalescing operation, given a conversion function. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , and properties set to the specified values. /// /// or is . /// /// .Type and .Type are not convertible to each other.-or- /// is not and .Type is a delegate type that does not take exactly one argument. /// The property of does not represent a reference type or a nullable value type.-or-The property of represents a type that is not assignable to the parameter type of the delegate type .Type.-or-The property of is not equal to the return type of the delegate type .Type. // Token: 0x06000270 RID: 624 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000270")] [Address(RVA = "0x546590", Offset = "0x545390", VA = "0x180546590")] public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion) { return null; } // Token: 0x06000271 RID: 625 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000271")] [Address(RVA = "0x555800", Offset = "0x554600", VA = "0x180555800")] private static Type ValidateCoalesceArgTypes(Type left, Type right) { return null; } /// Creates a that represents an arithmetic addition operation that does not have overflow checking. The implementing method can be specified. /// A to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the addition operator is not defined for .Type and .Type. // Token: 0x06000272 RID: 626 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000272")] [Address(RVA = "0x542270", Offset = "0x541070", VA = "0x180542270")] public static BinaryExpression Add(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents an addition assignment operation that does not have overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000273 RID: 627 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000273")] [Address(RVA = "0x541E00", Offset = "0x540C00", VA = "0x180541E00")] public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } // Token: 0x06000274 RID: 628 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x6000274")] [Address(RVA = "0x556B30", Offset = "0x555930", VA = "0x180556B30")] private static void ValidateOpAssignConversionLambda(LambdaExpression conversion, Expression left, MethodInfo method, ExpressionType nodeType) { } /// Creates a that represents an addition assignment operation that has overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000275 RID: 629 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000275")] [Address(RVA = "0x541BA0", Offset = "0x5409A0", VA = "0x180541BA0")] public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an arithmetic addition operation that has overflow checking. The implementing method can be specified. /// A to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the addition operator is not defined for .Type and .Type. // Token: 0x06000276 RID: 630 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000276")] [Address(RVA = "0x542060", Offset = "0x540E60", VA = "0x180542060")] public static BinaryExpression AddChecked(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents an arithmetic subtraction operation that does not have overflow checking. /// A to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the subtraction operator is not defined for .Type and .Type. // Token: 0x06000277 RID: 631 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000277")] [Address(RVA = "0x554900", Offset = "0x553700", VA = "0x180554900")] public static BinaryExpression Subtract(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a subtraction assignment operation that does not have overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000278 RID: 632 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000278")] [Address(RVA = "0x554490", Offset = "0x553290", VA = "0x180554490")] public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a subtraction assignment operation that has overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000279 RID: 633 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000279")] [Address(RVA = "0x554230", Offset = "0x553030", VA = "0x180554230")] public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an arithmetic subtraction operation that has overflow checking. /// A to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the subtraction operator is not defined for .Type and .Type. // Token: 0x0600027A RID: 634 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027A")] [Address(RVA = "0x5546F0", Offset = "0x5534F0", VA = "0x1805546F0")] public static BinaryExpression SubtractChecked(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents an arithmetic division operation. The implementing method can be specified. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the division operator is not defined for .Type and .Type. // Token: 0x0600027B RID: 635 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027B")] [Address(RVA = "0x547FB0", Offset = "0x546DB0", VA = "0x180547FB0")] public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a division assignment operation that does not have overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x0600027C RID: 636 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027C")] [Address(RVA = "0x547D50", Offset = "0x546B50", VA = "0x180547D50")] public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an arithmetic remainder operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the modulus operator is not defined for .Type and .Type. // Token: 0x0600027D RID: 637 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027D")] [Address(RVA = "0x550770", Offset = "0x54F570", VA = "0x180550770")] public static BinaryExpression Modulo(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a remainder assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x0600027E RID: 638 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027E")] [Address(RVA = "0x550510", Offset = "0x54F310", VA = "0x180550510")] public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an arithmetic multiplication operation that does not have overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the multiplication operator is not defined for .Type and .Type. // Token: 0x0600027F RID: 639 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600027F")] [Address(RVA = "0x551050", Offset = "0x54FE50", VA = "0x180551050")] public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a multiplication assignment operation that does not have overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000280 RID: 640 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000280")] [Address(RVA = "0x550BE0", Offset = "0x54F9E0", VA = "0x180550BE0")] public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a multiplication assignment operation that has overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000281 RID: 641 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000281")] [Address(RVA = "0x550980", Offset = "0x54F780", VA = "0x180550980")] public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents an arithmetic multiplication operation that has overflow checking. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the multiplication operator is not defined for .Type and .Type. // Token: 0x06000282 RID: 642 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000282")] [Address(RVA = "0x550E40", Offset = "0x54FC40", VA = "0x180550E40")] public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method) { return null; } // Token: 0x06000283 RID: 643 RVA: 0x00002910 File Offset: 0x00000B10 [Token(Token = "0x6000283")] [Address(RVA = "0x54C890", Offset = "0x54B690", VA = "0x18054C890")] private static bool IsSimpleShift(Type left, Type right) { return default(bool); } // Token: 0x06000284 RID: 644 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000284")] [Address(RVA = "0x54A9F0", Offset = "0x5497F0", VA = "0x18054A9F0")] private static Type GetResultTypeOfShift(Type left, Type right) { return null; } /// Creates a that represents a bitwise left-shift operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the left-shift operator is not defined for .Type and .Type. // Token: 0x06000285 RID: 645 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000285")] [Address(RVA = "0x54D150", Offset = "0x54BF50", VA = "0x18054D150")] public static BinaryExpression LeftShift(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a bitwise left-shift assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000286 RID: 646 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000286")] [Address(RVA = "0x54CEC0", Offset = "0x54BCC0", VA = "0x18054CEC0")] public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a bitwise right-shift operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the right-shift operator is not defined for .Type and .Type. // Token: 0x06000287 RID: 647 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000287")] [Address(RVA = "0x554000", Offset = "0x552E00", VA = "0x180554000")] public static BinaryExpression RightShift(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a bitwise right-shift assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000288 RID: 648 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000288")] [Address(RVA = "0x553D70", Offset = "0x552B70", VA = "0x180553D70")] public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a bitwise operation. The implementing method can be specified. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the bitwise operator is not defined for .Type and .Type. // Token: 0x06000289 RID: 649 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000289")] [Address(RVA = "0x542B70", Offset = "0x541970", VA = "0x180542B70")] public static BinaryExpression And(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a bitwise AND assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x0600028A RID: 650 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028A")] [Address(RVA = "0x542910", Offset = "0x541710", VA = "0x180542910")] public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a bitwise operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the bitwise operator is not defined for .Type and .Type. // Token: 0x0600028B RID: 651 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028B")] [Address(RVA = "0x552740", Offset = "0x551540", VA = "0x180552740")] public static BinaryExpression Or(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a bitwise OR assignment operation. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x0600028C RID: 652 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028C")] [Address(RVA = "0x552010", Offset = "0x550E10", VA = "0x180552010")] public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents a bitwise operation, using op_ExclusiveOr for user-defined types. The implementing method can be specified. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the operator is not defined for .Type and .Type. // Token: 0x0600028D RID: 653 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028D")] [Address(RVA = "0x5485F0", Offset = "0x5473F0", VA = "0x1805485F0")] public static BinaryExpression ExclusiveOr(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x0600028E RID: 654 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028E")] [Address(RVA = "0x548390", Offset = "0x547190", VA = "0x180548390")] public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents raising a number to a power. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly two arguments. /// /// is and the exponentiation operator is not defined for .Type and .Type.-or- /// is and .Type and/or .Type are not . // Token: 0x0600028F RID: 655 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600028F")] [Address(RVA = "0x552D40", Offset = "0x551B40", VA = "0x180552D40")] public static BinaryExpression Power(Expression left, Expression right, MethodInfo method) { return null; } /// Creates a that represents raising an expression to a power and assigning the result back to the expression. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , , and properties set to the specified values. // Token: 0x06000290 RID: 656 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000290")] [Address(RVA = "0x552BB0", Offset = "0x5519B0", VA = "0x180552BB0")] public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) { return null; } /// Creates a that represents applying an array index operator to an array of rank one. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// or is . /// /// .Type does not represent an array type.-or- /// .Type represents an array type whose rank is not 1.-or- /// .Type does not represent the type. // Token: 0x06000291 RID: 657 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000291")] [Address(RVA = "0x5431D0", Offset = "0x541FD0", VA = "0x1805431D0")] public static BinaryExpression ArrayIndex(Expression array, Expression index) { return null; } /// Creates a that contains the given expressions, has no variables and has specific result type. /// The result type of the block. /// The expressions in the block. /// The created . // Token: 0x06000292 RID: 658 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000292")] [Address(RVA = "0x544120", Offset = "0x542F20", VA = "0x180544120")] public static BlockExpression Block(Type type, params Expression[] expressions) { return null; } /// Creates a that contains the given expressions, has no variables and has specific result type. /// The result type of the block. /// The expressions in the block. /// The created . // Token: 0x06000293 RID: 659 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000293")] [Address(RVA = "0x543E10", Offset = "0x542C10", VA = "0x180543E10")] public static BlockExpression Block(Type type, IEnumerable expressions) { return null; } /// Creates a that contains the given variables and expressions. /// The result type of the block. /// The variables in the block. /// The expressions in the block. /// The created . // Token: 0x06000294 RID: 660 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000294")] [Address(RVA = "0x543D90", Offset = "0x542B90", VA = "0x180543D90")] public static BlockExpression Block(Type type, IEnumerable variables, params Expression[] expressions) { return null; } /// Creates a that contains the given variables and expressions. /// The variables in the block. /// The expressions in the block. /// The created . // Token: 0x06000295 RID: 661 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000295")] [Address(RVA = "0x543C00", Offset = "0x542A00", VA = "0x180543C00")] public static BlockExpression Block(IEnumerable variables, IEnumerable expressions) { return null; } /// Creates a that contains the given variables and expressions. /// The result type of the block. /// The variables in the block. /// The expressions in the block. /// The created . // Token: 0x06000296 RID: 662 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000296")] [Address(RVA = "0x543EB0", Offset = "0x542CB0", VA = "0x180543EB0")] public static BlockExpression Block(Type type, IEnumerable variables, IEnumerable expressions) { return null; } // Token: 0x06000297 RID: 663 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000297")] [Address(RVA = "0x5437A0", Offset = "0x5425A0", VA = "0x1805437A0")] private static BlockExpression BlockCore(Type type, ReadOnlyCollection variables, ReadOnlyCollection expressions) { return null; } // Token: 0x06000298 RID: 664 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x6000298")] [Address(RVA = "0x557D80", Offset = "0x556B80", VA = "0x180557D80")] internal static void ValidateVariables(ReadOnlyCollection varList, string collectionName) { } // Token: 0x06000299 RID: 665 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000299")] [Address(RVA = "0x54A590", Offset = "0x549390", VA = "0x18054A590")] private static BlockExpression GetOptimizedBlockExpression(IReadOnlyList expressions) { return null; } /// Creates a representing a catch statement with the specified elements. /// The of this will handle. /// A representing a reference to the object caught by this handler. /// The body of the catch statement. /// The body of the filter. /// The created . // Token: 0x0600029A RID: 666 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029A")] [Address(RVA = "0x54E790", Offset = "0x54D590", VA = "0x18054E790")] public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter) { return null; } /// Creates a that represents a conditional statement. /// An to set the property equal to. /// An to set the property equal to. /// An to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or or is . /// /// .Type is not .-or- /// .Type is not equal to .Type. // Token: 0x0600029B RID: 667 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029B")] [Address(RVA = "0x546B80", Offset = "0x545980", VA = "0x180546B80")] public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse) { return null; } /// Creates a that represents a conditional statement. /// An to set the property equal to. /// An to set the property equal to. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. // Token: 0x0600029C RID: 668 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029C")] [Address(RVA = "0x546D40", Offset = "0x545B40", VA = "0x180546D40")] public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse, Type type) { return null; } /// Creates a that has the property set to the specified value. /// An to set the property equal to. /// A that has the property equal to and the property set to the specified value. // Token: 0x0600029D RID: 669 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029D")] [Address(RVA = "0x546F90", Offset = "0x545D90", VA = "0x180546F90")] public static ConstantExpression Constant(object value) { return null; } /// Creates a that has the and properties set to the specified values. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is . /// /// is not and is not assignable from the dynamic type of . // Token: 0x0600029E RID: 670 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029E")] [Address(RVA = "0x547020", Offset = "0x545E20", VA = "0x180547020")] public static ConstantExpression Constant(object value, Type type) { return null; } /// Creates an empty expression that has type. /// A that has the property equal to and the property set to . // Token: 0x0600029F RID: 671 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600029F")] [Address(RVA = "0x5481C0", Offset = "0x546FC0", VA = "0x1805481C0")] public static DefaultExpression Empty() { return null; } /// Constructs a new instance of . // Token: 0x060002A0 RID: 672 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002A0")] [Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")] protected Expression() { } /// Gets the node type of this . /// One of the values. // Token: 0x17000056 RID: 86 // (get) Token: 0x060002A1 RID: 673 RVA: 0x00002928 File Offset: 0x00000B28 [Token(Token = "0x17000056")] public virtual ExpressionType NodeType { [Token(Token = "0x60002A1")] [Address(RVA = "0x558400", Offset = "0x557200", VA = "0x180558400", Slot = "4")] get { return ExpressionType.Add; } } /// Gets the static type of the expression that this represents. /// The that represents the static type of the expression. // Token: 0x17000057 RID: 87 // (get) Token: 0x060002A2 RID: 674 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x17000057")] public virtual Type Type { [Token(Token = "0x60002A2")] [Address(RVA = "0x5584E0", Offset = "0x5572E0", VA = "0x1805584E0", Slot = "5")] get { return null; } } /// Indicates that the node can be reduced to a simpler node. If this returns true, Reduce() can be called to produce the reduced form. /// True if the node can be reduced, otherwise false. // Token: 0x17000058 RID: 88 // (get) Token: 0x060002A3 RID: 675 RVA: 0x00002940 File Offset: 0x00000B40 [Token(Token = "0x17000058")] public virtual bool CanReduce { [Token(Token = "0x60002A3")] [Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "6")] get { return default(bool); } } /// Reduces this node to a simpler expression. If CanReduce returns true, this should return a valid expression. This method can return another node which itself must be reduced. /// The reduced expression. // Token: 0x060002A4 RID: 676 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002A4")] [Address(RVA = "0x553720", Offset = "0x552520", VA = "0x180553720", Slot = "7")] public virtual Expression Reduce() { return null; } /// Reduces the node and then calls the visitor delegate on the reduced expression. The method throws an exception if the node is not reducible. /// An instance of . /// The expression being visited, or an expression which should replace it in the tree. // Token: 0x060002A5 RID: 677 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002A5")] [Address(RVA = "0x558220", Offset = "0x557020", VA = "0x180558220", Slot = "8")] protected internal virtual Expression VisitChildren(ExpressionVisitor visitor) { return null; } /// Dispatches to the specific visit method for this node type. For example, calls the . /// The visitor to visit this node with. /// The result of visiting this node. // Token: 0x060002A6 RID: 678 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002A6")] [Address(RVA = "0x541B70", Offset = "0x540970", VA = "0x180541B70", Slot = "9")] protected internal virtual Expression Accept(ExpressionVisitor visitor) { return null; } /// Reduces this node to a simpler expression. If CanReduce returns true, this should return a valid expression. This method can return another node which itself must be reduced. /// The reduced expression. // Token: 0x060002A7 RID: 679 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002A7")] [Address(RVA = "0x553630", Offset = "0x552430", VA = "0x180553630")] public Expression ReduceAndCheck() { return null; } /// Returns a textual representation of the . /// A textual representation of the . // Token: 0x060002A8 RID: 680 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002A8")] [Address(RVA = "0x554C60", Offset = "0x553A60", VA = "0x180554C60", Slot = "3")] public override string ToString() { return null; } // Token: 0x060002A9 RID: 681 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002A9")] [Address(RVA = "0x553A00", Offset = "0x552800", VA = "0x180553A00")] private static void RequiresCanRead(IReadOnlyList items, string paramName) { } // Token: 0x060002AA RID: 682 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002AA")] [Address(RVA = "0x553B10", Offset = "0x552910", VA = "0x180553B10")] private static void RequiresCanWrite(Expression expression, string paramName) { } /// Creates a representing a "go to" statement. The value passed to the label upon jumping can be specified. /// The that the will jump to. /// The value that will be passed to the associated label upon jumping. /// A with equal to Goto, the property set to , and to be passed to the target label upon jumping. // Token: 0x060002AB RID: 683 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002AB")] [Address(RVA = "0x54BCE0", Offset = "0x54AAE0", VA = "0x18054BCE0")] public static GotoExpression Goto(LabelTarget target, Expression value) { return null; } /// Creates a representing a jump of the specified . The value passed to the label upon jumping can also be specified. /// The of the . /// The that the will jump to. /// The value that will be passed to the associated label upon jumping. /// An to set the property equal to. /// A with equal to , the property set to , the property set to , and to be passed to the target label upon jumping. // Token: 0x060002AC RID: 684 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002AC")] [Address(RVA = "0x54E9F0", Offset = "0x54D7F0", VA = "0x18054E9F0")] public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type) { return null; } // Token: 0x060002AD RID: 685 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002AD")] [Address(RVA = "0x555A90", Offset = "0x554890", VA = "0x180555A90")] private static void ValidateGoto(LabelTarget target, ref Expression value, string targetParameter, string valueParameter, Type type) { } // Token: 0x060002AE RID: 686 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002AE")] [Address(RVA = "0x555960", Offset = "0x554760", VA = "0x180555960")] private static void ValidateGotoType(Type expectedType, ref Expression value, string paramName) { } /// Creates an that represents accessing an indexed property in an object. /// The object to which the property belongs. It should be null if the property is ( in Visual Basic). /// An representing the property to index. /// An IEnumerable<Expression> (IEnumerable (Of Expression) in Visual Basic) that contains the arguments that will be used to index the property. /// The created . // Token: 0x060002AF RID: 687 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002AF")] [Address(RVA = "0x54EB70", Offset = "0x54D970", VA = "0x18054EB70")] public static IndexExpression MakeIndex(Expression instance, PropertyInfo indexer, IEnumerable arguments) { return null; } /// Creates an to access an array. /// An expression representing the array to index. /// An array that contains expressions used to index the array. /// The created . // Token: 0x060002B0 RID: 688 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B0")] [Address(RVA = "0x542E40", Offset = "0x541C40", VA = "0x180542E40")] public static IndexExpression ArrayAccess(Expression array, params Expression[] indexes) { return null; } /// Creates an to access a multidimensional array. /// An expression that represents the multidimensional array. /// An containing expressions used to index the array. /// The created . // Token: 0x060002B1 RID: 689 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B1")] [Address(RVA = "0x542EB0", Offset = "0x541CB0", VA = "0x180542EB0")] public static IndexExpression ArrayAccess(Expression array, IEnumerable indexes) { return null; } /// Creates an representing the access to an indexed property. /// The object to which the property belongs. If the property is static/shared, it must be null. /// The that represents the property to index. /// An of objects that are used to index the property. /// The created . // Token: 0x060002B2 RID: 690 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B2")] [Address(RVA = "0x552F70", Offset = "0x551D70", VA = "0x180552F70")] public static IndexExpression Property(Expression instance, PropertyInfo indexer, IEnumerable arguments) { return null; } // Token: 0x060002B3 RID: 691 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B3")] [Address(RVA = "0x54EAC0", Offset = "0x54D8C0", VA = "0x18054EAC0")] private static IndexExpression MakeIndexProperty(Expression instance, PropertyInfo indexer, string paramName, ReadOnlyCollection argList) { return null; } // Token: 0x060002B4 RID: 692 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002B4")] [Address(RVA = "0x555D20", Offset = "0x554B20", VA = "0x180555D20")] private static void ValidateIndexedProperty(Expression instance, PropertyInfo indexer, string paramName, ref ReadOnlyCollection argList) { } // Token: 0x060002B5 RID: 693 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002B5")] [Address(RVA = "0x555540", Offset = "0x554340", VA = "0x180555540")] private static void ValidateAccessor(Expression instance, MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection arguments, string paramName) { } // Token: 0x060002B6 RID: 694 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002B6")] [Address(RVA = "0x555170", Offset = "0x553F70", VA = "0x180555170")] private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection arguments, string paramName) { } // Token: 0x060002B7 RID: 695 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B7")] [Address(RVA = "0x54C1A0", Offset = "0x54AFA0", VA = "0x18054C1A0")] internal static InvocationExpression Invoke(Expression expression, Expression arg0) { return null; } // Token: 0x060002B8 RID: 696 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B8")] [Address(RVA = "0x549460", Offset = "0x548260", VA = "0x180549460")] internal static MethodInfo GetInvokeMethod(Expression expression) { return null; } /// Creates a representing a label with the given default value. /// The which this will be associated with. /// The value of this when the label is reached through regular control flow. /// A with the given default value. // Token: 0x060002B9 RID: 697 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002B9")] [Address(RVA = "0x54CB70", Offset = "0x54B970", VA = "0x18054CB70")] public static LabelExpression Label(LabelTarget target, Expression defaultValue) { return null; } /// Creates a representing a label with the given type and name. /// The type of value that is passed when jumping to the label. /// The name of the label. /// The new . // Token: 0x060002BA RID: 698 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BA")] [Address(RVA = "0x54CC20", Offset = "0x54BA20", VA = "0x18054CC20")] public static LabelTarget Label(Type type, string name) { return null; } // Token: 0x060002BB RID: 699 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BB")] [Address(RVA = "0x547730", Offset = "0x546530", VA = "0x180547730")] internal static LambdaExpression CreateLambda(Type delegateType, Expression body, string name, bool tailCall, ReadOnlyCollection parameters) { return null; } /// Creates an where the delegate type is known at compile time. /// An to set the property equal to. /// An array of objects to use to populate the collection. /// A delegate type. /// An that has the property equal to and the and properties set to the specified values. /// /// is .-or-One or more elements in are . /// /// is not a delegate type.-or- /// .Type represents a type that is not assignable to the return type of .-or- /// does not contain the same number of elements as the list of parameters for .-or-The property of an element of is not assignable from the type of the corresponding parameter type of . // Token: 0x060002BC RID: 700 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BC")] [Address(RVA = "0x2174770", Offset = "0x2173570", VA = "0x182174770")] public static Expression Lambda(Expression body, params ParameterExpression[] parameters) { return null; } /// Creates an where the delegate type is known at compile time. /// An to set the property equal to. /// A that indicates if tail call optimization will be applied when compiling the created expression. /// An that contains objects to use to populate the collection. /// The delegate type. /// An that has the property equal to and the and properties set to the specified values. // Token: 0x060002BD RID: 701 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BD")] [Address(RVA = "0x21746E0", Offset = "0x21734E0", VA = "0x1821746E0")] public static Expression Lambda(Expression body, bool tailCall, IEnumerable parameters) { return null; } /// Creates an where the delegate type is known at compile time. /// An to set the property equal to. /// The name of the lambda. Used for generating debugging info. /// A that indicates if tail call optimization will be applied when compiling the created expression. /// An that contains objects to use to populate the collection. /// The delegate type. /// An that has the property equal to and the and properties set to the specified values. // Token: 0x060002BE RID: 702 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BE")] [Address(RVA = "0x21747F0", Offset = "0x21735F0", VA = "0x1821747F0")] public static Expression Lambda(Expression body, string name, bool tailCall, IEnumerable parameters) { return null; } /// Creates a by first constructing a delegate type. It can be used when the delegate type is not known at compile time. /// A that represents a delegate signature for the lambda. /// An to set the property equal to. /// An array of objects to use to populate the collection. /// An object that represents a lambda expression which has the property equal to and the and properties set to the specified values. /// /// or is .-or-One or more elements in are . /// /// does not represent a delegate type.-or- /// .Type represents a type that is not assignable to the return type of the delegate type represented by .-or- /// does not contain the same number of elements as the list of parameters for the delegate type represented by .-or-The property of an element of is not assignable from the type of the corresponding parameter type of the delegate type represented by . // Token: 0x060002BF RID: 703 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002BF")] [Address(RVA = "0x54CD00", Offset = "0x54BB00", VA = "0x18054CD00")] public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters) { return null; } /// Creates a LambdaExpression by first constructing a delegate type. /// A representing the delegate signature for the lambda. /// An to set the property equal to. /// The name for the lambda. Used for emitting debug information. /// A that indicates if tail call optimization will be applied when compiling the created expression. /// An that contains objects to use to populate the collection. /// A that has the property equal to Lambda and the and properties set to the specified values. // Token: 0x060002C0 RID: 704 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C0")] [Address(RVA = "0x54CDF0", Offset = "0x54BBF0", VA = "0x18054CDF0")] public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable parameters) { return null; } // Token: 0x060002C1 RID: 705 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002C1")] [Address(RVA = "0x5563A0", Offset = "0x5551A0", VA = "0x1805563A0")] private static void ValidateLambdaArgs(Type delegateType, ref Expression body, ReadOnlyCollection parameters, string paramName) { } /// Creates a that represents accessing a field. /// An to set the property equal to. For ( in Visual Basic), must be . /// The to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is .-or-The field represented by is not ( in Visual Basic) and is . /// /// .Type is not assignable to the declaring type of the field represented by . // Token: 0x060002C2 RID: 706 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C2")] [Address(RVA = "0x548800", Offset = "0x547600", VA = "0x180548800")] public static MemberExpression Field(Expression expression, FieldInfo field) { return null; } /// Creates a that represents accessing a field given the name of the field. /// An whose contains a field named . This can be null for static fields. /// The name of a field to be accessed. /// A that has the property equal to , the property set to , and the property set to the that represents the field denoted by . /// /// or is . /// No field named is defined in .Type or its base types. // Token: 0x060002C3 RID: 707 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C3")] [Address(RVA = "0x5489D0", Offset = "0x5477D0", VA = "0x1805489D0")] public static MemberExpression Field(Expression expression, string fieldName) { return null; } /// Creates a that represents accessing a property. /// An whose contains a property named . This can be for static properties. /// The name of a property to be accessed. /// A that has the property equal to , the property set to , and the property set to the that represents the property denoted by . /// /// or is . /// No property named is defined in .Type or its base types. // Token: 0x060002C4 RID: 708 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C4")] [Address(RVA = "0x553080", Offset = "0x551E80", VA = "0x180553080")] public static MemberExpression Property(Expression expression, string propertyName) { return null; } /// Creates a that represents accessing a property. /// An to set the property equal to. This can be null for static properties. /// The to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is .-or-The property that represents is not ( in Visual Basic) and is . /// /// .Type is not assignable to the declaring type of the property that represents. // Token: 0x060002C5 RID: 709 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C5")] [Address(RVA = "0x553220", Offset = "0x552020", VA = "0x180553220")] public static MemberExpression Property(Expression expression, PropertyInfo property) { return null; } /// Creates a that represents accessing either a field or a property. /// An that represents the object that the member belongs to. This can be null for static members. /// The that describes the field or property to be accessed. /// The that results from calling the appropriate factory method. /// /// is . /// /// does not represent a field or property. // Token: 0x060002C6 RID: 710 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C6")] [Address(RVA = "0x54ED00", Offset = "0x54DB00", VA = "0x18054ED00")] public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member) { return null; } // Token: 0x060002C7 RID: 711 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C7")] [Address(RVA = "0x544260", Offset = "0x543060", VA = "0x180544260")] internal static MethodCallExpression Call(MethodInfo method) { return null; } /// Creates a that represents a call to a ( in Visual Basic) method that takes one argument. /// A to set the property equal to. /// The that represents the first argument. /// A that has the property equal to and the and properties set to the specified values. /// /// is null. // Token: 0x060002C8 RID: 712 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C8")] [Address(RVA = "0x544360", Offset = "0x543160", VA = "0x180544360")] public static MethodCallExpression Call(MethodInfo method, Expression arg0) { return null; } /// Creates a that represents a call to a static method that takes two arguments. /// A to set the property equal to. /// The that represents the first argument. /// The that represents the second argument. /// A that has the property equal to and the and properties set to the specified values. /// /// is null. // Token: 0x060002C9 RID: 713 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002C9")] [Address(RVA = "0x5449A0", Offset = "0x5437A0", VA = "0x1805449A0")] public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1) { return null; } /// Creates a that represents a call to a static method that takes three arguments. /// A to set the property equal to. /// The that represents the first argument. /// The that represents the second argument. /// The that represents the third argument. /// A that has the property equal to and the and properties set to the specified values. /// /// is null. // Token: 0x060002CA RID: 714 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CA")] [Address(RVA = "0x544530", Offset = "0x543330", VA = "0x180544530")] public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2) { return null; } /// Creates a that represents a call to a static method that takes four arguments. /// A to set the property equal to. /// The that represents the first argument. /// The that represents the second argument. /// The that represents the third argument. /// The that represents the fourth argument. /// A that has the property equal to and the and properties set to the specified values. /// /// is null. // Token: 0x060002CB RID: 715 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CB")] [Address(RVA = "0x546190", Offset = "0x544F90", VA = "0x180546190")] public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3) { return null; } /// Creates a that represents a call to a static method that takes five arguments. /// A to set the property equal to. /// The that represents the first argument. /// The that represents the second argument. /// The that represents the third argument. /// The that represents the fourth argument. /// The that represents the fifth argument. /// A that has the property equal to and the and properties set to the specified values. /// /// is null. // Token: 0x060002CC RID: 716 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CC")] [Address(RVA = "0x545CE0", Offset = "0x544AE0", VA = "0x180545CE0")] public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4) { return null; } /// Creates a that represents a call to a static (Shared in Visual Basic) method. /// The that represents the target method. /// A collection of that represents the call arguments. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x060002CD RID: 717 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CD")] [Address(RVA = "0x5451E0", Offset = "0x543FE0", VA = "0x1805451E0")] public static MethodCallExpression Call(MethodInfo method, IEnumerable arguments) { return null; } /// Creates a that represents a call to a method that takes no arguments. /// An that specifies the instance for an instance method call (pass for a ( in Visual Basic) method). /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is .-or- /// is and represents an instance method. /// /// .Type is not assignable to the declaring type of the method represented by . // Token: 0x060002CE RID: 718 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CE")] [Address(RVA = "0x544870", Offset = "0x543670", VA = "0x180544870")] public static MethodCallExpression Call(Expression instance, MethodInfo method) { return null; } /// Creates a that represents a call to a method that takes arguments. /// An that specifies the instance for an instance method call (pass for a ( in Visual Basic) method). /// A to set the property equal to. /// An array of objects to use to populate the collection. /// A that has the property equal to and the , , and properties set to the specified values. /// /// is .-or- /// is and represents an instance method.-or- /// is not and one or more of its elements is . /// /// .Type is not assignable to the declaring type of the method represented by .-or-The number of elements in does not equal the number of parameters for the method represented by .-or-One or more of the elements of is not assignable to the corresponding parameter for the method represented by . // Token: 0x060002CF RID: 719 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002CF")] [Address(RVA = "0x5455D0", Offset = "0x5443D0", VA = "0x1805455D0")] public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments) { return null; } // Token: 0x060002D0 RID: 720 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D0")] [Address(RVA = "0x545650", Offset = "0x544450", VA = "0x180545650")] internal static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0) { return null; } /// Creates a that represents a call to a method that takes two arguments. /// An that specifies the instance for an instance call. (pass null for a static (Shared in Visual Basic) method). /// The that represents the target method. /// The that represents the first argument. /// The that represents the second argument. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x060002D1 RID: 721 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D1")] [Address(RVA = "0x545A10", Offset = "0x544810", VA = "0x180545A10")] public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1) { return null; } /// Creates a that represents a call to a method that takes three arguments. /// An that specifies the instance for an instance call. (pass null for a static (Shared in Visual Basic) method). /// The that represents the target method. /// The that represents the first argument. /// The that represents the second argument. /// The that represents the third argument. /// A that has the property equal to and the and properties set to the specified values. // Token: 0x060002D2 RID: 722 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D2")] [Address(RVA = "0x545250", Offset = "0x544050", VA = "0x180545250")] public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1, Expression arg2) { return null; } /// Creates a that represents a call to a method by calling the appropriate factory method. /// An whose property value will be searched for a specific method. /// The name of the method. /// An array of objects that specify the type parameters of the generic method. This argument should be null when methodName specifies a non-generic method. /// An array of objects that represents the arguments to the method. /// A that has the property equal to , the property equal to , set to the that represents the specified instance method, and set to the specified arguments. /// /// or is . /// No method whose name is , whose type parameters match , and whose parameter types match is found in .Type or its base types.-or-More than one method whose name is , whose type parameters match , and whose parameter types match is found in .Type or its base types. // Token: 0x060002D3 RID: 723 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D3")] [Address(RVA = "0x545850", Offset = "0x544650", VA = "0x180545850")] public static MethodCallExpression Call(Expression instance, string methodName, Type[] typeArguments, params Expression[] arguments) { return null; } /// Creates a that represents a call to a method that takes arguments. /// An to set the property equal to (pass for a ( in Visual Basic) method). /// A to set the property equal to. /// An that contains objects to use to populate the collection. /// A that has the property equal to and the , , and properties set to the specified values. /// /// is .-or- /// is and represents an instance method. /// /// .Type is not assignable to the declaring type of the method represented by .-or-The number of elements in does not equal the number of parameters for the method represented by .-or-One or more of the elements of is not assignable to the corresponding parameter for the method represented by . // Token: 0x060002D4 RID: 724 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D4")] [Address(RVA = "0x544C20", Offset = "0x543A20", VA = "0x180544C20")] public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable arguments) { return null; } // Token: 0x060002D5 RID: 725 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D5")] [Address(RVA = "0x5569C0", Offset = "0x5557C0", VA = "0x1805569C0")] private static ParameterInfo[] ValidateMethodAndGetParameters(Expression instance, MethodInfo method) { return null; } // Token: 0x060002D6 RID: 726 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002D6")] [Address(RVA = "0x556F70", Offset = "0x555D70", VA = "0x180556F70")] private static void ValidateStaticOrInstanceMethod(Expression instance, MethodInfo method) { } // Token: 0x060002D7 RID: 727 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002D7")] [Address(RVA = "0x555780", Offset = "0x554580", VA = "0x180555780")] private static void ValidateCallInstanceType(Type instanceType, MethodInfo method) { } // Token: 0x060002D8 RID: 728 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002D8")] [Address(RVA = "0x555770", Offset = "0x554570", VA = "0x180555770")] private static void ValidateArgumentTypes(MethodBase method, ExpressionType nodeKind, ref ReadOnlyCollection arguments, string methodParamName) { } // Token: 0x060002D9 RID: 729 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002D9")] [Address(RVA = "0x54A9E0", Offset = "0x5497E0", VA = "0x18054A9E0")] private static ParameterInfo[] GetParametersForValidation(MethodBase method, ExpressionType nodeKind) { return null; } // Token: 0x060002DA RID: 730 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002DA")] [Address(RVA = "0x555760", Offset = "0x554560", VA = "0x180555760")] private static void ValidateArgumentCount(MethodBase method, ExpressionType nodeKind, int count, ParameterInfo[] pis) { } // Token: 0x060002DB RID: 731 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002DB")] [Address(RVA = "0x556AF0", Offset = "0x5558F0", VA = "0x180556AF0")] private static Expression ValidateOneArgument(MethodBase method, ExpressionType nodeKind, Expression arg, ParameterInfo pi, string methodParamName, string argumentParamName) { return null; } // Token: 0x060002DC RID: 732 RVA: 0x00002958 File Offset: 0x00000B58 [Token(Token = "0x60002DC")] [Address(RVA = "0x554CE0", Offset = "0x553AE0", VA = "0x180554CE0")] private static bool TryQuote(Type parameterType, ref Expression argument) { return default(bool); } // Token: 0x060002DD RID: 733 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002DD")] [Address(RVA = "0x548B80", Offset = "0x547980", VA = "0x180548B80")] private static MethodInfo FindMethod(Type type, string methodName, Type[] typeArgs, Expression[] args, BindingFlags flags) { return null; } // Token: 0x060002DE RID: 734 RVA: 0x00002970 File Offset: 0x00000B70 [Token(Token = "0x60002DE")] [Address(RVA = "0x54C310", Offset = "0x54B110", VA = "0x18054C310")] private static bool IsCompatible(MethodBase m, Expression[] arguments) { return default(bool); } // Token: 0x060002DF RID: 735 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002DF")] [Address(RVA = "0x542D80", Offset = "0x541B80", VA = "0x180542D80")] private static MethodInfo ApplyTypeArgs(MethodInfo m, Type[] typeArgs) { return null; } /// Creates a that represents creating a one-dimensional array and initializing it from a list of elements. /// A that represents the element type of the array. /// An array of objects to use to populate the collection. /// A that has the property equal to and the property set to the specified value. /// /// or is .-or-An element of is . /// The property of an element of represents a type that is not assignable to the type . // Token: 0x060002E0 RID: 736 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E0")] [Address(RVA = "0x5517F0", Offset = "0x5505F0", VA = "0x1805517F0")] public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers) { return null; } /// Creates a that represents creating a one-dimensional array and initializing it from a list of elements. /// A that represents the element type of the array. /// An that contains objects to use to populate the collection. /// A that has the property equal to and the property set to the specified value. /// /// or is .-or-An element of is . /// The property of an element of represents a type that is not assignable to the type that represents. // Token: 0x060002E1 RID: 737 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E1")] [Address(RVA = "0x551860", Offset = "0x550660", VA = "0x180551860")] public static NewArrayExpression NewArrayInit(Type type, IEnumerable initializers) { return null; } /// Creates a that represents creating an array that has a specified rank. /// A that represents the element type of the array. /// An that contains objects to use to populate the collection. /// A that has the property equal to and the property set to the specified value. /// /// or is .-or-An element of is . /// The property of an element of does not represent an integral type. // Token: 0x060002E2 RID: 738 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E2")] [Address(RVA = "0x551560", Offset = "0x550360", VA = "0x180551560")] public static NewArrayExpression NewArrayBounds(Type type, IEnumerable bounds) { return null; } /// Creates a node that can be used to identify a parameter or a variable in an expression tree. /// The type of the parameter or variable. /// A node with the specified name and type. // Token: 0x060002E3 RID: 739 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E3")] [Address(RVA = "0x552A70", Offset = "0x551870", VA = "0x180552A70")] public static ParameterExpression Parameter(Type type) { return null; } /// Creates a node that can be used to identify a parameter or a variable in an expression tree. /// The type of the parameter or variable. /// The name of the parameter or variable, used for debugging or printing purpose only. /// A that has the property equal to and the and properties set to the specified values. /// /// is . // Token: 0x060002E4 RID: 740 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E4")] [Address(RVA = "0x5529C0", Offset = "0x5517C0", VA = "0x1805529C0")] public static ParameterExpression Parameter(Type type, string name) { return null; } /// Creates a node that can be used to identify a parameter or a variable in an expression tree. /// The type of the parameter or variable. /// The name of the parameter or variable. This name is used for debugging or printing purpose only. /// A node with the specified name and type. // Token: 0x060002E5 RID: 741 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E5")] [Address(RVA = "0x558000", Offset = "0x556E00", VA = "0x180558000")] public static ParameterExpression Variable(Type type, string name) { return null; } // Token: 0x060002E6 RID: 742 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002E6")] [Address(RVA = "0x557EE0", Offset = "0x556CE0", VA = "0x180557EE0")] private static void Validate(Type type, bool allowByRef) { } /// Creates a representing a try block with a finally block and no catch statements. /// The body of the try block. /// The body of the finally block. /// The created . // Token: 0x060002E7 RID: 743 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E7")] [Address(RVA = "0x554C70", Offset = "0x553A70", VA = "0x180554C70")] public static TryExpression TryFinally(Expression body, Expression @finally) { return null; } /// Creates a representing a try block with the specified elements. /// The result type of the try expression. If null, bodh and all handlers must have identical type. /// The body of the try block. /// The body of the finally block. Pass null if the try block has no finally block associated with it. /// The body of the fault block. Pass null if the try block has no fault block associated with it. /// A collection of s representing the catch statements to be associated with the try block. /// The created . // Token: 0x060002E8 RID: 744 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002E8")] [Address(RVA = "0x54F100", Offset = "0x54DF00", VA = "0x18054F100")] public static TryExpression MakeTry(Type type, Expression body, Expression @finally, Expression fault, IEnumerable handlers) { return null; } // Token: 0x060002E9 RID: 745 RVA: 0x00002053 File Offset: 0x00000253 [Token(Token = "0x60002E9")] [Address(RVA = "0x557060", Offset = "0x555E60", VA = "0x180557060")] private static void ValidateTryAndCatchHaveSameType(Type type, Expression tryBody, ReadOnlyCollection handlers) { } /// Creates a , given an operand and implementing method, by calling the appropriate factory method. /// The that specifies the type of unary operation. /// An that represents the operand. /// The that specifies the type to be converted to (pass if not applicable). /// The that represents the implementing method. /// The that results from calling the appropriate factory method. /// /// is . /// /// does not correspond to a unary expression node. // Token: 0x060002EA RID: 746 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002EA")] [Address(RVA = "0x54F2E0", Offset = "0x54E0E0", VA = "0x18054F2E0")] public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type, MethodInfo method) { return null; } // Token: 0x060002EB RID: 747 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002EB")] [Address(RVA = "0x54B820", Offset = "0x54A620", VA = "0x18054B820")] private static UnaryExpression GetUserDefinedUnaryOperatorOrThrow(ExpressionType unaryType, string name, Expression operand) { return null; } // Token: 0x060002EC RID: 748 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002EC")] [Address(RVA = "0x54B9C0", Offset = "0x54A7C0", VA = "0x18054B9C0")] private static UnaryExpression GetUserDefinedUnaryOperator(ExpressionType unaryType, string name, Expression operand) { return null; } // Token: 0x060002ED RID: 749 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002ED")] [Address(RVA = "0x54A1F0", Offset = "0x548FF0", VA = "0x18054A1F0")] private static UnaryExpression GetMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method) { return null; } // Token: 0x060002EE RID: 750 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002EE")] [Address(RVA = "0x54B610", Offset = "0x54A410", VA = "0x18054B610")] private static UnaryExpression GetUserDefinedCoercionOrThrow(ExpressionType coercionType, Expression expression, Type convertToType) { return null; } // Token: 0x060002EF RID: 751 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002EF")] [Address(RVA = "0x54B750", Offset = "0x54A550", VA = "0x18054B750")] private static UnaryExpression GetUserDefinedCoercion(ExpressionType coercionType, Expression expression, Type convertToType) { return null; } // Token: 0x060002F0 RID: 752 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F0")] [Address(RVA = "0x549EA0", Offset = "0x548CA0", VA = "0x180549EA0")] private static UnaryExpression GetMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type convertToType, MethodInfo method) { return null; } /// Creates a that represents an arithmetic negation operation. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// /// is and the unary minus operator is not defined for .Type.-or- /// .Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by . // Token: 0x060002F1 RID: 753 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F1")] [Address(RVA = "0x5513E0", Offset = "0x5501E0", VA = "0x1805513E0")] public static UnaryExpression Negate(Expression expression, MethodInfo method) { return null; } /// Creates a that represents a unary plus operation. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// /// is and the unary plus operator is not defined for .Type.-or- /// .Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by . // Token: 0x060002F2 RID: 754 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F2")] [Address(RVA = "0x554E30", Offset = "0x553C30", VA = "0x180554E30")] public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method) { return null; } /// Creates a that represents an arithmetic negation operation that has overflow checking. The implementing method can be specified. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// /// is and the unary minus operator is not defined for .Type.-or- /// .Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by . // Token: 0x060002F3 RID: 755 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F3")] [Address(RVA = "0x551260", Offset = "0x550060", VA = "0x180551260")] public static UnaryExpression NegateChecked(Expression expression, MethodInfo method) { return null; } /// Creates a that represents a bitwise complement operation. The implementing method can be specified. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// /// is and the unary not operator is not defined for .Type.-or- /// .Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by . // Token: 0x060002F4 RID: 756 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F4")] [Address(RVA = "0x551D20", Offset = "0x550B20", VA = "0x180551D20")] public static UnaryExpression Not(Expression expression, MethodInfo method) { return null; } /// Returns whether the expression evaluates to false. /// An to evaluate. /// A that represents the implementing method. /// An instance of . // Token: 0x060002F5 RID: 757 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F5")] [Address(RVA = "0x54C520", Offset = "0x54B320", VA = "0x18054C520")] public static UnaryExpression IsFalse(Expression expression, MethodInfo method) { return null; } /// Returns whether the expression evaluates to true. /// An to evaluate. /// A that represents the implementing method. /// An instance of . // Token: 0x060002F6 RID: 758 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F6")] [Address(RVA = "0x54C970", Offset = "0x54B770", VA = "0x18054C970")] public static UnaryExpression IsTrue(Expression expression, MethodInfo method) { return null; } /// Returns the expression representing the ones complement. /// An . /// A that represents the implementing method. /// An instance of . // Token: 0x060002F7 RID: 759 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F7")] [Address(RVA = "0x551EB0", Offset = "0x550CB0", VA = "0x180551EB0")] public static UnaryExpression OnesComplement(Expression expression, MethodInfo method) { return null; } /// Creates a that represents an explicit reference or boxing conversion where is supplied if the conversion fails. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// or is . // Token: 0x060002F8 RID: 760 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F8")] [Address(RVA = "0x554CF0", Offset = "0x553AF0", VA = "0x180554CF0")] public static UnaryExpression TypeAs(Expression expression, Type type) { return null; } /// Creates a that represents an explicit unboxing. /// An to unbox. /// The new of the expression. /// An instance of . // Token: 0x060002F9 RID: 761 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002F9")] [Address(RVA = "0x554F90", Offset = "0x553D90", VA = "0x180554F90")] public static UnaryExpression Unbox(Expression expression, Type type) { return null; } /// Creates a that represents a type conversion operation. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// or is . /// No conversion operator is defined between .Type and . // Token: 0x060002FA RID: 762 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FA")] [Address(RVA = "0x5476C0", Offset = "0x5464C0", VA = "0x1805476C0")] public static UnaryExpression Convert(Expression expression, Type type) { return null; } /// Creates a that represents a conversion operation for which the implementing method is specified. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// No conversion operator is defined between .Type and .-or- /// .Type is not assignable to the argument type of the method represented by .-or-The return type of the method represented by is not assignable to .-or- /// .Type or is a nullable value type and the corresponding non-nullable value type does not equal the argument type or the return type, respectively, of the method represented by . /// More than one method that matches the description was found. // Token: 0x060002FB RID: 763 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FB")] [Address(RVA = "0x5474E0", Offset = "0x5462E0", VA = "0x1805474E0")] public static UnaryExpression Convert(Expression expression, Type type, MethodInfo method) { return null; } /// Creates a that represents a conversion operation that throws an exception if the target type is overflowed. /// An to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the and properties set to the specified values. /// /// or is . /// No conversion operator is defined between .Type and . // Token: 0x060002FC RID: 764 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FC")] [Address(RVA = "0x547470", Offset = "0x546270", VA = "0x180547470")] public static UnaryExpression ConvertChecked(Expression expression, Type type) { return null; } /// Creates a that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified. /// An to set the property equal to. /// A to set the property equal to. /// A to set the property equal to. /// A that has the property equal to and the , , and properties set to the specified values. /// /// or is . /// /// is not and the method it represents returns , is not ( in Visual Basic), or does not take exactly one argument. /// No conversion operator is defined between .Type and .-or- /// .Type is not assignable to the argument type of the method represented by .-or-The return type of the method represented by is not assignable to .-or- /// .Type or is a nullable value type and the corresponding non-nullable value type does not equal the argument type or the return type, respectively, of the method represented by . /// More than one method that matches the description was found. // Token: 0x060002FD RID: 765 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FD")] [Address(RVA = "0x547270", Offset = "0x546070", VA = "0x180547270")] public static UnaryExpression ConvertChecked(Expression expression, Type type, MethodInfo method) { return null; } /// Creates a that represents an expression for obtaining the length of a one-dimensional array. /// An to set the property equal to. /// A that has the property equal to and the property equal to . /// /// is . /// /// .Type does not represent an array type. // Token: 0x060002FE RID: 766 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FE")] [Address(RVA = "0x5433B0", Offset = "0x5421B0", VA = "0x1805433B0")] public static UnaryExpression ArrayLength(Expression array) { return null; } /// Creates a that represents an expression that has a constant value of type . /// An to set the property equal to. /// A that has the property equal to and the property set to the specified value. /// /// is . // Token: 0x060002FF RID: 767 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60002FF")] [Address(RVA = "0x553520", Offset = "0x552320", VA = "0x180553520")] public static UnaryExpression Quote(Expression expression) { return null; } /// Creates a that represents a throwing of an exception with a given type. /// An . /// The new of the expression. /// A that represents the exception. // Token: 0x06000300 RID: 768 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000300")] [Address(RVA = "0x554B10", Offset = "0x553910", VA = "0x180554B10")] public static UnaryExpression Throw(Expression value, Type type) { return null; } /// Creates a that represents the incrementing of the expression by 1. /// An to increment. /// A that represents the implementing method. /// A that represents the incremented expression. // Token: 0x06000301 RID: 769 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000301")] [Address(RVA = "0x54C040", Offset = "0x54AE40", VA = "0x18054C040")] public static UnaryExpression Increment(Expression expression, MethodInfo method) { return null; } /// Creates a that represents the decrementing of the expression by 1. /// An to decrement. /// A that represents the implementing method. /// A that represents the decremented expression. // Token: 0x06000302 RID: 770 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000302")] [Address(RVA = "0x547BF0", Offset = "0x5469F0", VA = "0x180547BF0")] public static UnaryExpression Decrement(Expression expression, MethodInfo method) { return null; } /// Creates a that increments the expression by 1 and assigns the result back to the expression. /// An to apply the operations on. /// A that represents the implementing method. /// A that represents the resultant expression. // Token: 0x06000303 RID: 771 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000303")] [Address(RVA = "0x552F00", Offset = "0x551D00", VA = "0x180552F00")] public static UnaryExpression PreIncrementAssign(Expression expression, MethodInfo method) { return null; } /// Creates a that decrements the expression by 1 and assigns the result back to the expression. /// An to apply the operations on. /// A that represents the implementing method. /// A that represents the resultant expression. // Token: 0x06000304 RID: 772 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000304")] [Address(RVA = "0x552E90", Offset = "0x551C90", VA = "0x180552E90")] public static UnaryExpression PreDecrementAssign(Expression expression, MethodInfo method) { return null; } /// Creates a that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression. /// An to apply the operations on. /// A that represents the implementing method. /// A that represents the resultant expression. // Token: 0x06000305 RID: 773 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000305")] [Address(RVA = "0x552B40", Offset = "0x551940", VA = "0x180552B40")] public static UnaryExpression PostIncrementAssign(Expression expression, MethodInfo method) { return null; } /// Creates a that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression. /// An to apply the operations on. /// A that represents the implementing method. /// A that represents the resultant expression. // Token: 0x06000306 RID: 774 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000306")] [Address(RVA = "0x552AD0", Offset = "0x5518D0", VA = "0x180552AD0")] public static UnaryExpression PostDecrementAssign(Expression expression, MethodInfo method) { return null; } // Token: 0x06000307 RID: 775 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6000307")] [Address(RVA = "0x54EEC0", Offset = "0x54DCC0", VA = "0x18054EEC0")] private static UnaryExpression MakeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method) { return null; } // Token: 0x0400011B RID: 283 [Token(Token = "0x400011B")] private static readonly CacheDict s_lambdaDelegateCache; // Token: 0x0400011C RID: 284 [Token(Token = "0x400011C")] private static CacheDict, LambdaExpression>> s_lambdaFactories; // Token: 0x0400011D RID: 285 [Token(Token = "0x400011D")] private static ConditionalWeakTable s_legacyCtorSupportTable; // Token: 0x02000054 RID: 84 [Token(Token = "0x2000054")] internal class BinaryExpressionProxy { } // Token: 0x02000055 RID: 85 [Token(Token = "0x2000055")] internal class BlockExpressionProxy { } // Token: 0x02000056 RID: 86 [Token(Token = "0x2000056")] internal class CatchBlockProxy { } // Token: 0x02000057 RID: 87 [Token(Token = "0x2000057")] internal class ConditionalExpressionProxy { } // Token: 0x02000058 RID: 88 [Token(Token = "0x2000058")] internal class ConstantExpressionProxy { } // Token: 0x02000059 RID: 89 [Token(Token = "0x2000059")] internal class DebugInfoExpressionProxy { } // Token: 0x0200005A RID: 90 [Token(Token = "0x200005A")] internal class DefaultExpressionProxy { } // Token: 0x0200005B RID: 91 [Token(Token = "0x200005B")] internal class GotoExpressionProxy { } // Token: 0x0200005C RID: 92 [Token(Token = "0x200005C")] internal class IndexExpressionProxy { } // Token: 0x0200005D RID: 93 [Token(Token = "0x200005D")] internal class InvocationExpressionProxy { } // Token: 0x0200005E RID: 94 [Token(Token = "0x200005E")] internal class LabelExpressionProxy { } // Token: 0x0200005F RID: 95 [Token(Token = "0x200005F")] internal class LambdaExpressionProxy { } // Token: 0x02000060 RID: 96 [Token(Token = "0x2000060")] internal class ListInitExpressionProxy { } // Token: 0x02000061 RID: 97 [Token(Token = "0x2000061")] internal class LoopExpressionProxy { } // Token: 0x02000062 RID: 98 [Token(Token = "0x2000062")] internal class MemberExpressionProxy { } // Token: 0x02000063 RID: 99 [Token(Token = "0x2000063")] internal class MemberInitExpressionProxy { } // Token: 0x02000064 RID: 100 [Token(Token = "0x2000064")] internal class MethodCallExpressionProxy { } // Token: 0x02000065 RID: 101 [Token(Token = "0x2000065")] internal class NewArrayExpressionProxy { } // Token: 0x02000066 RID: 102 [Token(Token = "0x2000066")] internal class NewExpressionProxy { } // Token: 0x02000067 RID: 103 [Token(Token = "0x2000067")] internal class ParameterExpressionProxy { } // Token: 0x02000068 RID: 104 [Token(Token = "0x2000068")] internal class RuntimeVariablesExpressionProxy { } // Token: 0x02000069 RID: 105 [Token(Token = "0x2000069")] internal class SwitchCaseProxy { } // Token: 0x0200006A RID: 106 [Token(Token = "0x200006A")] internal class SwitchExpressionProxy { } // Token: 0x0200006B RID: 107 [Token(Token = "0x200006B")] internal class TryExpressionProxy { } // Token: 0x0200006C RID: 108 [Token(Token = "0x200006C")] internal class TypeBinaryExpressionProxy { } // Token: 0x0200006D RID: 109 [Token(Token = "0x200006D")] internal class UnaryExpressionProxy { } // Token: 0x0200006E RID: 110 [Token(Token = "0x200006E")] private class ExtensionInfo { // Token: 0x0400011E RID: 286 [FieldOffset(Offset = "0x10")] [Token(Token = "0x400011E")] internal readonly ExpressionType NodeType; // Token: 0x0400011F RID: 287 [FieldOffset(Offset = "0x18")] [Token(Token = "0x400011F")] internal readonly Type Type; } } }