Expression Expression Expression Expression Class

Définition

Fournit la classe de base de laquelle sont dérivées les classes qui représentent des nœuds d'arborescence d'expression.Provides the base class from which the classes that represent expression tree nodes are derived. Contient également des méthodes de fabrique static (Shared en Visual Basic) pour créer les divers types de nœuds.It also contains static (Shared in Visual Basic) factory methods to create the various node types. Il s'agit d'une classe abstract.This is an abstract class.

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

Exemples

L’exemple de code suivant montre comment créer une expression de bloc.The following code example shows how to create a block expression. L’expression de bloc se compose MethodCallExpression de deux objets ConstantExpression et d’un objet.The block expression consists of two MethodCallExpression objects and one ConstantExpression object.

// 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() Expression() Expression() Expression()

Construit une nouvelle instance de Expression.Constructs a new instance of Expression.

Expression(ExpressionType, Type) Expression(ExpressionType, Type) Expression(ExpressionType, Type) Expression(ExpressionType, Type)

Initialise une nouvelle instance de la classe Expression.Initializes a new instance of the Expression class.

Propriétés

CanReduce CanReduce CanReduce CanReduce

Indique que le nœud peut être réduit à un nœud plus simple.Indicates that the node can be reduced to a simpler node. Si la valeur retournée est true, Reduce() peut être appelé pour produire la forme réduite.If this returns true, Reduce() can be called to produce the reduced form.

NodeType NodeType NodeType NodeType

Obtient le type de nœud de ce Expression.Gets the node type of this Expression.

Type Type Type Type

Obtient le type statique de l'expression que ce Expression représente.Gets the static type of the expression that this Expression represents.

Méthodes

Accept(ExpressionVisitor) Accept(ExpressionVisitor) Accept(ExpressionVisitor) Accept(ExpressionVisitor)

Distribue à la méthode de visite spécifique à ce type de nœud.Dispatches to the specific visit method for this node type. Par exemple, MethodCallExpression appelle VisitMethodCall(MethodCallExpression).For example, MethodCallExpression calls the VisitMethodCall(MethodCallExpression).

Add(Expression, Expression) Add(Expression, Expression) Add(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking.

Add(Expression, Expression, MethodInfo) Add(Expression, Expression, MethodInfo) Add(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

AddAssign(Expression, Expression) AddAssign(Expression, Expression) AddAssign(Expression, Expression) 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é.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssign(Expression, Expression, MethodInfo) AddAssign(Expression, Expression, MethodInfo) AddAssign(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssign(Expression, Expression, MethodInfo, LambdaExpression) AddAssign(Expression, Expression, MethodInfo, LambdaExpression) AddAssign(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssignChecked(Expression, Expression) AddAssignChecked(Expression, Expression) AddAssignChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddAssignChecked(Expression, Expression, MethodInfo) AddAssignChecked(Expression, Expression, MethodInfo) AddAssignChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddChecked(Expression, Expression) AddChecked(Expression, Expression) AddChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking.

AddChecked(Expression, Expression, MethodInfo) AddChecked(Expression, Expression, MethodInfo) AddChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

And(Expression, Expression) And(Expression, Expression) And(Expression, Expression) And(Expression, Expression)

Crée un BinaryExpression qui représente une opération AND au niveau du bit.Creates a BinaryExpression that represents a bitwise AND operation.

And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération AND au niveau du bit.Creates a BinaryExpression that represents a bitwise AND operation. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

AndAlso(Expression, Expression) AndAlso(Expression, Expression) AndAlso(Expression, Expression) 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.Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand evaluates to true.

AndAlso(Expression, Expression, MethodInfo) AndAlso(Expression, Expression, MethodInfo) AndAlso(Expression, Expression, MethodInfo) 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.Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand is resolved to true. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

AndAssign(Expression, Expression) AndAssign(Expression, Expression) AndAssign(Expression, Expression) AndAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation AND au niveau du bit.Creates a BinaryExpression that represents a bitwise AND assignment operation.

AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation AND au niveau du bit.Creates a BinaryExpression that represents a bitwise AND assignment operation.

AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation AND au niveau du bit.Creates a BinaryExpression that represents a bitwise AND assignment operation.

ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[])

Crée un IndexExpression pour accéder à un tableau.Creates an IndexExpression to access an array.

ArrayAccess(Expression, IEnumerable<Expression>) ArrayAccess(Expression, IEnumerable<Expression>) ArrayAccess(Expression, IEnumerable<Expression>) ArrayAccess(Expression, IEnumerable<Expression>)

Crée un IndexExpression pour accéder à un tableau multidimensionnel.Creates an IndexExpression to access a multidimensional array.

ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression)

Crée un BinaryExpression qui représente l'application d'un opérateur index de tableau à un tableau de rang un.Creates a BinaryExpression that represents applying an array index operator to an array of rank one.

ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[])

Crée un MethodCallExpression qui représente l'application d'un opérateur index de tableau à un tableau multidimensionnel.Creates a MethodCallExpression that represents applying an array index operator to a multidimensional array.

ArrayIndex(Expression, IEnumerable<Expression>) ArrayIndex(Expression, IEnumerable<Expression>) ArrayIndex(Expression, IEnumerable<Expression>) 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.Creates a MethodCallExpression that represents applying an array index operator to an array of rank more than one.

ArrayLength(Expression) ArrayLength(Expression) ArrayLength(Expression) ArrayLength(Expression)

Crée un UnaryExpression qui représente une expression permettant d'obtenir la longueur d'un tableau unidimensionnel.Creates a UnaryExpression that represents an expression for obtaining the length of a one-dimensional array.

Assign(Expression, Expression) Assign(Expression, Expression) Assign(Expression, Expression) Assign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation.Creates a BinaryExpression that represents an assignment operation.

Bind(MemberInfo, Expression) Bind(MemberInfo, Expression) Bind(MemberInfo, Expression) Bind(MemberInfo, Expression)

Crée un MemberAssignment qui représente l'initialisation d'un champ ou d'une propriété.Creates a MemberAssignment that represents the initialization of a field or property.

Bind(MethodInfo, Expression) Bind(MethodInfo, Expression) Bind(MethodInfo, Expression) 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é.Creates a MemberAssignment that represents the initialization of a member by using a property accessor method.

Block(Expression, Expression) Block(Expression, Expression) Block(Expression, Expression) Block(Expression, Expression)

Crée un BlockExpression qui contient deux expressions et aucune variable.Creates a BlockExpression that contains two expressions and has no variables.

Block(Expression, Expression, Expression) Block(Expression, Expression, Expression) Block(Expression, Expression, Expression) Block(Expression, Expression, Expression)

Crée un BlockExpression qui contient trois expressions et aucune variable.Creates a BlockExpression that contains three expressions and has no variables.

Block(Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression)

Crée un BlockExpression qui contient quatre expressions et aucune variable.Creates a BlockExpression that contains four expressions and has no variables.

Block(Expression, Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression, Expression) Block(Expression, Expression, Expression, Expression, Expression)

Crée un BlockExpression qui contient deux expressions et aucune variable.Creates a BlockExpression that contains five expressions and has no variables.

Block(Expression[]) Block(Expression[]) Block(Expression[]) Block(Expression[])

Crée un BlockExpression qui contient les expressions données et aucune variable.Creates a BlockExpression that contains the given expressions and has no variables.

Block(IEnumerable<Expression>) Block(IEnumerable<Expression>) Block(IEnumerable<Expression>) Block(IEnumerable<Expression>)

Crée un BlockExpression qui contient les expressions données et aucune variable.Creates a BlockExpression that contains the given expressions and has no variables.

Block(IEnumerable<ParameterExpression>, Expression[]) Block(IEnumerable<ParameterExpression>, Expression[]) Block(IEnumerable<ParameterExpression>, Expression[]) Block(IEnumerable<ParameterExpression>, Expression[])

Crée un BlockExpression qui contient les variables et expressions données.Creates a BlockExpression that contains the given variables and expressions.

Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Crée un BlockExpression qui contient les variables et expressions données.Creates a BlockExpression that contains the given variables and expressions.

Block(Type, Expression[]) Block(Type, Expression[]) Block(Type, Expression[]) Block(Type, Expression[])

Crée un BlockExpression qui contient les expressions données, aucune variable et a un type de résultat spécifique.Creates a BlockExpression that contains the given expressions, has no variables and has specific result type.

Block(Type, IEnumerable<Expression>) Block(Type, IEnumerable<Expression>) Block(Type, IEnumerable<Expression>) 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.Creates a BlockExpression that contains the given expressions, has no variables and has specific result type.

Block(Type, IEnumerable<ParameterExpression>, Expression[]) Block(Type, IEnumerable<ParameterExpression>, Expression[]) Block(Type, IEnumerable<ParameterExpression>, Expression[]) Block(Type, IEnumerable<ParameterExpression>, Expression[])

Crée un BlockExpression qui contient les variables et expressions données.Creates a BlockExpression that contains the given variables and expressions.

Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>) Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Crée un BlockExpression qui contient les variables et expressions données.Creates a BlockExpression that contains the given variables and expressions.

Break(LabelTarget) Break(LabelTarget) Break(LabelTarget) Break(LabelTarget)

Crée un GotoExpression qui représente une instruction Break.Creates a GotoExpression representing a break statement.

Break(LabelTarget, Expression) Break(LabelTarget, Expression) Break(LabelTarget, Expression) Break(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction Break.Creates a GotoExpression representing a break statement. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction Break avec le type spécifié.Creates a GotoExpression representing a break statement with the specified type. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Break(LabelTarget, Type) Break(LabelTarget, Type) Break(LabelTarget, Type) Break(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Break avec le type spécifié.Creates a GotoExpression representing a break statement with the specified type.

Call(Expression, MethodInfo) Call(Expression, MethodInfo) Call(Expression, MethodInfo) Call(Expression, MethodInfo)

Crée un MethodCallExpression qui représente un appel à une méthode qui ne prend aucun argument.Creates a MethodCallExpression that represents a call to a method that takes no arguments.

Call(Expression, MethodInfo, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode qui prend deux arguments.Creates a MethodCallExpression that represents a call to a method that takes two arguments.

Call(Expression, MethodInfo, Expression, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression, Expression) Call(Expression, MethodInfo, Expression, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode qui prend trois arguments.Creates a MethodCallExpression that represents a call to a method that takes three arguments.

Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[])

Crée un MethodCallExpression qui représente un appel à une méthode qui prend des arguments.Creates a MethodCallExpression that represents a call to a method that takes arguments.

Call(Expression, MethodInfo, IEnumerable<Expression>) Call(Expression, MethodInfo, IEnumerable<Expression>) Call(Expression, MethodInfo, IEnumerable<Expression>) Call(Expression, MethodInfo, IEnumerable<Expression>)

Crée un MethodCallExpression qui représente un appel à une méthode qui prend des arguments.Creates a MethodCallExpression that represents a call to a method that takes arguments.

Call(Expression, String, Type[], Expression[]) Call(Expression, String, Type[], Expression[]) Call(Expression, String, Type[], Expression[]) 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.Creates a MethodCallExpression that represents a call to a method by calling the appropriate factory method.

Call(MethodInfo, Expression) Call(MethodInfo, Expression) Call(MethodInfo, Expression) 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.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that takes one argument.

Call(MethodInfo, Expression, Expression) Call(MethodInfo, Expression, Expression) Call(MethodInfo, Expression, Expression) Call(MethodInfo, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode statique prenant deux arguments.Creates a MethodCallExpression that represents a call to a static method that takes two arguments.

Call(MethodInfo, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode statique prenant trois arguments.Creates a MethodCallExpression that represents a call to a static method that takes three arguments.

Call(MethodInfo, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode statique prenant quatre arguments.Creates a MethodCallExpression that represents a call to a static method that takes four arguments.

Call(MethodInfo, Expression, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression, Expression) Call(MethodInfo, Expression, Expression, Expression, Expression, Expression)

Crée un MethodCallExpression qui représente un appel à une méthode statique prenant cinq arguments.Creates a MethodCallExpression that represents a call to a static method that takes five arguments.

Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[])

Crée un MethodCallExpression qui représente un appel à une méthode static (Shared en Visual Basic) comportant des arguments.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that has arguments.

Call(MethodInfo, IEnumerable<Expression>) Call(MethodInfo, IEnumerable<Expression>) Call(MethodInfo, IEnumerable<Expression>) Call(MethodInfo, IEnumerable<Expression>)

Crée un MethodCallExpression qui représente un appel à une méthode statique (méthode partagée en Visual Basic).Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method.

Call(Type, String, Type[], Expression[]) Call(Type, String, Type[], Expression[]) Call(Type, String, Type[], Expression[]) 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.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method by calling the appropriate factory method.

Catch(ParameterExpression, Expression) Catch(ParameterExpression, Expression) Catch(ParameterExpression, Expression) 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.Creates a CatchBlock representing a catch statement with a reference to the caught Exception object for use in the handler body.

Catch(ParameterExpression, Expression, Expression) Catch(ParameterExpression, Expression, Expression) Catch(ParameterExpression, Expression, Expression) 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é.Creates a CatchBlock representing a catch statement with an Exception filter and a reference to the caught Exception object.

Catch(Type, Expression) Catch(Type, Expression) Catch(Type, Expression) Catch(Type, Expression)

Crée un CatchBlock qui représente une instruction Catch.Creates a CatchBlock representing a catch statement.

Catch(Type, Expression, Expression) Catch(Type, Expression, Expression) Catch(Type, Expression, Expression) 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é.Creates a CatchBlock representing a catch statement with an Exception filter but no reference to the caught Exception object.

ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo)

Crée un DebugInfoExpression pour la suppression d'un point de séquence.Creates a DebugInfoExpression for clearing a sequence point.

Coalesce(Expression, Expression) Coalesce(Expression, Expression) Coalesce(Expression, Expression) Coalesce(Expression, Expression)

Crée un BinaryExpression qui représente une opération de fusion.Creates a BinaryExpression that represents a coalescing operation.

Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression)

Crée un BinaryExpression qui représente une opération de fusion, à partir d'une fonction de conversion.Creates a BinaryExpression that represents a coalescing operation, given a conversion function.

Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression)

Crée un ConditionalExpression qui représente une instruction conditionnelle.Creates a ConditionalExpression that represents a conditional statement.

Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type)

Crée un ConditionalExpression qui représente une instruction conditionnelle.Creates a ConditionalExpression that represents a conditional statement.

Constant(Object) Constant(Object) Constant(Object) Constant(Object)

Crée un ConstantExpression dont la propriété Value a la valeur spécifiée.Creates a ConstantExpression that has the Value property set to the specified value.

Constant(Object, Type) Constant(Object, Type) Constant(Object, Type) Constant(Object, Type)

Crée un ConstantExpression dont les propriétés Value et Type ont les valeurs spécifiées.Creates a ConstantExpression that has the Value and Type properties set to the specified values.

Continue(LabelTarget) Continue(LabelTarget) Continue(LabelTarget) Continue(LabelTarget)

Crée un GotoExpression qui représente une instruction Continue.Creates a GotoExpression representing a continue statement.

Continue(LabelTarget, Type) Continue(LabelTarget, Type) Continue(LabelTarget, Type) Continue(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Continue avec le type spécifié.Creates a GotoExpression representing a continue statement with the specified type.

Convert(Expression, Type) Convert(Expression, Type) Convert(Expression, Type) Convert(Expression, Type)

Crée un UnaryExpression qui représente une opération de conversion de type.Creates a UnaryExpression that represents a type conversion operation.

Convert(Expression, Type, MethodInfo) Convert(Expression, Type, MethodInfo) Convert(Expression, Type, MethodInfo) 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.Creates a UnaryExpression that represents a conversion operation for which the implementing method is specified.

ConvertChecked(Expression, Type) ConvertChecked(Expression, Type) ConvertChecked(Expression, Type) 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.Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed.

ConvertChecked(Expression, Type, MethodInfo) ConvertChecked(Expression, Type, MethodInfo) ConvertChecked(Expression, Type, MethodInfo) 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.Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified.

DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32) DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32) DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32) DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32)

Crée un DebugInfoExpression avec l'étendue spécifiée.Creates a DebugInfoExpression with the specified span.

Decrement(Expression) Decrement(Expression) Decrement(Expression) Decrement(Expression)

Crée un UnaryExpression qui représente la décrémentation de l'expression par 1.Creates a UnaryExpression that represents the decrementing of the expression by 1.

Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo)

Crée un UnaryExpression qui représente la décrémentation de l'expression par 1.Creates a UnaryExpression that represents the decrementing of the expression by 1.

Default(Type) Default(Type) Default(Type) Default(Type)

Crée un DefaultExpression dont la propriété Type a le type spécifié.Creates a DefaultExpression that has the Type property set to the specified type.

Divide(Expression, Expression) Divide(Expression, Expression) Divide(Expression, Expression) Divide(Expression, Expression)

Crée un BinaryExpression qui représente une opération de division arithmétique.Creates a BinaryExpression that represents an arithmetic division operation.

Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de division arithmétique.Creates a BinaryExpression that represents an arithmetic division operation. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

DivideAssign(Expression, Expression) DivideAssign(Expression, Expression) DivideAssign(Expression, Expression) 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é.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

DivideAssign(Expression, Expression, MethodInfo) DivideAssign(Expression, Expression, MethodInfo) DivideAssign(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

Dynamic(CallSiteBinder, Type, Expression) Dynamic(CallSiteBinder, Type, Expression) Dynamic(CallSiteBinder, Type, Expression) Dynamic(CallSiteBinder, Type, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression) Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[])

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, IEnumerable<Expression>) Dynamic(CallSiteBinder, Type, IEnumerable<Expression>) Dynamic(CallSiteBinder, Type, IEnumerable<Expression>) Dynamic(CallSiteBinder, Type, IEnumerable<Expression>)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[])

Crée un ElementInit, à partir d'un tableau de valeurs comme deuxième argument.Creates an ElementInit, given an array of values as the second argument.

ElementInit(MethodInfo, IEnumerable<Expression>) ElementInit(MethodInfo, IEnumerable<Expression>) ElementInit(MethodInfo, IEnumerable<Expression>) ElementInit(MethodInfo, IEnumerable<Expression>)

Crée un ElementInit, à partir d'un IEnumerable<T> comme deuxième argument.Creates an ElementInit, given an IEnumerable<T> as the second argument.

Empty() Empty() Empty() Empty()

Crée une expression vide qui a le type Void.Creates an empty expression that has Void type.

Equal(Expression, Expression) Equal(Expression, Expression) Equal(Expression, Expression) Equal(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'égalité.Creates a BinaryExpression that represents an equality comparison.

Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison d'égalité.Creates a BinaryExpression that represents an equality comparison. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’assignation XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l’utilisateur.Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types.

ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’assignation XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l’utilisateur.Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d’assignation XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l’utilisateur.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d’assignation XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l’utilisateur.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d’assignation XOR au niveau du bit, en utilisant op_ExclusiveOr pour les types définis par l’utilisateur.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

Field(Expression, FieldInfo) Field(Expression, FieldInfo) Field(Expression, FieldInfo) Field(Expression, FieldInfo)

Crée un MemberExpression qui représente l'accès à un champ.Creates a MemberExpression that represents accessing a field.

Field(Expression, String) Field(Expression, String) Field(Expression, String) Field(Expression, String)

Crée un MemberExpression qui représente l'accès à un champ à partir du nom du champ.Creates a MemberExpression that represents accessing a field given the name of the field.

Field(Expression, Type, String) Field(Expression, Type, String) Field(Expression, Type, String) Field(Expression, Type, String)

Crée un MemberExpression qui représente l'accès à un champ.Creates a MemberExpression that represents accessing a field.

GetActionType(Type[]) GetActionType(Type[]) GetActionType(Type[]) GetActionType(Type[])

Crée un objet Type qui représente un type délégué System.Action générique ayant des arguments de type spécifiques.Creates a Type object that represents a generic System.Action delegate type that has specific type arguments.

GetDelegateType(Type[]) GetDelegateType(Type[]) GetDelegateType(Type[]) GetDelegateType(Type[])

Obtient un objet Type qui représente un type délégué System.Func ou System.Action générique ayant des arguments de type spécifiques.Gets a Type object that represents a generic System.Func or System.Action delegate type that has specific type arguments.

GetFuncType(Type[]) GetFuncType(Type[]) GetFuncType(Type[]) GetFuncType(Type[])

Crée un objet Type qui représente un type délégué System.Func générique ayant des arguments de type spécifiques.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. Le dernier argument de type spécifie le type de retour du délégué créé.The last type argument specifies the return type of the created delegate.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
Goto(LabelTarget) Goto(LabelTarget) Goto(LabelTarget) Goto(LabelTarget)

Crée un GotoExpression qui représente une instruction GoTo.Creates a GotoExpression representing a "go to" statement.

Goto(LabelTarget, Expression) Goto(LabelTarget, Expression) Goto(LabelTarget, Expression) Goto(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction GoTo.Creates a GotoExpression representing a "go to" statement. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction GoTo avec le type spécifié.Creates a GotoExpression representing a "go to" statement with the specified type. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Goto(LabelTarget, Type) Goto(LabelTarget, Type) Goto(LabelTarget, Type) Goto(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction GoTo avec le type spécifié.Creates a GotoExpression representing a "go to" statement with the specified type.

GreaterThan(Expression, Expression) GreaterThan(Expression, Expression) GreaterThan(Expression, Expression) GreaterThan(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur à ».Creates a BinaryExpression that represents a "greater than" numeric comparison.

GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur à ».Creates a BinaryExpression that represents a "greater than" numeric comparison. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur ou égal à ».Creates a BinaryExpression that represents a "greater than or equal" numeric comparison.

GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « supérieur ou égal à ».Creates a BinaryExpression that represents a "greater than or equal" numeric comparison.

IfThen(Expression, Expression) IfThen(Expression, Expression) IfThen(Expression, Expression) IfThen(Expression, Expression)

Crée un ConditionalExpression qui représente un bloc conditionnel avec une instruction if.Creates a ConditionalExpression that represents a conditional block with an if statement.

IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression)

Crée un ConditionalExpression qui représente un bloc conditionnel avec des instructions if et else.Creates a ConditionalExpression that represents a conditional block with if and else statements.

Increment(Expression) Increment(Expression) Increment(Expression) Increment(Expression)

Crée un UnaryExpression qui représente l'incrémentation de la valeur de l'expression par 1.Creates a UnaryExpression that represents the incrementing of the expression value by 1.

Increment(Expression, MethodInfo) Increment(Expression, MethodInfo) Increment(Expression, MethodInfo) Increment(Expression, MethodInfo)

Crée un UnaryExpression qui représente l'incrémentation de l'expression par 1.Creates a UnaryExpression that represents the incrementing of the expression by 1.

Invoke(Expression, Expression[]) Invoke(Expression, Expression[]) Invoke(Expression, Expression[]) Invoke(Expression, Expression[])

Crée un InvocationExpression qui applique un délégué ou une expression lambda à une liste d'expressions d'arguments.Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions.

Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>)

Crée un InvocationExpression qui applique un délégué ou une expression lambda à une liste d'expressions d'arguments.Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions.

IsFalse(Expression) IsFalse(Expression) IsFalse(Expression) IsFalse(Expression)

Indique si l'expression prend la valeur false.Returns whether the expression evaluates to false.

IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo)

Indique si l'expression prend la valeur false.Returns whether the expression evaluates to false.

IsTrue(Expression) IsTrue(Expression) IsTrue(Expression) IsTrue(Expression)

Indique si l'expression prend la valeur true.Returns whether the expression evaluates to true.

IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo)

Indique si l'expression prend la valeur true.Returns whether the expression evaluates to true.

Label() Label() Label() Label()

Crée un LabelTarget qui représente une étiquette avec le type void et aucun nom.Creates a LabelTarget representing a label with void type and no name.

Label(LabelTarget) Label(LabelTarget) Label(LabelTarget) Label(LabelTarget)

Crée un LabelExpression qui représente une étiquette sans valeur par défaut.Creates a LabelExpression representing a label without a default value.

Label(LabelTarget, Expression) Label(LabelTarget, Expression) Label(LabelTarget, Expression) Label(LabelTarget, Expression)

Crée un LabelExpression qui représente une étiquette avec la valeur par défaut donnée.Creates a LabelExpression representing a label with the given default value.

Label(String) Label(String) Label(String) Label(String)

Crée un LabelTarget représentant une étiquette avec le type void et le nom donné.Creates a LabelTarget representing a label with void type and the given name.

Label(Type) Label(Type) Label(Type) Label(Type)

Crée un LabelTarget représentant une étiquette avec le type donné.Creates a LabelTarget representing a label with the given type.

Label(Type, String) Label(Type, String) Label(Type, String) Label(Type, String)

Crée un LabelTarget qui représente une étiquette avec le type et le nom donnés.Creates a LabelTarget representing a label with the given type and name.

Lambda(Expression, Boolean, IEnumerable<ParameterExpression>) Lambda(Expression, Boolean, IEnumerable<ParameterExpression>) Lambda(Expression, Boolean, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Expression, Boolean, ParameterExpression[]) Lambda(Expression, Boolean, ParameterExpression[]) Lambda(Expression, Boolean, ParameterExpression[]) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Expression, IEnumerable<ParameterExpression>) Lambda(Expression, IEnumerable<ParameterExpression>) Lambda(Expression, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an enumerable collection of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Expression, ParameterExpression[]) Lambda(Expression, ParameterExpression[]) Lambda(Expression, ParameterExpression[]) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an array of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Expression, String, IEnumerable<ParameterExpression>) Lambda(Expression, String, IEnumerable<ParameterExpression>) Lambda(Expression, String, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression by first constructing a delegate type from the expression body, the name for the lambda, and an enumerable collection of parameter expressions. Peut être utilisé lorsque le type délégué n'est pas connu au moment de la compilation.It can be used when the delegate type is not known at compile time.

Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>) Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>) Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

Lambda(Type, Expression, Boolean, ParameterExpression[]) Lambda(Type, Expression, Boolean, ParameterExpression[]) Lambda(Type, Expression, Boolean, ParameterExpression[]) 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.Creates a LambdaExpression where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions.

Lambda(Type, Expression, IEnumerable<ParameterExpression>) Lambda(Type, Expression, IEnumerable<ParameterExpression>) Lambda(Type, Expression, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression where the delegate type is known at compile time, with an enumerable collection of parameter expressions.

Lambda(Type, Expression, ParameterExpression[]) Lambda(Type, Expression, ParameterExpression[]) Lambda(Type, Expression, ParameterExpression[]) 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.Creates a LambdaExpression where the delegate type is known at compile time, with an array of parameter expressions.

Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression where the delegate type is known at compile time, with the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

Lambda(Type, Expression, String, IEnumerable<ParameterExpression>) Lambda(Type, Expression, String, IEnumerable<ParameterExpression>) Lambda(Type, Expression, String, IEnumerable<ParameterExpression>) 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.Creates a LambdaExpression where the delegate type is known at compile time, with the name for the lambda, and an enumerable collection of parameter expressions.

Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

Lambda<TDelegate>(Expression, Boolean, ParameterExpression[]) Lambda<TDelegate>(Expression, Boolean, ParameterExpression[]) Lambda<TDelegate>(Expression, Boolean, ParameterExpression[]) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions.

Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with an enumerable collection of parameter expressions.

Lambda<TDelegate>(Expression, ParameterExpression[]) Lambda<TDelegate>(Expression, ParameterExpression[]) Lambda<TDelegate>(Expression, ParameterExpression[]) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with an array of parameter expressions.

Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>) Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>) 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.Creates an Expression<TDelegate> where the delegate type is known at compile time, with the name for the lambda, and an enumerable collection of parameter expressions.

LeftShift(Expression, Expression) LeftShift(Expression, Expression) LeftShift(Expression, Expression) LeftShift(Expression, Expression)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la gauche.Creates a BinaryExpression that represents a bitwise left-shift operation.

LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la gauche.Creates a BinaryExpression that represents a bitwise left-shift operation.

LeftShiftAssign(Expression, Expression) LeftShiftAssign(Expression, Expression) LeftShiftAssign(Expression, Expression) 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.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LeftShiftAssign(Expression, Expression, MethodInfo) LeftShiftAssign(Expression, Expression, MethodInfo) LeftShiftAssign(Expression, Expression, MethodInfo) 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.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) 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.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LessThan(Expression, Expression) LessThan(Expression, Expression) LessThan(Expression, Expression) LessThan(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « inférieur à ».Creates a BinaryExpression that represents a "less than" numeric comparison.

LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « inférieur à ».Creates a BinaryExpression that represents a "less than" numeric comparison.

LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison numérique « inférieur ou égal à ».Creates a BinaryExpression that represents a " less than or equal" numeric comparison.

LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison numérique « inférieur ou égal à ».Creates a BinaryExpression that represents a "less than or equal" numeric comparison.

ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[])

Crée un MemberListBinding dans lequel le membre est un champ ou une propriété.Creates a MemberListBinding where the member is a field or property.

ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>)

Crée un MemberListBinding dans lequel le membre est un champ ou une propriété.Creates a MemberListBinding where the member is a field or property.

ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[])

Crée un objet MemberListBinding basé sur une méthode d'accesseur de propriété spécifiée.Creates a MemberListBinding object based on a specified property accessor method.

ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>)

Crée un objet MemberListBinding basé sur une méthode d’accesseur de propriété spécifiée.Creates a MemberListBinding based on a specified property accessor method.

ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[])

Crée un ListInitExpression qui utilise des objets ElementInit spécifiés pour initialiser une collection.Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection.

ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[])

Crée un ListInitExpression qui utilise une méthode nommée « Add » pour ajouter des éléments à une collection.Creates a ListInitExpression that uses a method named "Add" to add elements to a collection.

ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>)

Crée un ListInitExpression qui utilise des objets ElementInit spécifiés pour initialiser une collection.Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection.

ListInit(NewExpression, IEnumerable<Expression>) ListInit(NewExpression, IEnumerable<Expression>) ListInit(NewExpression, IEnumerable<Expression>) ListInit(NewExpression, IEnumerable<Expression>)

Crée un ListInitExpression qui utilise une méthode nommée « Add » pour ajouter des éléments à une collection.Creates a ListInitExpression that uses a method named "Add" to add elements to a collection.

ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[])

Crée un ListInitExpression qui utilise une méthode spécifiée pour ajouter des éléments à une collection.Creates a ListInitExpression that uses a specified method to add elements to a collection.

ListInit(NewExpression, MethodInfo, IEnumerable<Expression>) ListInit(NewExpression, MethodInfo, IEnumerable<Expression>) ListInit(NewExpression, MethodInfo, IEnumerable<Expression>) ListInit(NewExpression, MethodInfo, IEnumerable<Expression>)

Crée un ListInitExpression qui utilise une méthode spécifiée pour ajouter des éléments à une collection.Creates a ListInitExpression that uses a specified method to add elements to a collection.

Loop(Expression) Loop(Expression) Loop(Expression) Loop(Expression)

Crée un LoopExpression avec le corps donné.Creates a LoopExpression with the given body.

Loop(Expression, LabelTarget) Loop(Expression, LabelTarget) Loop(Expression, LabelTarget) Loop(Expression, LabelTarget)

Crée un objet LoopExpression avec le corps et la cible d'instruction Break donnés.Creates a LoopExpression with the given body and break target.

Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget)

Crée un LoopExpression avec le corps donné.Creates a LoopExpression with the given body.

MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression)

Crée un BinaryExpression, à partir des opérandes gauche et droit, en appelant une méthode de fabrique appropriée.Creates a BinaryExpression, given the left and right operands, by calling an appropriate factory method.

MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo) MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo) MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo) 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.Creates a BinaryExpression, given the left operand, right operand and implementing method, by calling the appropriate factory method.

MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression) MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression) MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression) 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.Creates a BinaryExpression, given the left operand, right operand, implementing method and type conversion function, by calling the appropriate factory method.

MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression)

Crée un CatchBlock qui représente une instruction Catch avec les éléments spécifiés.Creates a CatchBlock representing a catch statement with the specified elements.

MakeDynamic(Type, CallSiteBinder, Expression) MakeDynamic(Type, CallSiteBinder, Expression) MakeDynamic(Type, CallSiteBinder, Expression) MakeDynamic(Type, CallSiteBinder, Expression)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni et un argument.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and one argument.

MakeDynamic(Type, CallSiteBinder, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression) 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.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and two arguments.

MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression) 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.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and three arguments.

MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression) MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression) 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.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and four arguments.

MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[])

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>) MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>) MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>) MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>)

Crée un DynamicExpression qui représente une opération dynamique liée par le CallSiteBinder fourni.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type)

Crée un GotoExpression qui représente un saut du GotoExpressionKind spécifié.Creates a GotoExpression representing a jump of the specified GotoExpressionKind. La valeur passée à l'étiquette au moment du saut peut également être spécifiée.The value passed to the label upon jumping can also be specified.

MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>) MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>) MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>) MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>)

Crée un IndexExpression qui représente l'accès à une propriété indexée dans un objet.Creates an IndexExpression that represents accessing an indexed property in an object.

MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo)

Crée un MemberExpression qui représente l'accès à un champ ou à une propriété.Creates a MemberExpression that represents accessing either a field or a property.

MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>) MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>) MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>) MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>)

Crée un TryExpression représentant un bloc Try avec les éléments spécifiés.Creates a TryExpression representing a try block with the specified elements.

MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type)

Crée un UnaryExpression, avec un opérande, en appelant la méthode de fabrique appropriée.Creates a UnaryExpression, given an operand, by calling the appropriate factory method.

MakeUnary(ExpressionType, Expression, Type, MethodInfo) MakeUnary(ExpressionType, Expression, Type, MethodInfo) MakeUnary(ExpressionType, Expression, Type, MethodInfo) 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.Creates a UnaryExpression, given an operand and implementing method, by calling the appropriate factory method.

MemberBind(MemberInfo, IEnumerable<MemberBinding>) MemberBind(MemberInfo, IEnumerable<MemberBinding>) MemberBind(MemberInfo, IEnumerable<MemberBinding>) 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é.Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property.

MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[])

Crée un MemberMemberBinding qui représente l'initialisation récursive des membres d'un champ ou d'une propriété.Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property.

MemberBind(MethodInfo, IEnumerable<MemberBinding>) MemberBind(MethodInfo, IEnumerable<MemberBinding>) MemberBind(MethodInfo, IEnumerable<MemberBinding>) 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é.Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method.

MemberBind(MethodInfo, MemberBinding[]) MemberBind(MethodInfo, MemberBinding[]) MemberBind(MethodInfo, MemberBinding[]) 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é.Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method.

MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>)

Représente une expression qui crée un nouvel objet et initialise une propriété de l'objet.Represents an expression that creates a new object and initializes a property of the object.

MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[])

Crée un MemberInitExpression.Creates a MemberInitExpression.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Modulo(Expression, Expression) Modulo(Expression, Expression) Modulo(Expression, Expression) Modulo(Expression, Expression)

Crée un BinaryExpression qui représente une opération arithmétique relative au reste.Creates a BinaryExpression that represents an arithmetic remainder operation.

Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération arithmétique relative au reste.Creates a BinaryExpression that represents an arithmetic remainder operation.

ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation de reste.Creates a BinaryExpression that represents a remainder assignment operation.

ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation de reste.Creates a BinaryExpression that represents a remainder assignment operation.

ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation de reste.Creates a BinaryExpression that represents a remainder assignment operation.

Multiply(Expression, Expression) Multiply(Expression, Expression) Multiply(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking.

Multiply(Expression, Expression, MethodInfo) Multiply(Expression, Expression, MethodInfo) Multiply(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking.

MultiplyAssign(Expression, Expression) MultiplyAssign(Expression, Expression) MultiplyAssign(Expression, Expression) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssign(Expression, Expression, MethodInfo) MultiplyAssign(Expression, Expression, MethodInfo) MultiplyAssign(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssignChecked(Expression, Expression) MultiplyAssignChecked(Expression, Expression) MultiplyAssignChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyAssignChecked(Expression, Expression, MethodInfo) MultiplyAssignChecked(Expression, Expression, MethodInfo) MultiplyAssignChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyChecked(Expression, Expression) MultiplyChecked(Expression, Expression) MultiplyChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking.

MultiplyChecked(Expression, Expression, MethodInfo) MultiplyChecked(Expression, Expression, MethodInfo) MultiplyChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking.

Negate(Expression) Negate(Expression) Negate(Expression) Negate(Expression)

Crée un UnaryExpression qui représente une opération de négation arithmétique.Creates a UnaryExpression that represents an arithmetic negation operation.

Negate(Expression, MethodInfo) Negate(Expression, MethodInfo) Negate(Expression, MethodInfo) Negate(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération de négation arithmétique.Creates a UnaryExpression that represents an arithmetic negation operation.

NegateChecked(Expression) NegateChecked(Expression) NegateChecked(Expression) 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é.Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking.

NegateChecked(Expression, MethodInfo) NegateChecked(Expression, MethodInfo) NegateChecked(Expression, MethodInfo) 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é.Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

New(ConstructorInfo) New(ConstructorInfo) New(ConstructorInfo) New(ConstructorInfo)

Crée un NewExpression qui représente l'appel du constructeur spécifié qui ne prend pas d'arguments.Creates a NewExpression that represents calling the specified constructor that takes no arguments.

New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[])

Crée un NewExpression qui représente l'appel du constructeur spécifié avec les arguments spécifiés.Creates a NewExpression that represents calling the specified constructor with the specified arguments.

New(ConstructorInfo, IEnumerable<Expression>) New(ConstructorInfo, IEnumerable<Expression>) New(ConstructorInfo, IEnumerable<Expression>) New(ConstructorInfo, IEnumerable<Expression>)

Crée un NewExpression qui représente l'appel du constructeur spécifié avec les arguments spécifiés.Creates a NewExpression that represents calling the specified constructor with the specified arguments.

New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>) New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>) New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>) 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.Creates a NewExpression that represents calling the specified constructor with the specified arguments. Les membres qui accèdent aux champs initialisés du constructeur sont spécifiés.The members that access the constructor initialized fields are specified.

New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[]) New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[]) New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[]) New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[])

Crée un NewExpression qui représente l'appel du constructeur spécifié avec les arguments spécifiés.Creates a NewExpression that represents calling the specified constructor with the specified arguments. Les membres qui accèdent aux champs initialisés du constructeur sont spécifiés sous forme de tableau.The members that access the constructor initialized fields are specified as an array.

New(Type) New(Type) New(Type) New(Type)

Crée un NewExpression qui représente l'appel du constructeur sans paramètre du type spécifié.Creates a NewExpression that represents calling the parameterless constructor of the specified type.

NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[])

Crée un NewArrayExpression qui représente la création d'un tableau ayant un rang spécifié.Creates a NewArrayExpression that represents creating an array that has a specified rank.

NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>)

Crée un NewArrayExpression qui représente la création d'un tableau ayant un rang spécifié.Creates a NewArrayExpression that represents creating an array that has a specified rank.

NewArrayInit(Type, Expression[]) NewArrayInit(Type, Expression[]) NewArrayInit(Type, Expression[]) 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.Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements.

NewArrayInit(Type, IEnumerable<Expression>) NewArrayInit(Type, IEnumerable<Expression>) NewArrayInit(Type, IEnumerable<Expression>) 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.Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements.

Not(Expression) Not(Expression) Not(Expression) Not(Expression)

Crée un UnaryExpression qui représente une opération de bits de complément.Creates a UnaryExpression that represents a bitwise complement operation.

Not(Expression, MethodInfo) Not(Expression, MethodInfo) Not(Expression, MethodInfo) Not(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération de bits de complément.Creates a UnaryExpression that represents a bitwise complement operation. La méthode d'implémentation peut être spécifiée.The implementing method can be specified.

NotEqual(Expression, Expression) NotEqual(Expression, Expression) NotEqual(Expression, Expression) NotEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'inégalité.Creates a BinaryExpression that represents an inequality comparison.

NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo)

Crée un BinaryExpression qui représente une comparaison d'inégalité.Creates a BinaryExpression that represents an inequality comparison.

OnesComplement(Expression) OnesComplement(Expression) OnesComplement(Expression) OnesComplement(Expression)

Retourne l'expression qui représente le complément à 1.Returns the expression representing the ones complement.

OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo)

Retourne l'expression qui représente le complément à 1.Returns the expression representing the ones complement.

Or(Expression, Expression) Or(Expression, Expression) Or(Expression, Expression) Or(Expression, Expression)

Crée un BinaryExpression qui représente une opération OR au niveau du bit.Creates a BinaryExpression that represents a bitwise OR operation.

Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération OR au niveau du bit.Creates a BinaryExpression that represents a bitwise OR operation.

OrAssign(Expression, Expression) OrAssign(Expression, Expression) OrAssign(Expression, Expression) OrAssign(Expression, Expression)

Crée un BinaryExpression qui représente une opération d'assignation OR au niveau du bit.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération d'assignation OR au niveau du bit.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Crée un BinaryExpression qui représente une opération d'assignation OR au niveau du bit.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrElse(Expression, Expression) OrElse(Expression, Expression) OrElse(Expression, Expression) 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.Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false.

OrElse(Expression, Expression, MethodInfo) OrElse(Expression, Expression, MethodInfo) OrElse(Expression, Expression, MethodInfo) 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.Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false.

Parameter(Type) Parameter(Type) Parameter(Type) 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.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

Parameter(Type, String) Parameter(Type, String) Parameter(Type, String) 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.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

PostDecrementAssign(Expression) PostDecrementAssign(Expression) PostDecrementAssign(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.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression.

PostDecrementAssign(Expression, MethodInfo) PostDecrementAssign(Expression, MethodInfo) PostDecrementAssign(Expression, MethodInfo) 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.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression.

PostIncrementAssign(Expression) PostIncrementAssign(Expression) PostIncrementAssign(Expression) 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.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression.

PostIncrementAssign(Expression, MethodInfo) PostIncrementAssign(Expression, MethodInfo) PostIncrementAssign(Expression, MethodInfo) 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.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression.

Power(Expression, Expression) Power(Expression, Expression) Power(Expression, Expression) Power(Expression, Expression)

Crée un BinaryExpression qui représente l'élévation d'un nombre à une puissance.Creates a BinaryExpression that represents raising a number to a power.

Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente l'élévation d'un nombre à une puissance.Creates a BinaryExpression that represents raising a number to a power.

PowerAssign(Expression, Expression) PowerAssign(Expression, Expression) PowerAssign(Expression, Expression) 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.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PowerAssign(Expression, Expression, MethodInfo) PowerAssign(Expression, Expression, MethodInfo) PowerAssign(Expression, Expression, MethodInfo) 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.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) 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.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PreDecrementAssign(Expression) PreDecrementAssign(Expression) PreDecrementAssign(Expression) PreDecrementAssign(Expression)

Crée un UnaryExpression qui décrémente l'expression de 1 et réassigne le résultat à l'expression.Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression.

PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui décrémente l'expression de 1 et réassigne le résultat à l'expression.Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression.

PreIncrementAssign(Expression) PreIncrementAssign(Expression) PreIncrementAssign(Expression) PreIncrementAssign(Expression)

Crée un UnaryExpression qui incrémente l'expression de 1 et réassigne le résultat à l'expression.Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression.

PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo)

Crée un UnaryExpression qui incrémente l'expression de 1 et réassigne le résultat à l'expression.Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression.

Property(Expression, MethodInfo) Property(Expression, MethodInfo) Property(Expression, MethodInfo) 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é.Creates a MemberExpression that represents accessing a property by using a property accessor method.

Property(Expression, PropertyInfo) Property(Expression, PropertyInfo) Property(Expression, PropertyInfo) Property(Expression, PropertyInfo)

Crée un MemberExpression qui représente l'accès à une propriété.Creates a MemberExpression that represents accessing a property.

Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[])

Crée un IndexExpression qui représente l'accès à une propriété indexée.Creates an IndexExpression representing the access to an indexed property.

Property(Expression, PropertyInfo, IEnumerable<Expression>) Property(Expression, PropertyInfo, IEnumerable<Expression>) Property(Expression, PropertyInfo, IEnumerable<Expression>) Property(Expression, PropertyInfo, IEnumerable<Expression>)

Crée un IndexExpression qui représente l'accès à une propriété indexée.Creates an IndexExpression representing the access to an indexed property.

Property(Expression, String) Property(Expression, String) Property(Expression, String) Property(Expression, String)

Crée un MemberExpression qui représente l'accès à une propriété.Creates a MemberExpression that represents accessing a property.

Property(Expression, String, Expression[]) Property(Expression, String, Expression[]) Property(Expression, String, Expression[]) Property(Expression, String, Expression[])

Crée un IndexExpression qui représente l'accès à une propriété indexée.Creates an IndexExpression representing the access to an indexed property.

Property(Expression, Type, String) Property(Expression, Type, String) Property(Expression, Type, String) Property(Expression, Type, String)

Crée un MemberExpression qui accède à une propriété.Creates a MemberExpression accessing a property.

PropertyOrField(Expression, String) PropertyOrField(Expression, String) PropertyOrField(Expression, String) PropertyOrField(Expression, String)

Crée un MemberExpression qui représente l'accès à une propriété ou un champ.Creates a MemberExpression that represents accessing a property or field.

Quote(Expression) Quote(Expression) Quote(Expression) Quote(Expression)

Crée un UnaryExpression qui représente une expression ayant une valeur de constante de type Expression.Creates a UnaryExpression that represents an expression that has a constant value of type Expression.

Reduce() Reduce() Reduce() Reduce()

Réduit le nœud en une expression plus simple.Reduces this node to a simpler expression. Si CanReduce retourne la valeur true, cela doit retourner une expression valide.If CanReduce returns true, this should return a valid expression. Cette méthode peut retourner un autre nœud qui doit lui-même être réduit.This method can return another node which itself must be reduced.

ReduceAndCheck() ReduceAndCheck() ReduceAndCheck() ReduceAndCheck()

Réduit le nœud en une expression plus simple.Reduces this node to a simpler expression. Si CanReduce retourne la valeur true, cela doit retourner une expression valide.If CanReduce returns true, this should return a valid expression. Cette méthode peut retourner un autre nœud qui doit lui-même être réduit.This method can return another node which itself must be reduced.

ReduceExtensions() ReduceExtensions() ReduceExtensions() 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.Reduces the expression to a known node type (that is not an Extension node) or just returns the expression if it is already a known type.

ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'égalité des références.Creates a BinaryExpression that represents a reference equality comparison.

ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression)

Crée un BinaryExpression qui représente une comparaison d'inégalité des références.Creates a BinaryExpression that represents a reference inequality comparison.

Rethrow() Rethrow() Rethrow() Rethrow()

Crée un UnaryExpression qui représente une nouvelle levée d'exception.Creates a UnaryExpression that represents a rethrowing of an exception.

Rethrow(Type) Rethrow(Type) Rethrow(Type) Rethrow(Type)

Crée un UnaryExpression qui représente une nouvelle levée d'une exception avec un type donné.Creates a UnaryExpression that represents a rethrowing of an exception with a given type.

Return(LabelTarget) Return(LabelTarget) Return(LabelTarget) Return(LabelTarget)

Crée un GotoExpression qui représente une instruction Return.Creates a GotoExpression representing a return statement.

Return(LabelTarget, Expression) Return(LabelTarget, Expression) Return(LabelTarget, Expression) Return(LabelTarget, Expression)

Crée un GotoExpression qui représente une instruction Return.Creates a GotoExpression representing a return statement. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type)

Crée un GotoExpression qui représente une instruction Return avec le type spécifié.Creates a GotoExpression representing a return statement with the specified type. La valeur passée à l'étiquette au moment du saut peut être spécifiée.The value passed to the label upon jumping can be specified.

Return(LabelTarget, Type) Return(LabelTarget, Type) Return(LabelTarget, Type) Return(LabelTarget, Type)

Crée un GotoExpression qui représente une instruction Return avec le type spécifié.Creates a GotoExpression representing a return statement with the specified type.

RightShift(Expression, Expression) RightShift(Expression, Expression) RightShift(Expression, Expression) RightShift(Expression, Expression)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la droite.Creates a BinaryExpression that represents a bitwise right-shift operation.

RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo)

Crée un BinaryExpression qui représente une opération de bits de décalage vers la droite.Creates a BinaryExpression that represents a bitwise right-shift operation.

RightShiftAssign(Expression, Expression) RightShiftAssign(Expression, Expression) RightShiftAssign(Expression, Expression) 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.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RightShiftAssign(Expression, Expression, MethodInfo) RightShiftAssign(Expression, Expression, MethodInfo) RightShiftAssign(Expression, Expression, MethodInfo) 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.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) 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.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>)

Crée une instance de RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[])

Crée une instance de RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

Subtract(Expression, Expression) Subtract(Expression, Expression) Subtract(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking.

Subtract(Expression, Expression, MethodInfo) Subtract(Expression, Expression, MethodInfo) Subtract(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking.

SubtractAssign(Expression, Expression) SubtractAssign(Expression, Expression) SubtractAssign(Expression, Expression) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssign(Expression, Expression, MethodInfo) SubtractAssign(Expression, Expression, MethodInfo) SubtractAssign(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssignChecked(Expression, Expression) SubtractAssignChecked(Expression, Expression) SubtractAssignChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractAssignChecked(Expression, Expression, MethodInfo) SubtractAssignChecked(Expression, Expression, MethodInfo) SubtractAssignChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) 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é.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractChecked(Expression, Expression) SubtractChecked(Expression, Expression) SubtractChecked(Expression, Expression) 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é.Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking.

SubtractChecked(Expression, Expression, MethodInfo) SubtractChecked(Expression, Expression, MethodInfo) SubtractChecked(Expression, Expression, MethodInfo) 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é.Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking.

Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

Switch(Expression, Expression, MethodInfo, SwitchCase[]) Switch(Expression, Expression, MethodInfo, SwitchCase[]) Switch(Expression, Expression, MethodInfo, SwitchCase[]) Switch(Expression, Expression, MethodInfo, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

Switch(Expression, Expression, SwitchCase[]) Switch(Expression, Expression, SwitchCase[]) Switch(Expression, Expression, SwitchCase[]) Switch(Expression, Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

Switch(Expression, SwitchCase[]) Switch(Expression, SwitchCase[]) Switch(Expression, SwitchCase[]) Switch(Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch sans casse par défaut.Creates a SwitchExpression that represents a switch statement without a default case.

Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>) Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

Switch(Type, Expression, Expression, MethodInfo, SwitchCase[]) Switch(Type, Expression, Expression, MethodInfo, SwitchCase[]) Switch(Type, Expression, Expression, MethodInfo, SwitchCase[]) Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[])

Crée un SwitchCase pour une utilisation dans un SwitchExpression.Creates a SwitchCase for use in a SwitchExpression.

SwitchCase(Expression, IEnumerable<Expression>) SwitchCase(Expression, IEnumerable<Expression>) SwitchCase(Expression, IEnumerable<Expression>) SwitchCase(Expression, IEnumerable<Expression>)

Crée un objet SwitchCase à utiliser dans un objet SwitchExpression.Creates a SwitchCase object to be used in a SwitchExpression object.

SymbolDocument(String) SymbolDocument(String) SymbolDocument(String) SymbolDocument(String)

Crée une instance de SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid) SymbolDocument(String, Guid) SymbolDocument(String, Guid) SymbolDocument(String, Guid)

Crée une instance de SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid)

Crée une instance de SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid)

Crée une instance de SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

Throw(Expression) Throw(Expression) Throw(Expression) Throw(Expression)

Crée un UnaryExpression qui représente une levée d'exception.Creates a UnaryExpression that represents a throwing of an exception.

Throw(Expression, Type) Throw(Expression, Type) Throw(Expression, Type) Throw(Expression, Type)

Crée un UnaryExpression qui représente la levée d'une exception avec un type donné.Creates a UnaryExpression that represents a throwing of an exception with a given type.

ToString() ToString() ToString() ToString()

Retourne une représentation textuelle de Expression.Returns a textual representation of the Expression.

TryCatch(Expression, CatchBlock[]) TryCatch(Expression, CatchBlock[]) TryCatch(Expression, CatchBlock[]) 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.Creates a TryExpression representing a try block with any number of catch statements and neither a fault nor finally block.

TryCatchFinally(Expression, Expression, CatchBlock[]) TryCatchFinally(Expression, Expression, CatchBlock[]) TryCatchFinally(Expression, Expression, CatchBlock[]) 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.Creates a TryExpression representing a try block with any number of catch statements and a finally block.

TryFault(Expression, Expression) TryFault(Expression, Expression) TryFault(Expression, Expression) TryFault(Expression, Expression)

Crée un TryExpression qui représente un bloc Try avec un bloc Fault et aucune instruction Catch.Creates a TryExpression representing a try block with a fault block and no catch statements.

TryFinally(Expression, Expression) TryFinally(Expression, Expression) TryFinally(Expression, Expression) TryFinally(Expression, Expression)

Crée un TryExpression qui représente un bloc Try avec un bloc Finally et aucune instruction Catch.Creates a TryExpression representing a try block with a finally block and no catch statements.

TryGetActionType(Type[], Type) TryGetActionType(Type[], Type) TryGetActionType(Type[], Type) 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.Creates a Type object that represents a generic System.Action delegate type that has specific type arguments.

TryGetFuncType(Type[], Type) TryGetFuncType(Type[], Type) TryGetFuncType(Type[], Type) 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.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. Le dernier argument de type spécifie le type de retour du délégué créé.The last type argument specifies the return type of the created delegate.

TypeAs(Expression, Type) TypeAs(Expression, Type) TypeAs(Expression, Type) 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.Creates a UnaryExpression that represents an explicit reference or boxing conversion where null is supplied if the conversion fails.

TypeEqual(Expression, Type) TypeEqual(Expression, Type) TypeEqual(Expression, Type) TypeEqual(Expression, Type)

Crée un TypeBinaryExpression qui compare l'identité de type à l'exécution.Creates a TypeBinaryExpression that compares run-time type identity.

TypeIs(Expression, Type) TypeIs(Expression, Type) TypeIs(Expression, Type) TypeIs(Expression, Type)

Crée un TypeBinaryExpression.Creates a TypeBinaryExpression.

UnaryPlus(Expression) UnaryPlus(Expression) UnaryPlus(Expression) UnaryPlus(Expression)

Crée un UnaryExpression qui représente une opération plus unaire.Creates a UnaryExpression that represents a unary plus operation.

UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo)

Crée un UnaryExpression qui représente une opération plus unaire.Creates a UnaryExpression that represents a unary plus operation.

Unbox(Expression, Type) Unbox(Expression, Type) Unbox(Expression, Type) Unbox(Expression, Type)

Crée un UnaryExpression qui représente un unboxing explicite.Creates a UnaryExpression that represents an explicit unboxing.

Variable(Type) Variable(Type) Variable(Type) 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.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

Variable(Type, String) Variable(Type, String) Variable(Type, String) 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.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor)

Réduit le nœud puis appelle le délégué visiteur sur l'expression réduite.Reduces the node and then calls the visitor delegate on the reduced expression. La méthode lève une exception si le nœud n'est pas réductible.The method throws an exception if the node is not reducible.

S’applique à