Expression Classe

  • Référence

Définition

Espace de noms:
System.Linq.Expressions
Assembly:
System.Linq.Expressions.dll
Assembly:
System.Core.dll
Assembly:
netstandard.dll
Source:
Expression.cs
Source:
Expression.cs
Source:
Expression.cs

Fournit la classe de base de laquelle sont dérivées les classes qui représentent des nœuds d'arborescence d'expression. Contient également des méthodes de fabrique static (Shared en Visual Basic) pour créer les divers types de nœuds. Il s'agit d'une classe abstract.

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

Expression()

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

Initialise une nouvelle instance de la classe Expression.

Propriétés

CanReduce

Indique que le nœud peut être réduit à un nœud plus simple. Si la valeur retournée est true, Reduce() peut être appelé pour produire la forme réduite.
NodeType

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

Obtient le type statique de l'expression que ce Expression représente.

Méthodes

Accept(ExpressionVisitor)

Distribue à la méthode de visite spécifique à ce type de nœud. Par exemple, MethodCallExpression appelle VisitMethodCall(MethodCallExpression).
Add(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'addition arithmétique qui ne dispose pas d'une vérification de dépassement de capacité.
Add(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'addition arithmétique qui ne dispose pas d'une vérification de dépassement de capacité. La méthode d'implémentation peut être spécifiée.
AddAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation d'addition qui ne dispose pas d'une vérification de dépassement de capacité.
AddAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation d'addition qui ne dispose pas d'une vérification de dépassement de capacité.
AddAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation d'addition qui ne dispose pas d'une vérification de dépassement de capacité.
AddAssignChecked(Expression, Expression)

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

Crée un BinaryExpression qui représente une opération d'assignation d'addition qui dispose d'une vérification de dépassement de capacité.
AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation d'addition qui dispose d'une vérification de dépassement de capacité.
AddChecked(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'addition arithmétique qui dispose d'une vérification de dépassement de capacité.
AddChecked(Expression, Expression, MethodInfo)

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

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

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

Crée un BinaryExpression qui représente une opération AND conditionnelle évaluant la deuxième opérande uniquement si la première opérande a la valeur true.
AndAlso(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération AND conditionnelle évaluant la deuxième opérande uniquement si la première opérande a la valeur true. La méthode d'implémentation peut être spécifiée.
AndAssign(Expression, Expression)

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

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

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

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

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

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

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

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

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

Crée un BinaryExpression qui représente une opération d'assignation.
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)

Crée un BlockExpression qui contient deux expressions et aucune variable.
Block(Expression, Expression, Expression)

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

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

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

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

Crée un BlockExpression qui contient les expressions données et 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, 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, 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)

Crée un GotoExpression qui représente une instruction Break.
Break(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction Break. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Break(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction Break avec le type spécifié. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Break(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Break avec le type spécifié.
Call(Expression, MethodInfo)

Crée un MethodCallExpression qui représente un appel à une méthode qui ne prend aucun argument.
Call(Expression, MethodInfo, Expression, Expression)

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

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

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

Crée un MethodCallExpression qui représente un appel à une méthode qui prend des arguments.
Call(Expression, String, Type[], Expression[])

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

Crée un MethodCallExpression qui représente un appel à une méthode static (Shared en Visual Basic) qui prend un seul argument.
Call(MethodInfo, Expression, Expression)

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

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

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

Crée un MethodCallExpression qui représente un appel à une méthode statique prenant cinq arguments.
Call(MethodInfo, Expression[])

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

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

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

Crée un CatchBlock qui représente une instruction Catch avec une référence à l'objet Exception intercepté pour une utilisation dans le corps du gestionnaire.
Catch(ParameterExpression, Expression, Expression)

Crée un CatchBlock qui représente une instruction Catch avec un filtre Exception et une référence à l'objet Exception intercepté.
Catch(Type, Expression)

Crée un CatchBlock qui représente une instruction Catch.
Catch(Type, Expression, Expression)

Crée un CatchBlock qui représente une instruction Catch avec un filtre Exception, sans référence à l'objet Exception intercepté.
ClearDebugInfo(SymbolDocumentInfo)

Crée un DebugInfoExpression pour la suppression d'un point de séquence.
Coalesce(Expression, Expression)

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

Crée un BinaryExpression qui représente une opération de fusion, à partir d'une fonction de conversion.
Condition(Expression, Expression, Expression)

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

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

Crée un ConstantExpression dont la propriété Value a la valeur spécifiée.
Constant(Object, Type)

Crée un ConstantExpression dont les propriétés Value et Type ont les valeurs spécifiées.
Continue(LabelTarget)

Crée un GotoExpression qui représente une instruction Continue.
Continue(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Continue avec le type spécifié.
Convert(Expression, Type)

Crée un UnaryExpression qui représente une opération de conversion de type.
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.
ConvertChecked(Expression, Type)

Crée un UnaryExpression qui représente une opération de conversion qui lève une exception en cas de dépassement du type cible.
ConvertChecked(Expression, Type, MethodInfo)

Crée un UnaryExpression qui représente une opération de conversion qui lève une exception en cas de dépassement du type cible et pour lequel la méthode d'implémentation est spécifiée.
DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32)

Crée un DebugInfoExpression avec l'étendue spécifiée.
Decrement(Expression)

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

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

Crée un DefaultExpression dont la propriété Type a le type spécifié.
Divide(Expression, Expression)

Crée un BinaryExpression qui représente une opération de division arithmétique.
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.
DivideAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation de division qui ne dispose pas d'une vérification de dépassement de capacité.
DivideAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation de division qui ne dispose pas d'une vérification de dépassement de capacité.
DivideAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de division qui ne dispose pas d'une vérification de dépassement de capacité.
Dynamic(CallSiteBinder, Type, Expression)

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

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

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

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

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

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

Crée un ElementInit, à partir d'un tableau de valeurs comme deuxième argument.
ElementInit(MethodInfo, IEnumerable<Expression>)

Crée un ElementInit, à partir d'un IEnumerable<T> comme deuxième argument.
Empty()

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

Crée un BinaryExpression qui représente une comparaison d'égalité.
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.
Equals(Object)

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

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

Crée un BinaryExpression qui représente une opération XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l'utilisateur.
ExclusiveOr(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l'utilisateur. La méthode d'implémentation peut être spécifiée.
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 pour les 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 pour les 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 pour les 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 qui représente l'accès à un champ à partir 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 Type objet qui représente un type délégué générique Action qui a des arguments de type spécifiques.
GetDelegateType(Type[])

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

Crée un Type objet qui représente un 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()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
Goto(LabelTarget)

Crée un GotoExpression qui représente une instruction GoTo.
Goto(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction GoTo. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Goto(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction GoTo avec le type spécifié. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Goto(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction GoTo avec le type spécifié.
GreaterThan(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur à ».
GreaterThan(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur à ». La méthode d'implémentation peut être spécifiée.
GreaterThanOrEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur ou égal à ».
GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur ou égal à ».
IfThen(Expression, Expression)

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

Crée un ConditionalExpression qui représente un bloc conditionnel avec des instructions if et else.
Increment(Expression)

Crée un UnaryExpression qui représente l'incrémentation de la valeur de l'expression par 1.
Increment(Expression, MethodInfo)

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

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

Crée un InvocationExpression qui applique un délégué ou une expression lambda à une liste d'expressions d'arguments.
IsFalse(Expression)

Indique si l'expression prend la valeur false.
IsFalse(Expression, MethodInfo)

Indique si l'expression prend la valeur false.
IsTrue(Expression)

Indique si l'expression prend la valeur true.
IsTrue(Expression, MethodInfo)

Indique si l'expression prend la valeur true.
Label()

Crée un LabelTarget qui représente une étiquette avec le type void et aucun nom.
Label(LabelTarget)

Crée un LabelExpression qui représente une étiquette sans valeur par défaut.
Label(LabelTarget, Expression)

Crée un LabelExpression qui représente une étiquette avec la valeur par défaut donnée.
Label(String)

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

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

Crée un LabelTarget qui représente une étiquette avec le type et le nom donnés.
Lambda(Expression, Boolean, IEnumerable<ParameterExpression>)

Crée un LambdaExpression en commençant par construire un type de délégué à partir du corps d’expression, un paramètre qui indique si l’optimisation d’appel tail est appliquée et une collection énumérable d’expressions de paramètre. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.
Lambda(Expression, Boolean, ParameterExpression[])

Crée un LambdaExpression en commençant par construire un type de délégué à partir du corps d’expression, un paramètre qui indique si l’optimisation d’appel tail est appliquée et un tableau d’expressions de paramètre. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.
Lambda(Expression, IEnumerable<ParameterExpression>)

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

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

Crée un LambdaExpression en commençant par construire un type de délégué à partir du corps d’expression, le nom de l’expression lambda, un paramètre qui indique si l’optimisation d’appel tail est appliquée et une collection énumérable d’expressions de paramètre. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.
Lambda(Expression, String, IEnumerable<ParameterExpression>)

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

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

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

Crée un LambdaExpression où le type de 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 où le type de 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 où le type de 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 d’appel tail est appliquée et une collection énumérable d’expressions de paramètre.
Lambda(Type, Expression, String, IEnumerable<ParameterExpression>)

Crée un LambdaExpression où le type de 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> où le type de délégué est connu au moment de la compilation, avec un paramètre qui indique si l’optimisation d’appel tail est appliquée et une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, Boolean, ParameterExpression[])

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

Crée un Expression<TDelegate> où le type de 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> où le type de 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> où le type de 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 d’appel tail est appliquée et une collection énumérable d’expressions de paramètre.
Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>)

Crée un Expression<TDelegate> où le type de 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)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la gauche.
LeftShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la gauche.
LeftShiftAssign(Expression, Expression)

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

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

Crée un BinaryExpression qui représente une opération d'assignation de décalage vers la gauche au niveau du bit.
LessThan(Expression, Expression)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Crée un objet LoopExpression avec le corps et la cible d'instruction Break donnés.
Loop(Expression, LabelTarget, LabelTarget)

Crée un LoopExpression avec le corps donné.
MakeBinary(ExpressionType, Expression, Expression)

Crée un BinaryExpression, à partir des opérandes gauche et droit, en appelant une méthode de fabrique appropriée.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression, avec l'opérande gauche, l'opérande droit et la méthode d'implémentation, en appelant la méthode de fabrique appropriée.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression)

Crée un BinaryExpression, avec l’opérande gauche, l’opérande droit, la méthode d’implémentation et la fonction de conversion de type, en appelant la méthode de fabrique appropriée.
MakeCatchBlock(Type, ParameterExpression, Expression, Expression)

Crée un CatchBlock qui représente une instruction Catch avec les éléments spécifiés.
MakeDynamic(Type, CallSiteBinder, Expression)

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

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

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

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

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

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

Crée un GotoExpression qui représente un saut du GotoExpressionKind spécifié. La valeur passée à l'étiquette au moment 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 représentant un bloc Try avec les éléments spécifiés.
MakeUnary(ExpressionType, Expression, Type)

Crée un UnaryExpression, avec un opérande, en appelant la méthode de fabrique appropriée.
MakeUnary(ExpressionType, Expression, Type, MethodInfo)

Crée un UnaryExpression, avec un opérande et une méthode d'implémentation, 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 via 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 via une méthode d'accesseur de propriété.
MemberInit(NewExpression, IEnumerable<MemberBinding>)

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

Crée un MemberInitExpression.
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

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

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

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

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

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

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui ne dispose pas d'une vérification de dépassement de capacité.
Multiply(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de multiplication arithmétique qui ne dispose pas d'une vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation de multiplication qui ne dispose pas d'une vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation de multiplication qui ne dispose pas d'une vérification de dépassement de capacité.
MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de multiplication qui ne dispose pas d'une vérification de dépassement de capacité.
MultiplyAssignChecked(Expression, Expression)

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

Crée un BinaryExpression qui représente une opération d'assignation de multiplication qui dispose d'une vérification de dépassement de capacité.
MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de multiplication qui dispose d'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 dispose d'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 dispose d'une vérification de dépassement de capacité.
Negate(Expression)

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

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

Crée un UnaryExpression qui représente une opération de négation arithmétique qui dispose d'une vérification de dépassement de capacité.
NegateChecked(Expression, MethodInfo)

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

Crée un NewExpression qui représente l'appel du constructeur spécifié qui ne prend pas d'arguments.
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>)

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 sous forme de tableau.
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 qui représente la création d'un tableau ayant un rang spécifié.
NewArrayBounds(Type, IEnumerable<Expression>)

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

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

Crée un NewArrayExpression qui représente la création d'un tableau unidimensionnel et son initialisation à partir d'une liste d'éléments.
Not(Expression)

Crée un UnaryExpression qui représente une opération de bits de complément.
Not(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération de bits de complément. La méthode d'implémentation peut être spécifiée.
NotEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'inégalité.
NotEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison d'inégalité.
OnesComplement(Expression)

Retourne l'expression qui représente le complément à 1.
OnesComplement(Expression, MethodInfo)

Retourne l'expression qui représente le complément à 1.
Or(Expression, Expression)

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

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

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

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

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

Crée un BinaryExpression qui représente une opération OR conditionnelle évaluant la deuxième opérande uniquement si la première opérande a la valeur false.
OrElse(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération OR conditionnelle évaluant la deuxième opérande uniquement si la première opérande a la valeur false.
Parameter(Type)

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

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

Crée un UnaryExpression qui représente l'assignation de l'expression suivie d'une décrémentation de 1 de l'expression d'origine.
PostDecrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui représente l'assignation de l'expression suivie d'une décrémentation de 1 de l'expression d'origine.
PostIncrementAssign(Expression)

Crée un UnaryExpression qui représente l'assignation de l'expression suivie d'une incrémentation de 1 de l'expression d'origine.
PostIncrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui représente l'assignation de l'expression suivie d'une incrémentation de 1 de l'expression d'origine.
Power(Expression, Expression)

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

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

Crée un BinaryExpression qui représente l'élévation d'une expression à une puissance et la réassignation 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 la réassignation du résultat à l'expression.
PowerAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente l'élévation d'une expression à une puissance et la réassignation du résultat à l'expression.
PreDecrementAssign(Expression)

Crée un UnaryExpression qui décrémente l'expression de 1 et réassigne le résultat à l'expression.
PreDecrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui décrémente l'expression de 1 et réassigne le résultat à l'expression.
PreIncrementAssign(Expression)

Crée un UnaryExpression qui incrémente l'expression de 1 et réassigne le résultat à l'expression.
PreIncrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui incrémente l'expression de 1 et réassigne 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)

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

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

Crée un IndexExpression qui représente 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, String, Expression[])

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

Crée un MemberExpression qui accède à 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 ayant une valeur de constante de type Expression.
Reduce()

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

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

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

Crée un BinaryExpression qui représente une comparaison d'égalité des références.
ReferenceNotEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'inégalité des références.
Rethrow()

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

Crée un UnaryExpression qui représente une nouvelle levée d'une exception avec un type donné.
Return(LabelTarget)

Crée un GotoExpression qui représente une instruction Return.
Return(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction Return. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Return(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction Return avec le type spécifié. La valeur passée à l'étiquette au moment du saut peut être spécifiée.
Return(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Return avec le type spécifié.
RightShift(Expression, Expression)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la droite.
RightShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la droite.
RightShiftAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation de décalage vers la droite au niveau du bit.
RightShiftAssign(Expression, Expression, MethodInfo)

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

Crée un BinaryExpression qui représente une opération d'assignation de décalage vers la droite au niveau du bit.
RuntimeVariables(IEnumerable<ParameterExpression>)

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

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

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui ne dispose pas d'une vérification de dépassement de capacité.
Subtract(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de soustraction arithmétique qui ne dispose pas d'une vérification de dépassement de capacité.
SubtractAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation de soustraction qui ne dispose pas d'une vérification de dépassement de capacité.
SubtractAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation de soustraction qui ne dispose pas d'une vérification de dépassement de capacité.
SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de soustraction qui ne dispose pas d'une vérification de dépassement de capacité.
SubtractAssignChecked(Expression, Expression)

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

Crée un BinaryExpression qui représente une opération d'assignation de soustraction qui dispose d'une vérification de dépassement de capacité.
SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de soustraction qui dispose d'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 dispose d'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 dispose d'une vérification de dépassement de capacité.
Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

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

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

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

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

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

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

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

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

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

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

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

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

Crée un UnaryExpression qui représente une levée d'exception.
Throw(Expression, Type)

Crée un UnaryExpression qui représente la levée d'une exception avec un type donné.
ToString()

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

Crée un TryExpression qui représente un bloc Try avec un nombre quelconque d'instructions Catch mais ni une erreur, ni un bloc Finally.
TryCatchFinally(Expression, Expression, CatchBlock[])

Crée un TryExpression qui représente un bloc Try avec un nombre quelconque d'instructions Catch et un bloc Finally.
TryFault(Expression, Expression)

Crée un TryExpression qui représente un bloc Try avec un bloc Fault et aucune instruction Catch.
TryFinally(Expression, Expression)

Crée un TryExpression qui représente un bloc Try avec un bloc Finally et aucune instruction Catch.
TryGetActionType(Type[], Type)

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

Crée un objet Type qui représente un type délégué System.Func générique comportant 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 UnaryExpression qui représente une référence explicite ou une conversion boxing où la valeur null est fournie en cas d'échec de la conversion.
TypeEqual(Expression, Type)

Crée un TypeBinaryExpression qui compare l'identité de type à l'exécution.
TypeIs(Expression, Type)

Crée un TypeBinaryExpression.
UnaryPlus(Expression)

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

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

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

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

Crée un nœud ParameterExpression qui peut être utilisé pour identifier un paramètre ou une variable dans une arborescence d’expression.
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 à