Expression Classe

Définition

Espace de noms:
System.Linq.Expressions
Assemblys:
System.Core.dll, System.Linq.Expressions.dll
Assembly:
System.Core.dll
Assembly:
System.Linq.Expressions.dll
Assembly:
netstandard.dll

Fournit la classe de base à partir de laquelle les classes qui représentent des nœuds d’arborescence d’expressions sont dérivées. Il contient static également (Shared en Visual Basic) des méthodes de fabrique pour créer les différents types de nœuds. Il s’agit d’une abstract classe.

public ref class Expression abstract
public abstract class Expression
type Expression = class
Public MustInherit Class Expression
Héritage
Object
Expression
Dérivé

Exemples

L’exemple de code suivant montre comment créer une expression de bloc. L’expression de bloc se compose de deux MethodCallExpression objets et d’un ConstantExpression objet.

// Add the following directive to your file:
// using System.Linq.Expressions;

// The block expression allows for executing several expressions sequentually.
// When the block expression is executed,
// it returns the value of the last expression in the sequence.
BlockExpression blockExpr = Expression.Block(
    Expression.Call(
        null,
        typeof(Console).GetMethod("Write", new Type[] { typeof(String) }),
        Expression.Constant("Hello ")
       ),
    Expression.Call(
        null,
        typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),
        Expression.Constant("World!")
        ),
    Expression.Constant(42)
);

Console.WriteLine("The result of executing the expression tree:");
// The following statement first creates an expression tree,
// then compiles it, and then executes it.
var result = Expression.Lambda<Func<int>>(blockExpr).Compile()();

// Print out the expressions from the block expression.
Console.WriteLine("The expressions from the block expression:");
foreach (var expr in blockExpr.Expressions)
    Console.WriteLine(expr.ToString());

// Print out the result of the tree execution.
Console.WriteLine("The return value of the block expression:");
Console.WriteLine(result);

// This code example produces the following output:
//
// The result of executing the expression tree:
// Hello World!

// The expressions from the block expression:
// Write("Hello ")
// WriteLine("World!")
// 42

// The return value of the block expression:
// 42

' Add the following directive to your file:
' Imports System.Linq.Expressions

' The block expression enables you to execute several expressions sequentually.
' When the block expression is executed,
' it returns the value of the last expression in the sequence.
Dim blockExpr As BlockExpression = Expression.Block(
    Expression.Call(
        Nothing,
        GetType(Console).GetMethod("Write", New Type() {GetType(String)}),
        Expression.Constant("Hello ")
       ),
    Expression.Call(
        Nothing,
        GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)}),
        Expression.Constant("World!")
        ),
    Expression.Constant(42)
)

Console.WriteLine("The result of executing the expression tree:")
' The following statement first creates an expression tree,
' then compiles it, and then executes it.           
Dim result = Expression.Lambda(Of Func(Of Integer))(blockExpr).Compile()()

' Print the expressions from the block expression.
Console.WriteLine("The expressions from the block expression:")
For Each expr In blockExpr.Expressions
    Console.WriteLine(expr.ToString())
Next

' Print the result of the tree execution.
Console.WriteLine("The return value of the block expression:")
Console.WriteLine(result)

' This code example produces the following output:
'
' The result of executing the expression tree:
' Hello World!

' The expressions from the block expression:
' Write("Hello ")
' WriteLine("World!")
' 42

' The return value of the block expression:
' 42

Constructeurs

Nom Description
Expression()

Construit une nouvelle instance de Expression.
Expression(ExpressionType, Type)
Obsolète.

Initialise une nouvelle instance de la classe Expression.

Propriétés

Nom Description
CanReduce

Indique que le nœud peut être réduit à un nœud plus simple. Si cela retourne la valeur true, Reduce() peut être appelé pour produire le formulaire réduit.
NodeType

Obtient le type de nœud de ce Expression.
Type

Obtient le type statique de l’expression que cela Expression représente.

Méthodes

Nom Description
Accept(ExpressionVisitor)

Répartit vers la méthode de visite spécifique pour ce type de nœud. Par exemple, MethodCallExpression appelle le VisitMethodCall(MethodCallExpression).
Add(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’ajout arithmétique qui n’a pas de vérification de dépassement de capacité. La méthode d’implémentation peut être spécifiée.
Add(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’ajout arithmétique qui n’a pas de vérification de dépassement de capacité.
AddAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui n’a pas de vérification de dépassement de capacité.
AddAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui n’a pas de vérification de dépassement de capacité.
AddAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui n’a pas de vérification de dépassement de capacité.
AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui a une vérification de dépassement de capacité.
AddAssignChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui a une vérification de dépassement de capacité.
AddAssignChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation d’addition qui a une vérification de dépassement de capacité.
AddChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’ajout arithmétique qui a une vérification de dépassement de capacité. La méthode d’implémentation peut être spécifiée.
AddChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’ajout arithmétique qui a une vérification de dépassement de capacité.
And(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération au niveau AND du bit. La méthode d’implémentation peut être spécifiée.
And(Expression, Expression)

Crée un BinaryExpression qui représente une opération au niveau AND du bit.
AndAlso(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération conditionnelle AND qui évalue le deuxième opérande uniquement si le premier opérande est résolu sur true. La méthode d’implémentation peut être spécifiée.
AndAlso(Expression, Expression)

Crée un BinaryExpression qui représente une opération conditionnelle AND qui évalue le deuxième opérande uniquement si le premier opérande prend truela valeur .
AndAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation AND au niveau du bit.
AndAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation AND au niveau du bit.
AndAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation AND au niveau du bit.
ArrayAccess(Expression, Expression[])

Crée un IndexExpression tableau pour accéder à un tableau.
ArrayAccess(Expression, IEnumerable<Expression>)

Crée un IndexExpression tableau multidimensionnel pour accéder à un tableau multidimensionnel.
ArrayIndex(Expression, Expression)

Crée un BinaryExpression qui représente l’application d’un opérateur d’index de tableau à un tableau de rang 1.
ArrayIndex(Expression, Expression[])

Crée un MethodCallExpression qui représente l’application d’un opérateur d’index de tableau à un tableau multidimensionnel.
ArrayIndex(Expression, IEnumerable<Expression>)

Crée un MethodCallExpression qui représente l’application d’un opérateur d’index de tableau à un tableau de rang plusieurs.
ArrayLength(Expression)

Crée une UnaryExpression expression qui représente une expression pour obtenir la longueur d’un tableau unidimensionnel.
Assign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation.
Bind(MemberInfo, Expression)

Crée un MemberAssignment qui représente l’initialisation d’un champ ou d’une propriété.
Bind(MethodInfo, Expression)

Crée un MemberAssignment qui représente l’initialisation d’un membre à l’aide d’une méthode d’accesseur de propriété.
Block(Expression, Expression, Expression, Expression, Expression)

Crée un BlockExpression qui contient cinq expressions et n’a aucune variable.
Block(Expression, Expression, Expression, Expression)

Crée un BlockExpression qui contient quatre expressions et n’a aucune variable.
Block(Expression, Expression, Expression)

Crée un BlockExpression qui contient trois expressions et n’a aucune variable.
Block(Expression, Expression)

Crée un BlockExpression qui contient deux expressions et n’a aucune variable.
Block(Expression[])

Crée un BlockExpression qui contient les expressions données et n’a aucune variable.
Block(IEnumerable<Expression>)

Crée un BlockExpression qui contient les expressions données et n’a aucune variable.
Block(IEnumerable<ParameterExpression>, Expression[])

Crée un BlockExpression qui contient les variables et expressions données.
Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Crée un BlockExpression qui contient les variables et expressions données.
Block(Type, Expression[])

Crée un BlockExpression qui contient les expressions données, n’a aucune variable et a un type de résultat spécifique.
Block(Type, IEnumerable<Expression>)

Crée un BlockExpression qui contient les expressions données, n’a aucune variable et a un type de résultat spécifique.
Block(Type, IEnumerable<ParameterExpression>, Expression[])

Crée un BlockExpression qui contient les variables et expressions données.
Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Crée un BlockExpression qui contient les variables et expressions données.
Break(LabelTarget, Expression, Type)

Crée une instruction représentant une GotoExpression instruction break avec le type spécifié. La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Break(LabelTarget, Expression)

Crée un représentant une GotoExpression instruction break. La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Break(LabelTarget, Type)

Crée une instruction représentant une GotoExpression instruction break avec le type spécifié.
Break(LabelTarget)

Crée un représentant une GotoExpression instruction break.
Call(Expression, MethodInfo, Expression, Expression, Expression)

Crée un MethodCallExpression appel à une méthode qui prend trois arguments.
Call(Expression, MethodInfo, Expression, Expression)

Crée un MethodCallExpression appel à une méthode qui prend deux arguments.
Call(Expression, MethodInfo, Expression[])

Crée un MethodCallExpression appel à une méthode qui prend des arguments.
Call(Expression, MethodInfo, IEnumerable<Expression>)

Crée un MethodCallExpression appel à une méthode qui prend des arguments.
Call(Expression, MethodInfo)

Crée un MethodCallExpression appel à une méthode qui ne prend aucun argument.
Call(Expression, String, Type[], Expression[])

Crée un MethodCallExpression appel qui représente un appel à une méthode en appelant la méthode de fabrique appropriée.
Call(MethodInfo, Expression, Expression, Expression, Expression, Expression)

Crée un MethodCallExpression appel à une méthode statique qui prend cinq arguments.
Call(MethodInfo, Expression, Expression, Expression, Expression)

Crée un MethodCallExpression appel à une méthode statique qui prend quatre arguments.
Call(MethodInfo, Expression, Expression, Expression)

Crée un MethodCallExpression appel à une méthode statique qui prend trois arguments.
Call(MethodInfo, Expression, Expression)

Crée un MethodCallExpression appel à une méthode statique qui prend deux arguments.
Call(MethodInfo, Expression)

Crée un MethodCallExpression appel à une static méthode (Shared en Visual Basic) qui accepte un argument.
Call(MethodInfo, Expression[])

Crée un MethodCallExpression qui représente un appel à une static méthode (Shared en Visual Basic) qui a des arguments.
Call(MethodInfo, IEnumerable<Expression>)

Crée un MethodCallExpression appel à une méthode statique (partagée en Visual Basic).
Call(Type, String, Type[], Expression[])

Crée un MethodCallExpression appel à une static méthode (Shared en Visual Basic) en appelant la méthode de fabrique appropriée.
Catch(ParameterExpression, Expression, Expression)

Crée une représentation d’une CatchBlock instruction catch avec un Exception filtre et une référence à l’objet intercepté Exception .
Catch(ParameterExpression, Expression)

Crée une instruction catch représentant une CatchBlock référence à l’objet intercepté Exception à utiliser dans le corps du gestionnaire.
Catch(Type, Expression, Expression)

Crée une instruction catch représentant une CatchBlock instruction catch avec un Exception filtre, mais aucune référence à l’objet intercepté Exception .
Catch(Type, Expression)

Crée un représentant une CatchBlock instruction catch.
ClearDebugInfo(SymbolDocumentInfo)

Crée un DebugInfoExpression élément permettant d’effacer un point de séquence.
Coalesce(Expression, Expression, LambdaExpression)

Crée un BinaryExpression qui représente une opération de fusion, en fonction d’une fonction de conversion.
Coalesce(Expression, Expression)

Crée un BinaryExpression qui représente une opération de fusion.
Condition(Expression, Expression, Expression, Type)

Crée une ConditionalExpression instruction conditionnelle qui représente une instruction conditionnelle.
Condition(Expression, Expression, Expression)

Crée une ConditionalExpression instruction conditionnelle qui représente une instruction conditionnelle.
Constant(Object, Type)

Crée un ConstantExpression qui a la Value valeur et Type les propriétés définies sur les valeurs spécifiées.
Constant(Object)

Crée une ConstantExpression propriété définie Value sur la valeur spécifiée.
Continue(LabelTarget, Type)

Crée un représentant une GotoExpression instruction continue avec le type spécifié.
Continue(LabelTarget)

Crée une GotoExpression instruction continue représentant une instruction continue.
Convert(Expression, Type, MethodInfo)

Crée un UnaryExpression qui représente une opération de conversion pour laquelle la méthode d’implémentation est spécifiée.
Convert(Expression, Type)

Crée un UnaryExpression qui représente une opération de conversion de type.
ConvertChecked(Expression, Type, MethodInfo)

Crée un UnaryExpression qui représente une opération de conversion qui lève une exception si le type cible est dépassé et pour lequel la méthode d’implémentation est spécifiée.
ConvertChecked(Expression, Type)

Crée un UnaryExpression qui représente une opération de conversion qui lève une exception si le type cible est dépassé.
DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32)

Crée une DebugInfoExpression étendue avec l’étendue spécifiée.
Decrement(Expression, MethodInfo)

Crée un UnaryExpression qui représente la décrémentation de l’expression par 1.
Decrement(Expression)

Crée un UnaryExpression qui représente la décrémentation de l’expression par 1.
Default(Type)

Crée une DefaultExpression propriété définie Type sur le type spécifié.
Divide(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de division arithmétique. La méthode d’implémentation peut être spécifiée.
Divide(Expression, Expression)

Crée un BinaryExpression qui représente une opération de division arithmétique.
DivideAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de division qui n’a pas de vérification de dépassement de capacité.
DivideAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de division qui n’a pas de vérification de dépassement de capacité.
DivideAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de division qui n’a pas de vérification de dépassement de capacité.
Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression[])

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
Dynamic(CallSiteBinder, Type, IEnumerable<Expression>)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
ElementInit(MethodInfo, Expression[])

Crée un ElementInittableau de valeurs donné en tant que deuxième argument.
ElementInit(MethodInfo, IEnumerable<Expression>)

Crée un ElementInitargument , donné IEnumerable<T> comme deuxième argument.
Empty()

Crée une expression vide qui a Void le type.
Equal(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison d’égalité. La méthode d’implémentation peut être spécifiée.
Equal(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d’égalité.
Equals(Object)

Détermine si l’objet spécifié est égal à l’objet actuel.

(Hérité de Object)
ExclusiveOr(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération au niveau XOR du bit, à l’aide op_ExclusiveOr de types définis par l’utilisateur. La méthode d’implémentation peut être spécifiée.
ExclusiveOr(Expression, Expression)

Crée un BinaryExpression qui représente une opération au niveau XOR du bit, à l’aide op_ExclusiveOr de types définis par l’utilisateur.
ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation XOR au niveau du bit, à l’aide op_ExclusiveOr de types définis par l’utilisateur.
ExclusiveOrAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation XOR au niveau du bit, à l’aide op_ExclusiveOr de types définis par l’utilisateur.
ExclusiveOrAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation XOR au niveau du bit, à l’aide op_ExclusiveOr de types définis par l’utilisateur.
Field(Expression, FieldInfo)

Crée un MemberExpression qui représente l’accès à un champ.
Field(Expression, String)

Crée un MemberExpression champ qui représente l’accès à un champ en fonction du nom du champ.
Field(Expression, Type, String)

Crée un MemberExpression qui représente l’accès à un champ.
GetActionType(Type[])

Crée un objet qui représente un Type type délégué générique Action qui a des arguments de type spécifiques.
GetDelegateType(Type[])

Obtient un objet qui représente un Type type générique Func<TResult> ou Action délégué qui a des arguments de type spécifiques.
GetFuncType(Type[])

Crée un objet qui représente un Type type délégué générique Func<TResult> qui a des arguments de type spécifiques. Le dernier argument de type spécifie le type de retour du délégué créé.
GetHashCode()

Sert de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient la Type de l’instance actuelle.

(Hérité de Object)
Goto(LabelTarget, Expression, Type)

Crée une instruction représentant une GotoExpression instruction « go to » avec le type spécifié. La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Goto(LabelTarget, Expression)

Crée une instruction représentant une GotoExpression instruction « go to ». La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Goto(LabelTarget, Type)

Crée une instruction représentant une GotoExpression instruction « go to » avec le type spécifié.
Goto(LabelTarget)

Crée une instruction représentant une GotoExpression instruction « go to ».
GreaterThan(Expression, Expression, Boolean, MethodInfo)

Crée une BinaryExpression comparaison numérique « supérieure à ». La méthode d’implémentation peut être spécifiée.
GreaterThan(Expression, Expression)

Crée une BinaryExpression comparaison numérique « supérieure à ».
GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Crée une BinaryExpression comparaison numérique « supérieure ou égale ».
GreaterThanOrEqual(Expression, Expression)

Crée une BinaryExpression comparaison numérique « supérieure ou égale ».
IfThen(Expression, Expression)

Crée un ConditionalExpression bloc conditionnel avec une if instruction.
IfThenElse(Expression, Expression, Expression)

Crée un ConditionalExpression bloc conditionnel avec if et else des instructions.
Increment(Expression, MethodInfo)

Crée un UnaryExpression qui représente l’incrémentation de l’expression par 1.
Increment(Expression)

Crée un UnaryExpression qui représente l’incrémentation de la valeur d’expression par 1.
Invoke(Expression, Expression[])

Crée un InvocationExpression délégué ou une expression lambda à une liste d’expressions d’argument.
Invoke(Expression, IEnumerable<Expression>)

Crée un InvocationExpression délégué ou une expression lambda à une liste d’expressions d’argument.
IsFalse(Expression, MethodInfo)

Retourne si l’expression prend la valeur false.
IsFalse(Expression)

Retourne si l’expression prend la valeur false.
IsTrue(Expression, MethodInfo)

Retourne si l’expression prend la valeur true.
IsTrue(Expression)

Retourne si l’expression prend la valeur true.
Label()

Crée une étiquette représentant un LabelTarget type void et aucun nom.
Label(LabelTarget, Expression)

Crée une étiquette représentant une LabelExpression étiquette avec la valeur par défaut donnée.
Label(LabelTarget)

Crée une représentation d’une LabelExpression étiquette sans valeur par défaut.
Label(String)

Crée une étiquette représentant un LabelTarget type void et le nom donné.
Label(Type, String)

Crée une LabelTarget étiquette représentant un type et un nom donnés.
Label(Type)

Crée une étiquette représentant un LabelTarget type donné.
Lambda(Expression, Boolean, IEnumerable<ParameterExpression>)

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression, un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Expression, Boolean, ParameterExpression[])

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression, un paramètre qui indique si l’optimisation des appels de fin sera appliquée et un tableau d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Expression, IEnumerable<ParameterExpression>)

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression et une collection énumérable d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Expression, ParameterExpression[])

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression et un tableau d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>)

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression, le nom de l’expression lambda, un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Expression, String, IEnumerable<ParameterExpression>)

Crée un LambdaExpression premier type de délégué à partir du corps de l’expression, du nom de l’expression lambda et d’une collection énumérable d’expressions de paramètre. Il peut être utilisé lorsque le type de délégué n’est pas connu au moment de la compilation.
Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>)

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre.
Lambda(Type, Expression, Boolean, ParameterExpression[])

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec un paramètre qui indique si l’optimisation des appels de fin sera appliquée et un tableau d’expressions de paramètre.
Lambda(Type, Expression, IEnumerable<ParameterExpression>)

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec une collection énumérable d’expressions de paramètre.
Lambda(Type, Expression, ParameterExpression[])

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec un tableau d’expressions de paramètre.
Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>)

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec le nom de l’expression lambda, un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre.
Lambda(Type, Expression, String, IEnumerable<ParameterExpression>)

Crée un LambdaExpression emplacement où le type délégué est connu au moment de la compilation, avec le nom de l’expression lambda et une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>)

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, Boolean, ParameterExpression[])

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec un paramètre qui indique si l’optimisation des appels de fin sera appliquée et un tableau d’expressions de paramètre.
Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, ParameterExpression[])

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec un tableau d’expressions de paramètre.
Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>)

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec le nom de l’expression lambda, un paramètre qui indique si l’optimisation des appels de fin sera appliquée et une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>)

Crée un Expression<TDelegate> emplacement où le type délégué est connu au moment de la compilation, avec le nom de l’expression lambda et une collection énumérable d’expressions de paramètre.
LeftShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression élément qui représente une opération de décalage gauche au niveau du bit.
LeftShift(Expression, Expression)

Crée un BinaryExpression élément qui représente une opération de décalage gauche au niveau du bit.
LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de décalage gauche au niveau du bit.
LeftShiftAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de décalage gauche au niveau du bit.
LeftShiftAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de décalage gauche au niveau du bit.
LessThan(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « inférieure à ».
LessThan(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « inférieure à ».
LessThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « inférieure ou égale ».
LessThanOrEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « inférieure ou égale ».
ListBind(MemberInfo, ElementInit[])

Crée un MemberListBinding emplacement où le membre est un champ ou une propriété.
ListBind(MemberInfo, IEnumerable<ElementInit>)

Crée un MemberListBinding emplacement où le membre est un champ ou une propriété.
ListBind(MethodInfo, ElementInit[])

Crée un MemberListBinding objet basé sur une méthode d’accesseur de propriété spécifiée.
ListBind(MethodInfo, IEnumerable<ElementInit>)

Crée une MemberListBinding méthode d’accesseur de propriété spécifiée.
ListInit(NewExpression, ElementInit[])

Crée un ListInitExpression objet qui utilise des objets spécifiés ElementInit pour initialiser une collection.
ListInit(NewExpression, Expression[])

Crée une ListInitExpression méthode nommée « Add » pour ajouter des éléments à une collection.
ListInit(NewExpression, IEnumerable<ElementInit>)

Crée un ListInitExpression objet qui utilise des objets spécifiés ElementInit pour initialiser une collection.
ListInit(NewExpression, IEnumerable<Expression>)

Crée une ListInitExpression méthode nommée « Add » pour ajouter des éléments à une collection.
ListInit(NewExpression, MethodInfo, Expression[])

Crée une ListInitExpression méthode qui utilise une méthode spécifiée pour ajouter des éléments à une collection.
ListInit(NewExpression, MethodInfo, IEnumerable<Expression>)

Crée une ListInitExpression méthode qui utilise une méthode spécifiée pour ajouter des éléments à une collection.
Loop(Expression, LabelTarget, LabelTarget)

Crée un LoopExpression corps donné.
Loop(Expression, LabelTarget)

Crée un corps et une LoopExpression cible d’arrêt donnés.
Loop(Expression)

Crée un LoopExpression corps donné.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression)

Crée un BinaryExpressionopérande gauche, un opérande de droite, une méthode d’implémentation et une fonction de conversion de type, en appelant la méthode de fabrique appropriée.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo)

Crée un opérande de gauche, un BinaryExpressionopérande de droite et une méthode d’implémentation en appelant la méthode de fabrique appropriée.
MakeBinary(ExpressionType, Expression, Expression)

Crée un BinaryExpressionopérande de gauche et de droite en appelant une méthode de fabrique appropriée.
MakeCatchBlock(Type, ParameterExpression, Expression, Expression)

Crée une CatchBlock instruction catch représentant les éléments spécifiés.
MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par les arguments fournis CallSiteBinder et quatre.
MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par les arguments fournis CallSiteBinder et trois.
MakeDynamic(Type, CallSiteBinder, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par les arguments fournis CallSiteBinder et deux.
MakeDynamic(Type, CallSiteBinder, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par l’argument fourni CallSiteBinder et un argument.
MakeDynamic(Type, CallSiteBinder, Expression[])

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>)

Crée un DynamicExpression qui représente une opération dynamique liée par le fichier fourni CallSiteBinder.
MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type)

Crée un représentant un GotoExpression saut du fichier spécifié GotoExpressionKind. La valeur passée à l’étiquette lors du saut peut également être spécifiée.
MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>)

Crée un IndexExpression qui représente l’accès à une propriété indexée dans un objet.
MakeMemberAccess(Expression, MemberInfo)

Crée un MemberExpression qui représente l’accès à un champ ou à une propriété.
MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>)

Crée un TryExpression bloc try représentant un bloc try avec les éléments spécifiés.
MakeUnary(ExpressionType, Expression, Type, MethodInfo)

Crée une UnaryExpressionméthode d’opérande et d’implémentation donnée en appelant la méthode de fabrique appropriée.
MakeUnary(ExpressionType, Expression, Type)

Crée un UnaryExpressionopérande , donné, en appelant la méthode de fabrique appropriée.
MemberBind(MemberInfo, IEnumerable<MemberBinding>)

Crée un MemberMemberBinding qui représente l’initialisation récursive des membres d’un champ ou d’une propriété.
MemberBind(MemberInfo, MemberBinding[])

Crée un MemberMemberBinding qui représente l’initialisation récursive des membres d’un champ ou d’une propriété.
MemberBind(MethodInfo, IEnumerable<MemberBinding>)

Crée un MemberMemberBinding qui représente l’initialisation récursive des membres d’un membre accessible à l’aide d’une méthode d’accesseur de propriété.
MemberBind(MethodInfo, MemberBinding[])

Crée un MemberMemberBinding qui représente l’initialisation récursive des membres d’un membre accessible à l’aide d’une méthode d’accesseur de propriété.
MemberInit(NewExpression, IEnumerable<MemberBinding>)

Représente une expression qui crée un objet et initialise une propriété de l’objet.
MemberInit(NewExpression, MemberBinding[])

Crée un MemberInitExpression.
MemberwiseClone()

Crée une copie superficielle du Objectactuel.

(Hérité de Object)
Modulo(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de reste arithmétique.
Modulo(Expression, Expression)

Crée un BinaryExpression qui représente une opération de reste arithmétique.
ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de reste.
ModuloAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de reste.
ModuloAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de reste.
Multiply(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui n’a pas de vérification de dépassement de capacité.
Multiply(Expression, Expression)

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui n’a pas de vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui n’a pas de vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui n’a pas de vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui n’a pas de vérification de dépassement de capacité.
MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui a une vérification de dépassement de capacité.
MultiplyAssignChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui a une vérification de dépassement de capacité.
MultiplyAssignChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de multiplication qui a une vérification de dépassement de capacité.
MultiplyChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui a une vérification de dépassement de capacité.
MultiplyChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui a une vérification de dépassement de capacité.
Negate(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération de négation arithmétique.
Negate(Expression)

Crée un UnaryExpression qui représente une opération de négation arithmétique.
NegateChecked(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération de négation arithmétique qui a une vérification de dépassement de capacité. La méthode d’implémentation peut être spécifiée.
NegateChecked(Expression)

Crée un UnaryExpression qui représente une opération de négation arithmétique qui a une vérification de dépassement de capacité.
New(ConstructorInfo, Expression[])

Crée un NewExpression qui représente l’appel du constructeur spécifié avec les arguments spécifiés.
New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>)

Crée un NewExpression qui représente l’appel du constructeur spécifié avec les arguments spécifiés. Les membres qui accèdent aux champs initialisés du constructeur sont spécifiés.
New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[])

Crée un NewExpression qui représente l’appel du constructeur spécifié avec les arguments spécifiés. Les membres qui accèdent aux champs initialisés du constructeur sont spécifiés en tant que tableau.
New(ConstructorInfo, IEnumerable<Expression>)

Crée un NewExpression qui représente l’appel du constructeur spécifié avec les arguments spécifiés.
New(ConstructorInfo)

Crée un NewExpression qui représente l’appel du constructeur spécifié qui ne prend aucun argument.
New(Type)

Crée un NewExpression qui représente l’appel du constructeur sans paramètre du type spécifié.
NewArrayBounds(Type, Expression[])

Crée un NewArrayExpression tableau qui représente la création d’un tableau dont le rang est spécifié.
NewArrayBounds(Type, IEnumerable<Expression>)

Crée un NewArrayExpression tableau qui représente la création d’un tableau dont le rang est spécifié.
NewArrayInit(Type, Expression[])

Crée un NewArrayExpression tableau unidimensionnel qui représente la création d’un tableau unidimensionnel et l’initialise à partir d’une liste d’éléments.
NewArrayInit(Type, IEnumerable<Expression>)

Crée un NewArrayExpression tableau unidimensionnel qui représente la création d’un tableau unidimensionnel et l’initialise à partir d’une liste d’éléments.
Not(Expression, MethodInfo)

Crée un UnaryExpression élément qui représente une opération de complément au niveau du bit. La méthode d’implémentation peut être spécifiée.
Not(Expression)

Crée un UnaryExpression élément qui représente une opération de complément au niveau du bit.
NotEqual(Expression, Expression, Boolean, MethodInfo)

Crée une BinaryExpression comparaison d’inégalités.
NotEqual(Expression, Expression)

Crée une BinaryExpression comparaison d’inégalités.
OnesComplement(Expression, MethodInfo)

Retourne l’expression représentant le complément.
OnesComplement(Expression)

Retourne l’expression représentant le complément.
Or(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération au niveau OR du bit.
Or(Expression, Expression)

Crée un BinaryExpression qui représente une opération au niveau OR du bit.
OrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation OR au niveau du bit.
OrAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation OR au niveau du bit.
OrAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation OR au niveau du bit.
OrElse(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération conditionnelle OR qui évalue le deuxième opérande uniquement si le premier opérande prend falsela valeur .
OrElse(Expression, Expression)

Crée un BinaryExpression qui représente une opération conditionnelle OR qui évalue le deuxième opérande uniquement si le premier opérande prend falsela valeur .
Parameter(Type, String)

Crée un ParameterExpression nœud qui peut être utilisé pour identifier un paramètre ou une variable dans une arborescence d’expressions.
Parameter(Type)

Crée un ParameterExpression nœud qui peut être utilisé pour identifier un paramètre ou une variable dans une arborescence d’expressions.
PostDecrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui représente l’affectation de l’expression suivie d’une décrémentation ultérieure par 1 de l’expression d’origine.
PostDecrementAssign(Expression)

Crée un UnaryExpression qui représente l’affectation de l’expression suivie d’une décrémentation ultérieure par 1 de l’expression d’origine.
PostIncrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui représente l’affectation de l’expression suivie d’un incrément suivant par 1 de l’expression d’origine.
PostIncrementAssign(Expression)

Crée un UnaryExpression qui représente l’affectation de l’expression suivie d’un incrément suivant par 1 de l’expression d’origine.
Power(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente l’élévation d’un nombre à une puissance.
Power(Expression, Expression)

Crée un BinaryExpression qui représente l’élévation d’un nombre à une puissance.
PowerAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente l’élévation d’une expression à une puissance et l’affectation du résultat à l’expression.
PowerAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente l’élévation d’une expression à une puissance et l’affectation du résultat à l’expression.
PowerAssign(Expression, Expression)

Crée un BinaryExpression qui représente l’élévation d’une expression à une puissance et l’affectation du résultat à l’expression.
PreDecrementAssign(Expression, MethodInfo)

Crée une UnaryExpression valeur qui décrémente l’expression par 1 et affecte le résultat à l’expression.
PreDecrementAssign(Expression)

Crée une UnaryExpression valeur qui décrémente l’expression par 1 et affecte le résultat à l’expression.
PreIncrementAssign(Expression, MethodInfo)

Crée un UnaryExpression élément qui incrémente l’expression de 1 et affecte le résultat à l’expression.
PreIncrementAssign(Expression)

Crée un UnaryExpression élément qui incrémente l’expression de 1 et affecte le résultat à l’expression.
Property(Expression, MethodInfo)

Crée un MemberExpression qui représente l’accès à une propriété à l’aide d’une méthode d’accesseur de propriété.
Property(Expression, PropertyInfo, Expression[])

Crée un IndexExpression représentant l’accès à une propriété indexée.
Property(Expression, PropertyInfo, IEnumerable<Expression>)

Crée un IndexExpression représentant l’accès à une propriété indexée.
Property(Expression, PropertyInfo)

Crée un MemberExpression qui représente l’accès à une propriété.
Property(Expression, String, Expression[])

Crée un IndexExpression représentant l’accès à une propriété indexée.
Property(Expression, String)

Crée un MemberExpression qui représente l’accès à une propriété.
Property(Expression, Type, String)

Crée un MemberExpression accès à une propriété.
PropertyOrField(Expression, String)

Crée un MemberExpression qui représente l’accès à une propriété ou à un champ.
Quote(Expression)

Crée un UnaryExpression qui représente une expression qui a une valeur constante de type Expression.
Reduce()

Réduit ce nœud à une expression plus simple. Si CanReduce retourne true, cela doit renvoyer une expression valide. Cette méthode peut retourner un autre nœud qui lui-même doit être réduit.
ReduceAndCheck()

Réduit ce nœud à une expression plus simple. Si CanReduce retourne true, cela doit renvoyer une expression valide. Cette méthode peut retourner un autre nœud qui lui-même doit être réduit.
ReduceExtensions()

Réduit l’expression à un type de nœud connu (qui n’est pas un nœud d’extension) ou retourne simplement l’expression s’il s’agit déjà d’un type connu.
ReferenceEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d’égalité de référence.
ReferenceNotEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison des inégalités de référence.
Rethrow()

Crée un UnaryExpression qui représente une nouvelle croissance d’une exception.
Rethrow(Type)

Crée un UnaryExpression qui représente une nouvelle croissance d’une exception avec un type donné.
Return(LabelTarget, Expression, Type)

Crée une instruction représentant une GotoExpression instruction return avec le type spécifié. La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Return(LabelTarget, Expression)

Crée un représentant une GotoExpression instruction return. La valeur transmise à l’étiquette lors du saut peut être spécifiée.
Return(LabelTarget, Type)

Crée une instruction représentant une GotoExpression instruction return avec le type spécifié.
Return(LabelTarget)

Crée un représentant une GotoExpression instruction return.
RightShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de décalage droit au niveau du bit.
RightShift(Expression, Expression)

Crée un BinaryExpression qui représente une opération de décalage droit au niveau du bit.
RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de décalage droit au niveau du bit.
RightShiftAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de décalage droit au niveau du bit.
RightShiftAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de décalage droit au niveau du bit.
RuntimeVariables(IEnumerable<ParameterExpression>)

Crée une instance de RuntimeVariablesExpression.
RuntimeVariables(ParameterExpression[])

Crée une instance de RuntimeVariablesExpression.
Subtract(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui n’a pas de vérification de dépassement de capacité.
Subtract(Expression, Expression)

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui n’a pas de vérification de dépassement de capacité.
SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui n’a pas de vérification de dépassement de capacité.
SubtractAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui n’a pas de vérification de dépassement de capacité.
SubtractAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui n’a pas de vérification de dépassement de capacité.
SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui a une vérification de dépassement de capacité.
SubtractAssignChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui a une vérification de dépassement de capacité.
SubtractAssignChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’affectation de soustraction qui a une vérification de dépassement de capacité.
SubtractChecked(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui a une vérification de dépassement de capacité.
SubtractChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui a une vérification de dépassement de capacité.
Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Crée un SwitchExpression qui représente une switch instruction qui a un cas par défaut.
Switch(Expression, Expression, MethodInfo, SwitchCase[])

Crée un SwitchExpression qui représente une switch instruction qui a un cas par défaut.
Switch(Expression, Expression, SwitchCase[])

Crée un SwitchExpression qui représente une switch instruction qui a un cas par défaut.
Switch(Expression, SwitchCase[])

Crée une instruction qui représente une SwitchExpressionswitch instruction sans cas par défaut.
Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Crée un SwitchExpression qui représente une switch instruction qui a un cas par défaut.
Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])

Crée un SwitchExpression qui représente une switch instruction qui a un cas par défaut.
SwitchCase(Expression, Expression[])

Crée une SwitchCase utilisation dans un SwitchExpression.
SwitchCase(Expression, IEnumerable<Expression>)

Crée un SwitchCase objet à utiliser dans un SwitchExpression objet.
SymbolDocument(String, Guid, Guid, Guid)

Crée une instance de SymbolDocumentInfo.
SymbolDocument(String, Guid, Guid)

Crée une instance de SymbolDocumentInfo.
SymbolDocument(String, Guid)

Crée une instance de SymbolDocumentInfo.
SymbolDocument(String)

Crée une instance de SymbolDocumentInfo.
Throw(Expression, Type)

Crée un UnaryExpression qui représente une levée d’une exception avec un type donné.
Throw(Expression)

Crée un UnaryExpression qui représente une levée d’une exception.
ToString()

Retourne une représentation textuelle du Expression.
TryCatch(Expression, CatchBlock[])

Crée un bloc try représentant un TryExpression nombre quelconque d’instructions catch et ni une erreur ni un bloc final.
TryCatchFinally(Expression, Expression, CatchBlock[])

Crée un bloc try représentant un TryExpression nombre quelconque d’instructions catch et un bloc final.
TryFault(Expression, Expression)

Crée un représentant un TryExpression bloc try avec un bloc d’erreur et aucune instruction catch.
TryFinally(Expression, Expression)

Crée un TryExpression bloc try représentant un bloc try avec un bloc final et aucune instruction catch.
TryGetActionType(Type[], Type)

Crée un objet qui représente un Type type délégué System.Action générique qui a des arguments de type spécifiques.
TryGetFuncType(Type[], Type)

Crée un objet qui représente un Type type de délégué System.Func générique qui a des arguments de type spécifiques. Le dernier argument de type spécifie le type de retour du délégué créé.
TypeAs(Expression, Type)

Crée un qui représente une UnaryExpression conversion de référence ou de boxe explicite où null elle est fournie en cas d’échec de la conversion.
TypeEqual(Expression, Type)

Crée une TypeBinaryExpression identité de type d’exécution qui compare l’identité de type d’exécution.
TypeIs(Expression, Type)

Crée un TypeBinaryExpression.
UnaryPlus(Expression, MethodInfo)

Crée un UnaryExpression élément qui représente une opération plus unaire.
UnaryPlus(Expression)

Crée un UnaryExpression élément qui représente une opération plus unaire.
Unbox(Expression, Type)

Crée un UnaryExpression qui représente un unboxing explicite.
Variable(Type, String)

Crée un ParameterExpression nœud qui peut être utilisé pour identifier un paramètre ou une variable dans une arborescence d’expressions.
Variable(Type)

Crée un ParameterExpression nœud qui peut être utilisé pour identifier un paramètre ou une variable dans une arborescence d’expressions.
VisitChildren(ExpressionVisitor)

Réduit le nœud, puis appelle le délégué visiteur sur l’expression réduite. La méthode lève une exception si le nœud n’est pas réductible.

S’applique à