Expression Class
[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the latest documentation. ]
Provides the base class from which the classes that represent expression tree nodes are derived. It also contains static (Shared in Visual Basic) factory methods to create the various node types. This is an abstract class.
Assembly: System.Core (in System.Core.dll)
The Expression type exposes the following members.
| Name | Description | |
|---|---|---|
 | Expression() | Constructs a new instance of Expression. |
| Expression(ExpressionType, Type) | Obsolete. Initializes a new instance of the Expression class. |
| Name | Description | |
|---|---|---|
| Accept | Dispatches to the specific visit method for this node type. For example, MethodCallExpression calls the VisitMethodCall. |
  | Add(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking. |
| Add(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking. The implementing method can be specified. |
| AddAssign(Expression, Expression) | Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking. |
| AddAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking. |
| AddAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking. |
| AddAssignChecked(Expression, Expression) | Creates a BinaryExpression that represents an addition assignment operation that has overflow checking. |
| AddAssignChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an addition assignment operation that has overflow checking. |
| AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents an addition assignment operation that has overflow checking. |
| AddChecked(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking. |
| AddChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking. The implementing method can be specified. |
| And(Expression, Expression) | Creates a BinaryExpression that represents a bitwise AND operation. |
| And(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise AND operation. The implementing method can be specified. |
| AndAlso(Expression, Expression) | Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand evaluates to true. |
| AndAlso(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand is resolved to true. The implementing method can be specified. |
| AndAssign(Expression, Expression) | Creates a BinaryExpression that represents a bitwise AND assignment operation. |
| AndAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise AND assignment operation. |
| AndAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a bitwise AND assignment operation. |
| ArrayAccess(Expression, IEnumerable<Expression>) | Creates an IndexExpression to access a multidimensional array. |
| ArrayAccess(Expression, array<Expression>) | Creates an IndexExpression to access an array. |
| ArrayIndex(Expression, IEnumerable<Expression>) | Creates a MethodCallExpression that represents applying an array index operator to an array of rank more than one. |
| ArrayIndex(Expression, Expression) | Creates a BinaryExpression that represents applying an array index operator to an array of rank one. |
| ArrayIndex(Expression, array<Expression>) | Creates a MethodCallExpression that represents applying an array index operator to a multidimensional array. |
| ArrayLength | Creates a UnaryExpression that represents an expression for obtaining the length of a one-dimensional array. |
| Assign | Creates a BinaryExpression that represents an assignment operation. |
| Bind(MemberInfo, Expression) | Creates a MemberAssignment that represents the initialization of a field or property. |
| Bind(MethodInfo, Expression) | Creates a MemberAssignment that represents the initialization of a member by using a property accessor method. |
| Block(array<Expression>) | Creates a BlockExpression that contains the given expressions and has no variables. |
| Block(IEnumerable<Expression>) | Creates a BlockExpression that contains the given expressions and has no variables. |
| Block(Expression, Expression) | Creates a BlockExpression that contains two expressions and has no variables. |
| Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>) | Creates a BlockExpression that contains the given variables and expressions. |
| Block(IEnumerable<ParameterExpression>, array<Expression>) | Creates a BlockExpression that contains the given variables and expressions. |
| Block(Type, IEnumerable<Expression>) | Creates a BlockExpression that contains the given expressions, has no variables and has specific result type. |
| Block(Type, array<Expression>) | Creates a BlockExpression that contains the given expressions, has no variables and has specific result type. |
| Block(Expression, Expression, Expression) | Creates a BlockExpression that contains three expressions and has no variables. |
| Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>) | Creates a BlockExpression that contains the given variables and expressions. |
| Block(Type, IEnumerable<ParameterExpression>, array<Expression>) | Creates a BlockExpression that contains the given variables and expressions. |
| Block(Expression, Expression, Expression, Expression) | Creates a BlockExpression that contains four expressions and has no variables. |
| Block(Expression, Expression, Expression, Expression, Expression) | Creates a BlockExpression that contains five expressions and has no variables. |
| Break(LabelTarget) | Creates a GotoExpression representing a break statement. |
| Break(LabelTarget, Expression) | Creates a GotoExpression representing a break statement. The value passed to the label upon jumping can be specified. |
| Break(LabelTarget, Type) | Creates a GotoExpression representing a break statement with the specified type. |
| Break(LabelTarget, Expression, Type) | Creates a GotoExpression representing a break statement with the specified type. The value passed to the label upon jumping can be specified. |
| Call(Expression, MethodInfo) | Creates a MethodCallExpression that represents a call to an instance method that takes no arguments. |
| Call(MethodInfo, IEnumerable<Expression>) | Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method. |
| Call(MethodInfo, Expression) | Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that takes one argument. |
| Call(MethodInfo, array<Expression>) | Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that has arguments. |
| Call(Expression, MethodInfo, IEnumerable<Expression>) | Creates a MethodCallExpression that represents a call to a method that takes arguments. |
| Call(Expression, MethodInfo, array<Expression>) | Creates a MethodCallExpression that represents a call to a method that takes arguments. |
| Call(MethodInfo, Expression, Expression) | Creates a MethodCallExpression that represents a call to an static method that takes two arguments. |
| Call(Expression, MethodInfo, Expression, Expression) | Creates a MethodCallExpression that represents a call to a static method that takes two arguments. |
| Call(Expression, String, array<Type>, array<Expression>) | Creates a MethodCallExpression that represents a call to an instance method by calling the appropriate factory method. |
| Call(MethodInfo, Expression, Expression, Expression) | Creates a MethodCallExpression that represents a call to a static method that takes three arguments. |
| Call(Type, String, array<Type>, array<Expression>) | Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method by calling the appropriate factory method. |
| Call(Expression, MethodInfo, Expression, Expression, Expression) | Creates a MethodCallExpression that represents a call to a method that takes no arguments. |
| Call(MethodInfo, Expression, Expression, Expression, Expression) | Creates a MethodCallExpression that represents a call to a static method that takes four arguments. |
| Call(MethodInfo, Expression, Expression, Expression, Expression, Expression) | Creates a MethodCallExpression that represents a call to a static method that takes five arguments. |
| Catch(ParameterExpression, Expression) | Creates a CatchBlock representing a catch statement with a reference to the caught Exception object for use in the handler body. |
| Catch(Type, Expression) | Creates a CatchBlock representing a catch statement. |
| Catch(ParameterExpression, Expression, Expression) | Creates a CatchBlock representing a catch statement with an Exception filter and a reference to the caught Exception object. |
| Catch(Type, Expression, Expression) | Creates a CatchBlock representing a catch statement with an Exception filter but no reference to the caught Exception object. |
| ClearDebugInfo | Creates a DebugInfoExpression for clearing a sequence point. |
| Coalesce(Expression, Expression) | Creates a BinaryExpression that represents a coalescing operation. |
| Coalesce(Expression, Expression, LambdaExpression) | Creates a BinaryExpression that represents a coalescing operation, given a conversion function. |
| Condition(Expression, Expression, Expression) | Creates a ConditionalExpression that represents a conditional statement. |
| Condition(Expression, Expression, Expression, Type) | Creates a ConditionalExpression that represents a conditional statement. |
| Constant(Object) | Creates a ConstantExpression that has the Value property set to the specified value. |
| Constant(Object, Type) | Creates a ConstantExpression that has the Value and Type properties set to the specified values. |
| Continue(LabelTarget) | Creates a GotoExpression representing a continue statement. |
| Continue(LabelTarget, Type) | Creates a GotoExpression representing a continue statement with the specified type. |
| Convert(Expression, Type) | Creates a UnaryExpression that represents a type conversion operation. |
| Convert(Expression, Type, MethodInfo) | Creates a UnaryExpression that represents a conversion operation for which the implementing method is specified. |
| ConvertChecked(Expression, Type) | Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed. |
| ConvertChecked(Expression, Type, MethodInfo) | Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified. |
| DebugInfo | Creates a DebugInfoExpression with the specified span. |
| Decrement(Expression) | Creates a UnaryExpression that represents the decrementing of the expression by 1. |
| Decrement(Expression, MethodInfo) | Creates a UnaryExpression that represents the decrementing of the expression by 1. |
| Default | Creates a DefaultExpression that has the Type property set to the specified type. |
| Divide(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic division operation. |
| Divide(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic division operation. The implementing method can be specified. |
| DivideAssign(Expression, Expression) | Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking. |
| DivideAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking. |
| DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking. |
| ElementInit(MethodInfo, IEnumerable<Expression>) | Creates an ElementInit, given an IEnumerable<T> as the second argument. |
| ElementInit(MethodInfo, array<Expression>) | Creates an ElementInit, given an array of values as the second argument. |
| Empty | Creates an empty expression that has Void type. |
| Equal(Expression, Expression) | Creates a BinaryExpression that represents an equality comparison. |
| Equal(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents an equality comparison. The implementing method can be specified. |
| Equals(Object) | Determines whether the specified Object is equal to the current Object. (Inherited from Object.) |
| ExclusiveOr(Expression, Expression) | Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types. |
| ExclusiveOr(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types. The implementing method can be specified. |
| ExclusiveOrAssign(Expression, Expression) | Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types. |
| ExclusiveOrAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types. |
| ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types. |
| Field(Expression, FieldInfo) | Creates a MemberExpression that represents accessing a field. |
| Field(Expression, String) | Creates a MemberExpression that represents accessing a field given the name of the field. |
| Field(Expression, Type, String) | Creates a MemberExpression that represents accessing a field. |
| Finalize | Allows an object to try to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.) |
| GetActionType | Creates a Type object that represents a generic System.Action delegate type that has specific type arguments. |
| GetDelegateType | Gets a Type object that represents a generic System.Func or System.Action delegate type that has specific type arguments. |
| GetFuncType | Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. The last type argument specifies the return type of the created delegate. |
| GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.) |
| GetType | Gets the Type of the current instance. (Inherited from Object.) |
| Goto(LabelTarget) | Creates a GotoExpression representing a "go to" statement. |
| Goto(LabelTarget, Expression) | Creates a GotoExpression representing a "go to" statement. The value passed to the label upon jumping can be specified. |
| Goto(LabelTarget, Type) | Creates a GotoExpression representing a "go to" statement with the specified type. |
| Goto(LabelTarget, Expression, Type) | Creates a GotoExpression representing a "go to" statement with the specified type. The value passed to the label upon jumping can be specified. |
| GreaterThan(Expression, Expression) | Creates a BinaryExpression that represents a "greater than" numeric comparison. |
| GreaterThan(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents a "greater than" numeric comparison. The implementing method can be specified. |
| GreaterThanOrEqual(Expression, Expression) | Creates a BinaryExpression that represents a "greater than or equal" numeric comparison. |
| GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents a "greater than or equal" numeric comparison. |
| IfThen | Creates a ConditionalExpression that represents a conditional block with an if statement. |
| IfThenElse | Creates a ConditionalExpression that represents a conditional block with if and else statements. |
| Increment(Expression) | Creates a UnaryExpression that represents the incrementing of the expression value by 1. |
| Increment(Expression, MethodInfo) | Creates a UnaryExpression that represents the incrementing of the expression by 1. |
| Invoke(Expression, IEnumerable<Expression>) | Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions. |
| Invoke(Expression, array<Expression>) | Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions. |
| IsFalse(Expression) | Returns whether the expression evaluates to false. |
| IsFalse(Expression, MethodInfo) | Returns whether the expression evaluates to false. |
| IsTrue(Expression) | Returns whether the expression evaluates to true. |
| IsTrue(Expression, MethodInfo) | Returns whether the expression evaluates to true. |
| Label() | Creates a LabelTarget representing a label with void type and no name. |
| Label(LabelTarget) | Creates a LabelExpression representing a label without a default value. |
| Label(String) | Creates a LabelTarget representing a label with void type and the given name. |
| Label(Type) | Creates a LabelTarget representing a label with the given type. |
| Label(LabelTarget, Expression) | Creates a LabelExpression representing a label with the given default value. |
| Label(Type, String) | Creates a LabelTarget representing a label with the given type and name. |
| Lambda(Expression, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Expression, array<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Expression, Boolean, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Expression, Boolean, array<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Expression, String, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Type, Expression, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. It can be used when the delegate type is not known at compile time. |
| Lambda(Type, Expression, array<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. It can be used when the delegate type is not known at compile time. |
| Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Type, Expression, Boolean, array<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Type, Expression, String, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>) | Creates a LambdaExpression by first constructing a delegate type. |
| Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| Lambda<TDelegate>(Expression, array<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| Lambda<TDelegate>(Expression, Boolean, array<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>) | Creates an Expression<TDelegate> where the delegate type is known at compile time. |
| LeftShift(Expression, Expression) | Creates a BinaryExpression that represents a bitwise left-shift operation. |
| LeftShift(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise left-shift operation. |
| LeftShiftAssign(Expression, Expression) | Creates a BinaryExpression that represents a bitwise left-shift assignment operation. |
| LeftShiftAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise left-shift assignment operation. |
| LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a bitwise left-shift assignment operation. |
| LessThan(Expression, Expression) | Creates a BinaryExpression that represents a "less than" numeric comparison. |
| LessThan(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents a "less than" numeric comparison. |
| LessThanOrEqual(Expression, Expression) | Creates a BinaryExpression that represents a " less than or equal" numeric comparison. |
| LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents a "less than or equal" numeric comparison. |
| ListBind(MemberInfo, IEnumerable<ElementInit>) | Creates a MemberListBinding where the member is a field or property. |
| ListBind(MemberInfo, array<ElementInit>) | Creates a MemberListBinding where the member is a field or property. |
| ListBind(MethodInfo, IEnumerable<ElementInit>) | Creates a MemberListBinding based on a specified property accessor method. |
| ListBind(MethodInfo, array<ElementInit>) | Creates a MemberListBinding object based on a specified property accessor method. |
| ListInit(NewExpression, IEnumerable<ElementInit>) | Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection. |
| ListInit(NewExpression, IEnumerable<Expression>) | Creates a ListInitExpression that uses a method named "Add" to add elements to a collection. |
| ListInit(NewExpression, array<ElementInit>) | Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection. |
| ListInit(NewExpression, array<Expression>) | Creates a ListInitExpression that uses a method named "Add" to add elements to a collection. |
| ListInit(NewExpression, MethodInfo, IEnumerable<Expression>) | Creates a ListInitExpression that uses a specified method to add elements to a collection. |
| ListInit(NewExpression, MethodInfo, array<Expression>) | Creates a ListInitExpression that uses a specified method to add elements to a collection. |
| Loop(Expression) | Creates a LoopExpression with the given body. |
| Loop(Expression, LabelTarget) | Creates a LoopExpression with the given body and break target. |
| Loop(Expression, LabelTarget, LabelTarget) | Creates a LoopExpression with the given body. |
| MakeBinary(ExpressionType, Expression, Expression) | Creates a BinaryExpression, given the left and right operands, by calling an appropriate factory method. |
| MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression, given the left operand, right operand and implementing method, by calling the appropriate factory method. |
| MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression) | Creates a BinaryExpression, given the left operand, right operand, implementing method and type conversion function, by calling the appropriate factory method. |
| MakeCatchBlock | Creates a CatchBlock representing a catch statement with the specified elements. |
| MakeGoto | Creates a GotoExpression representing a jump of the specified GotoExpressionKind. The value passed to the label upon jumping can also be specified. |
| MakeIndex | Creates an IndexExpression that represents accessing an indexed property in an object. |
| MakeMemberAccess | Creates a MemberExpression that represents accessing either a field or a property. |
| MakeTry | Creates a TryExpression representing a try block with the specified elements. |
| MakeUnary(ExpressionType, Expression, Type) | Creates a UnaryExpression, given an operand, by calling the appropriate factory method. |
| MakeUnary(ExpressionType, Expression, Type, MethodInfo) | Creates a UnaryExpression, given an operand and implementing method, by calling the appropriate factory method. |
| MemberBind(MemberInfo, IEnumerable<MemberBinding>) | Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property. |
| MemberBind(MemberInfo, array<MemberBinding>) | Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property. |
| MemberBind(MethodInfo, IEnumerable<MemberBinding>) | Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method. |
| MemberBind(MethodInfo, array<MemberBinding>) | Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method. |
| MemberInit(NewExpression, IEnumerable<MemberBinding>) | Represents an expression that creates a new object and initializes a property of the object. |
| MemberInit(NewExpression, array<MemberBinding>) | Creates a MemberInitExpression. |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.) |
| Modulo(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic remainder operation. |
| Modulo(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic remainder operation. |
| ModuloAssign(Expression, Expression) | Creates a BinaryExpression that represents a remainder assignment operation. |
| ModuloAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a remainder assignment operation. |
| ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a remainder assignment operation. |
| Multiply(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking. |
| Multiply(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking. |
| MultiplyAssign(Expression, Expression) | Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking. |
| MultiplyAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking. |
| MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking. |
| MultiplyAssignChecked(Expression, Expression) | Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking. |
| MultiplyAssignChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking. |
| MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking. |
| MultiplyChecked(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking. |
| MultiplyChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking. |
| Negate(Expression) | Creates a UnaryExpression that represents an arithmetic negation operation. |
| Negate(Expression, MethodInfo) | Creates a UnaryExpression that represents an arithmetic negation operation. |
| NegateChecked(Expression) | Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking. |
| NegateChecked(Expression, MethodInfo) | Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking. The implementing method can be specified. |
| New(ConstructorInfo) | Creates a NewExpression that represents calling the specified constructor that takes no arguments. |
| New(Type) | Creates a NewExpression that represents calling the parameterless constructor of the specified type. |
| New(ConstructorInfo, IEnumerable<Expression>) | Creates a NewExpression that represents calling the specified constructor with the specified arguments. |
| New(ConstructorInfo, array<Expression>) | Creates a NewExpression that represents calling the specified constructor with the specified arguments. |
| New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>) | Creates a NewExpression that represents calling the specified constructor with the specified arguments. The members that access the constructor initialized fields are specified. |
| New(ConstructorInfo, IEnumerable<Expression>, array<MemberInfo>) | Creates a NewExpression that represents calling the specified constructor with the specified arguments. The members that access the constructor initialized fields are specified as an array. |
| NewArrayBounds(Type, IEnumerable<Expression>) | Creates a NewArrayExpression that represents creating an array that has a specified rank. |
| NewArrayBounds(Type, array<Expression>) | Creates a NewArrayExpression that represents creating an array that has a specified rank. |
| NewArrayInit(Type, IEnumerable<Expression>) | Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements. |
| NewArrayInit(Type, array<Expression>) | Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements. |
| Not(Expression) | Creates a UnaryExpression that represents a bitwise complement operation. |
| Not(Expression, MethodInfo) | Creates a UnaryExpression that represents a bitwise complement operation. The implementing method can be specified. |
| NotEqual(Expression, Expression) | Creates a BinaryExpression that represents an inequality comparison. |
| NotEqual(Expression, Expression, Boolean, MethodInfo) | Creates a BinaryExpression that represents an inequality comparison. |
| OnesComplement(Expression) | Returns the expression representing the ones complement. |
| OnesComplement(Expression, MethodInfo) | Returns the expression representing the ones complement. |
| Or(Expression, Expression) | Creates a BinaryExpression that represents a bitwise OR operation. |
| Or(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise OR operation. |
| OrAssign(Expression, Expression) | Creates a BinaryExpression that represents a bitwise OR assignment operation. |
| OrAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise OR assignment operation. |
| OrAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a bitwise OR assignment operation. |
| OrElse(Expression, Expression) | Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false. |
| OrElse(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false. |
| Parameter(Type) | Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree. |
| Parameter(Type, String) | Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree. |
| PostDecrementAssign(Expression) | Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression. |
| PostDecrementAssign(Expression, MethodInfo) | Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression. |
| PostIncrementAssign(Expression) | Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression. |
| PostIncrementAssign(Expression, MethodInfo) | Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression. |
| Power(Expression, Expression) | Creates a BinaryExpression that represents raising a number to a power. |
| Power(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents raising a number to a power. |
| PowerAssign(Expression, Expression) | Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression. |
| PowerAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression. |
| PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression. |
| PreDecrementAssign(Expression) | Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression. |
| PreDecrementAssign(Expression, MethodInfo) | Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression. |
| PreIncrementAssign(Expression) | Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression. |
| PreIncrementAssign(Expression, MethodInfo) | Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression. |
| Property(Expression, MethodInfo) | Creates a MemberExpression that represents accessing a property by using a property accessor method. |
| Property(Expression, PropertyInfo) | Creates a MemberExpression that represents accessing a property. |
| Property(Expression, String) | Creates a MemberExpression that represents accessing a property. |
| Property(Expression, PropertyInfo, IEnumerable<Expression>) | Creates an IndexExpression representing the access to an indexed property. |
| Property(Expression, PropertyInfo, array<Expression>) | Creates an IndexExpression representing the access to an indexed property. |
| Property(Expression, String, array<Expression>) | Creates an IndexExpression representing the access to an indexed property. |
| Property(Expression, Type, String) | Creates a MemberExpression accessing a property. |
| PropertyOrField | Creates a MemberExpression that represents accessing a property or field. |
| Quote | Creates a UnaryExpression that represents an expression that has a constant value of type Expression. |
| Reduce | 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. |
| ReduceAndCheck | 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. |
| ReduceExtensions | Reduces the expression to a known node type (that is not an Extension node) or just returns the expression if it is already a known type. |
| ReferenceEqual | Creates a BinaryExpression that represents a reference equality comparison. |
| ReferenceNotEqual | Creates a BinaryExpression that represents a reference inequality comparison. |
| Rethrow() | Creates a UnaryExpression that represents a rethrowing of an exception. |
| Rethrow(Type) | Creates a UnaryExpression that represents a rethrowing of an exception with a given type. |
| Return(LabelTarget) | Creates a GotoExpression representing a return statement. |
| Return(LabelTarget, Expression) | Creates a GotoExpression representing a return statement. The value passed to the label upon jumping can be specified. |
| Return(LabelTarget, Type) | Creates a GotoExpression representing a return statement with the specified type. |
| Return(LabelTarget, Expression, Type) | Creates a GotoExpression representing a return statement with the specified type. The value passed to the label upon jumping can be specified. |
| RightShift(Expression, Expression) | Creates a BinaryExpression that represents a bitwise right-shift operation. |
| RightShift(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise right-shift operation. |
| RightShiftAssign(Expression, Expression) | Creates a BinaryExpression that represents a bitwise right-shift assignment operation. |
| RightShiftAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a bitwise right-shift assignment operation. |
| RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a bitwise right-shift assignment operation. |
| RuntimeVariables(IEnumerable<ParameterExpression>) | Creates an instance of RuntimeVariablesExpression. |
| RuntimeVariables(array<ParameterExpression>) | Creates an instance of RuntimeVariablesExpression. |
| Subtract(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking. |
| Subtract(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking. |
| SubtractAssign(Expression, Expression) | Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking. |
| SubtractAssign(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking. |
| SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking. |
| SubtractAssignChecked(Expression, Expression) | Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking. |
| SubtractAssignChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking. |
| SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking. |
| SubtractChecked(Expression, Expression) | Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking. |
| SubtractChecked(Expression, Expression, MethodInfo) | Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking. |
| Switch(Expression, array<SwitchCase>) | Creates a SwitchExpression that represents a switch statement without a default case. |
| Switch(Expression, Expression, array<SwitchCase>) | Creates a SwitchExpression that represents a switch statement that has a default case. |
| Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) | Creates a SwitchExpression that represents a switch statement that has a default case. |
| Switch(Expression, Expression, MethodInfo, array<SwitchCase>) | Creates a SwitchExpression that represents a switch statement that has a default case. |
| Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) | Creates a SwitchExpression that represents a switch statement that has a default case. |
| Switch(Type, Expression, Expression, MethodInfo, array<SwitchCase>) | Creates a SwitchExpression that represents a switch statement that has a default case.. |
| SwitchCase(Expression, IEnumerable<Expression>) | Creates a SwitchCase object to be used in a SwitchExpression object. |
| SwitchCase(Expression, array<Expression>) | Creates a SwitchCase for use in a SwitchExpression. |
| SymbolDocument(String) | Creates an instance of SymbolDocumentInfo. |
| SymbolDocument(String, Guid) | Creates an instance of SymbolDocumentInfo. |
| SymbolDocument(String, Guid, Guid) | Creates an instance of SymbolDocumentInfo. |
| SymbolDocument(String, Guid, Guid, Guid) | Creates an instance of SymbolDocumentInfo. |
| Throw(Expression) | Creates a UnaryExpression that represents a throwing of an exception. |
| Throw(Expression, Type) | Creates a UnaryExpression that represents a throwing of an exception with a given type. |
| ToString | Returns a textual representation of the Expression. (Overrides Object::ToString().) |
| TryCatch | Creates a TryExpression representing a try block with any number of catch statements and neither a fault nor finally block. |
| TryCatchFinally | Creates a TryExpression representing a try block with any number of catch statements and a finally block. |
| TryFault | Creates a TryExpression representing a try block with a fault block and no catch statements. |
| TryFinally | Creates a TryExpression representing a try block with a finally block and no catch statements. |
| TryGetActionType | Creates a Type object that represents a generic System.Action delegate type that has specific type arguments. |
| TryGetFuncType | Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. The last type argument specifies the return type of the created delegate. |
| TypeAs | Creates a UnaryExpression that represents an explicit reference or boxing conversion where nullptr is supplied if the conversion fails. |
| TypeEqual | Creates a TypeBinaryExpression that compares run-time type identity. |
| TypeIs | Creates a TypeBinaryExpression. |
| UnaryPlus(Expression) | Creates a UnaryExpression that represents a unary plus operation. |
| UnaryPlus(Expression, MethodInfo) | Creates a UnaryExpression that represents a unary plus operation. |
| Unbox | Creates a UnaryExpression that represents an explicit unboxing. |
| Variable(Type) | Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree. |
| Variable(Type, String) | Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree. |
| VisitChildren | Reduces the node and then calls the visitor delegate on the reduced expression. The method throws an exception if the node is not reducible. |
The following code example shows how to create a block expression. The block expression consists of two MethodCallExpression objects and one ConstantExpression object.
System::Object
System.Linq.Expressions::Expression
System.Linq.Expressions::BinaryExpression
System.Linq.Expressions::BlockExpression
System.Linq.Expressions::ConditionalExpression
System.Linq.Expressions::ConstantExpression
System.Linq.Expressions::DebugInfoExpression
System.Linq.Expressions::DefaultExpression
System.Linq.Expressions::DynamicExpression
System.Linq.Expressions::GotoExpression
System.Linq.Expressions::IndexExpression
System.Linq.Expressions::InvocationExpression
System.Linq.Expressions::LabelExpression
System.Linq.Expressions::LambdaExpression
System.Linq.Expressions::ListInitExpression
System.Linq.Expressions::LoopExpression
System.Linq.Expressions::MemberExpression
System.Linq.Expressions::MemberInitExpression
System.Linq.Expressions::MethodCallExpression
System.Linq.Expressions::NewArrayExpression
System.Linq.Expressions::NewExpression
System.Linq.Expressions::ParameterExpression
System.Linq.Expressions::RuntimeVariablesExpression
System.Linq.Expressions::SwitchExpression
System.Linq.Expressions::TryExpression
System.Linq.Expressions::TypeBinaryExpression
System.Linq.Expressions::UnaryExpression
System.Linq.Expressions::Expression
System.Linq.Expressions::BinaryExpression
System.Linq.Expressions::BlockExpression
System.Linq.Expressions::ConditionalExpression
System.Linq.Expressions::ConstantExpression
System.Linq.Expressions::DebugInfoExpression
System.Linq.Expressions::DefaultExpression
System.Linq.Expressions::DynamicExpression
System.Linq.Expressions::GotoExpression
System.Linq.Expressions::IndexExpression
System.Linq.Expressions::InvocationExpression
System.Linq.Expressions::LabelExpression
System.Linq.Expressions::LambdaExpression
System.Linq.Expressions::ListInitExpression
System.Linq.Expressions::LoopExpression
System.Linq.Expressions::MemberExpression
System.Linq.Expressions::MemberInitExpression
System.Linq.Expressions::MethodCallExpression
System.Linq.Expressions::NewArrayExpression
System.Linq.Expressions::NewExpression
System.Linq.Expressions::ParameterExpression
System.Linq.Expressions::RuntimeVariablesExpression
System.Linq.Expressions::SwitchExpression
System.Linq.Expressions::TryExpression
System.Linq.Expressions::TypeBinaryExpression
System.Linq.Expressions::UnaryExpression
Show: