System.Linq.Expressions Namespace

L'espace de noms System.Linq.Expressions contient les classes, interfaces et énumérations qui activent les expressions de code de niveau langage à représenter comme des objets sous la forme d'arborescences d'expression. The System.Linq.Expressions namespace contains classes, interfaces and enumerations that enable language-level code expressions to be represented as objects in the form of expression trees.

Classes

BinaryExpression

Représente une expression qui comporte un opérateur binaire.Represents an expression that has a binary operator.

BlockExpression

Représente un bloc qui contient une séquence d'expressions où des variables peuvent être définies.Represents a block that contains a sequence of expressions where variables can be defined.

CatchBlock

Représente une instruction catch dans un bloc try.Represents a catch statement in a try block.

ConditionalExpression

Représente une expression qui comporte un opérateur conditionnel.Represents an expression that has a conditional operator.

ConstantExpression

Représente une expression qui comporte une valeur de constante.Represents an expression that has a constant value.

DebugInfoExpression

Émet ou efface un point de séquence pour les informations de débogage.Emits or clears a sequence point for debug information. Cela permet au débogueur de mettre en surbrillance le code source correct pendant le débogage.This allows the debugger to highlight the correct source code when debugging.

DefaultExpression

Représente la valeur par défaut d'un type ou d'une expression vide.Represents the default value of a type or an empty expression.

DynamicExpression

Représente une opération dynamique.Represents a dynamic operation.

DynamicExpressionVisitor

Représente un visiteur ou module de réécriture pour les arborescences d’expression dynamiques.Represents a visitor or rewriter for dynamic expression trees.

ElementInit

Représente un initialiseur pour un élément unique d’une collection IEnumerable.Represents an initializer for a single element of an IEnumerable collection.

Expression

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.

Expression<TDelegate>

Représente une expression lambda fortement typée en tant que structure de données sous la forme d’une arborescence d’expression.Represents a strongly typed lambda expression as a data structure in the form of an expression tree. Cette classe ne peut pas être héritée.This class cannot be inherited.

ExpressionVisitor

Représente un visiteur ou module de réécriture pour les arborescences d’expression.Represents a visitor or rewriter for expression trees.

GotoExpression

Représente un saut inconditionnel.Represents an unconditional jump. Cela inclut les instructions return, break et continue, et d'autres sauts.This includes return statements, break and continue statements, and other jumps.

IndexExpression

Représente l'indexation d'une propriété ou d'un tableau.Represents indexing a property or array.

InvocationExpression

Représente une expression qui applique un délégué ou une expression lambda à une liste d’expressions d’arguments.Represents an expression that applies a delegate or lambda expression to a list of argument expressions.

LabelExpression

Représente une étiquette, qui peut être placée dans tout contexte Expression.Represents a label, which can be put in any Expression context. En cas de saut à cette étiquette, elle a la valeur fournie par le GotoExpression correspondant.If it is jumped to, it will get the value provided by the corresponding GotoExpression. Sinon, elle reçoit la valeur indiquée dans DefaultValue.Otherwise, it receives the value in DefaultValue. Si Type est System.Void, aucune valeur ne doit être fournie.If the Type equals System.Void, no value should be provided.

LabelTarget

Utilisé pour représenter la cible d'un GotoExpression.Used to represent the target of a GotoExpression.

LambdaExpression

Décrit une expression lambda.Describes a lambda expression. Capture un bloc de code semblable au corps d'une méthode .NET.This captures a block of code that is similar to a .NET method body.

ListInitExpression

Représente un appel de constructeur ayant un initialiseur de collection.Represents a constructor call that has a collection initializer.

LoopExpression

Représente une boucle infinie,Represents an infinite loop. qui peut être quittée avec « break ».It can be exited with "break".

MemberAssignment

Représente l'opération d'assignation pour un champ ou une propriété d'un objet.Represents assignment operation for a field or property of an object.

MemberBinding

Fournit la classe de base dont dérivent les classes qui représentent des liaisons utilisées pour initialiser les membres d’un objet nouvellement créé.Provides the base class from which the classes that represent bindings that are used to initialize members of a newly created object derive.

MemberExpression

Représente l'accès à un champ ou une propriété.Represents accessing a field or property.

MemberInitExpression

Représente l'appel d'un constructeur et l'initialisation d'un ou plusieurs membres du nouvel objet.Represents calling a constructor and initializing one or more members of the new object.

MemberListBinding

Représente l’initialisation des éléments d’un membre de collection d’un objet nouvellement créé.Represents initializing the elements of a collection member of a newly created object.

MemberMemberBinding

Représente l'initialisation des membres d'un membre d'un objet nouvellement créé.Represents initializing members of a member of a newly created object.

MethodCallExpression

Représente un appel à une méthode d'instance ou statique.Represents a call to either static or an instance method.

NewArrayExpression

Représente la création d'un tableau et éventuellement l'initialisation des éléments du nouveau tableau.Represents creating a new array and possibly initializing the elements of the new array.

NewExpression

Représente un appel de constructeur.Represents a constructor call.

ParameterExpression

Représente une expression de paramètre nommé.Represents a named parameter expression.

RuntimeVariablesExpression

Expression qui fournit l'autorisation de lecture/écriture d'exécution pour les variables.An expression that provides runtime read/write permission for variables.

SwitchCase

Représente le cas d'un SwitchExpression.Represents one case of a SwitchExpression.

SwitchExpression

Représente une expression de contrôle qui gère des sélections multiples en transmettant le contrôle à SwitchCase.Represents a control expression that handles multiple selections by passing control to SwitchCase.

SymbolDocumentInfo

Stocke les informations nécessaires pour émettre des informations de symboles de débogage pour un fichier source, notamment le nom de fichier et l'identificateur de langue unique.Stores information necessary to emit debugging symbol information for a source file, in particular the file name and unique language identifier.

TryExpression

Représente un bloc try/catch/finally/fault.Represents a try/catch/finally/fault block.

TypeBinaryExpression

Représente une opération entre une expression et un type.Represents an operation between an expression and a type.

UnaryExpression

Représente une expression qui comporte un opérateur unaire.Represents an expression that has a unary operator.

Interfaces

IArgumentProvider

Fournit une interface interne pour accéder aux arguments de plusieurs nœuds d’arborescence (DynamicExpression, ElementInit, MethodCallExpression, InvocationExpression, NewExpression et InexExpression).Provides an internal interface for accessing the arguments of multiple tree nodes (DynamicExpression, ElementInit, MethodCallExpression, InvocationExpression, NewExpression, and InexExpression). Vous ne devez pas utiliser cette API.You should not use this API. Elle est publique uniquement en raison de la refactorisation de la DLL et existe seulement pour optimiser les performances internes.It is only public due to DLL refactoring and exists only for internal performance optimizations.

Ceci permet deux optimisations qui réduisent la taille des arborescences d’expressions.This enables two optimizations which reduce the size of expression trees. La première permet aux nœuds de l’arborescence de conserver un IList<T> au lieu d’un ReadOnlyCollection.The first enables the tree nodes to hold onto an IList<T> instead of a ReadOnlyCollection. IList<T> évite d’allouer ReadOnlyCollection pour chaque nœud.IList<T> saves the cost of allocating the ReadOnlyCollection for each node. La deuxième permet la création de sous-classes spécialisées contenant un nombre spécifique d’arguments (par exemple, Block2, Block3, Block4).The second enables creating specialized subclasses that hold onto a specific number of arguments (for example, Block2, Block3, Block4). Ces nœuds évitent donc l’allocation à la fois d’une ReadOnlyCollection et d’un tableau pour stocker leurs éléments, économisant ainsi 32 octets par nœud.Therefore, these nodes avoid allocating both a ReadOnlyCollection and an array for storing their elements, saving 32 bytes per node.

Les nœuds d’arborescence d’expression continuent d’exposer les propriétés LINQ d’origine de ReadOnlyCollections.The expression tree nodes continue to expose the original LINQ properties of ReadOnlyCollections. Pour cela, les nœuds réutilisent un champ pour stocker le tableau ou un élément qui serait normalement stocké dans le tableau.The nodes do this by re-using a field for storing both the array or an element that would normally be stored in the array.

Dans le cas du tableau, la collection est de type IList<T> au lieu de ReadOnlyCollection<T>.For the array case, the collection is typed to IList<T> instead of ReadOnlyCollection<T>. Quand le nœud est initialement créé, c’est un tableau.When the node is initially constructed it is an array. Quand le compilateur accède aux membres, il utilise cette interface.When the compiler accesses the members it uses this interface. L’accès aux éléments du tableau promeut le tableau en ReadOnlyCollection.Accessing array elements promotes the array to a ReadOnlyCollection.

Dans le cas de l’objet, nous stockons le premier argument dans un champ de type objet.For the object case we store the first argument in a field typed to object. Quand le nœud est initialement créé, le champ contient l’expression.When the node is initially constructed, the field holds the Expression. Le compilateur accède aux arguments via cette interface, et l’accesseur pour le premier argument utilise Expression.ReturnObject pour retourner l’objet qui gère le cas Expression ou ReadOnlyCollection.The compiler accesses arguments through this interface, and the accessor for the first argument uses Expression.ReturnObject to return the object that handles the Expression or ReadOnlyCollection case. Quand l’utilisateur accède à la ReadOnlyCollection, le champ de l’objet est mis à jour pour conserver directement la ReadOnlyCollection.When the user accesses the ReadOnlyCollection, then the object field is updated to hold directly onto the ReadOnlyCollection.

Il est important que les expressions retournent toujours la même ReadOnlyCollection.It is important that the Expressions consistently return the same ReadOnlyCollection. Sinon, l’analyseur d’arborescence de réécriture s’arrêtera.Otherwise, the re-writer tree walker will break. Il s’agit d’une modification en rupture avec LINQ v1, qui retournait des ReadOnlyCollections différentes à partir du même nœud Expression.It is a breaking change from LINQ v1 to return different ReadOnlyCollections form the same Expression node. Les utilisateurs peuvent actuellement s’appuyer sur l’identité de l’objet pour indiquer si le nœud a changé.Currently users can rely on object identity to tell if the node has changed. Le stockage de la ReadOnlyCollection dans un champ surchargé à la fois réduit l’utilisation de la mémoire et maintient la compatibilité pour l’API publique.Storing the ReadOnlyCollection in an overloaded field both reduces memory usage and maintains compatibility for the public API.

IDynamicExpression

Fournit une interface interne pour accéder aux arguments des nœuds d’arborescence DynamicExpression, ainsi qu’aux fonctionnalités CallSite et Rewriting.Provides an internal interface for accessing the arguments of DynamicExpression tree nodes as well as CallSite and Rewriting functionality. Vous ne devez pas utiliser cette API.You should not use this API. Elle est publique uniquement en raison de la refactorisation de la DLL et existe seulement pour optimiser les performances internes.It is only public due to DLL refactoring and exists only for internal performance optimizations.

Énumérations

ExpressionType

Décrit les types de nœud pour les nœuds d’une arborescence d’expression.Describes the node types for the nodes of an expression tree.

GotoExpressionKind

Spécifie le type de saut que GotoExpression représente.Specifies what kind of jump this GotoExpression represents.

MemberBindingType

Décrit les types de liaison utilisés dans les objets MemberInitExpression.Describes the binding types that are used in MemberInitExpression objects.

Remarques

La classe abstraite Expression fournit la racine d’une hiérarchie de classes utilisée pour modéliser les arborescences d’expression.The abstract class Expression provides the root of a class hierarchy used to model expression trees.

Les classes de cet espace de noms qui dérivent de Expression, par exemple MemberExpression et ParameterExpression, sont utilisés pour représenter des nœuds dans une arborescence d’expression.The classes in this namespace that derive from Expression, for example MemberExpression and ParameterExpression, are used to represent nodes in an expression tree. Le Expression contient de la classe static (Shared en Visual Basic) des méthodes de fabrique pour créer des nœuds d’arborescence des différents types d’expression.The Expression class contains static (Shared in Visual Basic) factory methods to create expression tree nodes of the various types.

Le type d’énumération ExpressionType spécifie les types de nœud unique.The enumeration type ExpressionType specifies the unique node types.