Expression<TDelegate> Classe

Référence

Définition

Espace de noms:: System.Linq.Expressions

Assembly:: System.Linq.Expressions.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente une expression lambda fortement typée en tant que structure de données sous la forme d'une arborescence d'expression. Cette classe ne peut pas être héritée.

generic <typename TDelegate>
public ref class Expression sealed : System::Linq::Expressions::LambdaExpression

public sealed class Expression<TDelegate> : System.Linq.Expressions.LambdaExpression

type Expression<'Delegate> = class
    inherit LambdaExpression

Public NotInheritable Class Expression(Of TDelegate)
Inherits LambdaExpression

Paramètres de type

TDelegate

Type du délégué représenté par le Expression<TDelegate>.

Héritage: Object

Expression

LambdaExpression
Expression<TDelegate>

Exemples

L’exemple de code suivant montre comment représenter une expression lambda en tant que code exécutable sous la forme d’un délégué et en tant que données sous la forme d’une arborescence d’expressions. Il montre également comment transformer l’arborescence d’expressions en code exécutable à l’aide de la Compile méthode.


// Lambda expression as executable code.
Func<int, bool> deleg = i => i < 5;
// Invoke the delegate and display the output.
Console.WriteLine("deleg(4) = {0}", deleg(4));

// Lambda expression as data in the form of an expression tree.
System.Linq.Expressions.Expression<Func<int, bool>> expr = i => i < 5;
// Compile the expression tree into executable code.
Func<int, bool> deleg2 = expr.Compile();
// Invoke the method and print the output.
Console.WriteLine("deleg2(4) = {0}", deleg2(4));

/*  This code produces the following output:

    deleg(4) = True
    deleg2(4) = True
*/


' Lambda expression as executable code.
Dim deleg As Func(Of Integer, Boolean) = Function(ByVal i) i < 5
' Invoke the delegate and display the output.
MsgBox(String.Format("deleg(4) = {0}", deleg(4)))

' Lambda expression as data in the form of an expression tree.
Dim expr As System.Linq.Expressions.Expression(Of Func(Of Integer, Boolean)) = Function(ByVal i) i < 5
' Compile the expression tree into executable code.
Dim deleg2 As Func(Of Integer, Boolean) = expr.Compile()
' Invoke the method and print the output.
MsgBox(String.Format("deleg2(4) = {0}", deleg2(4)))

' This code produces the following output:
'
' deleg(4) = True
' deleg2(4) = True

Remarques

Lorsqu’une expression lambda est affectée à une variable, un champ ou un paramètre dont le type est Expression<TDelegate>, le compilateur émet des instructions pour générer une arborescence d’expressions.

Notes

Une conversion d’une expression lambda en type Expression<D> (Expression(Of D)dans Visual Basic) existe si une conversion de l’expression lambda en délégué de type D existe. Toutefois, la conversion peut échouer, par exemple, si le corps de l’expression lambda est un bloc. Cela signifie que les délégués et les arborescences d’expressions se comportent de la même façon en ce qui concerne la résolution de surcharge.

L’arborescence d’expressions est une représentation de données en mémoire de l’expression lambda. L’arborescence d’expressions rend la structure de l’expression lambda transparente et explicite. Vous pouvez interagir avec les données de l’arborescence d’expressions comme vous le pouvez avec n’importe quelle autre structure de données.

La possibilité de traiter des expressions comme des structures de données permet aux API de recevoir du code utilisateur dans un format qui peut être inspecté, transformé et traité de manière personnalisée. Par exemple, l’implémentation de l’accès aux données LINQ to SQL utilise cette fonctionnalité pour traduire des arborescences d’expressions en instructions Transact-SQL qui peuvent être évaluées par la base de données.

De nombreux opérateurs de requête standard définis dans la Queryable classe ont un ou plusieurs paramètres de type Expression<TDelegate>.

L’un NodeType Expression<TDelegate> est Lambda.

Utilisez la ou Lambda<TDelegate>(Expression, ParameterExpression[]) la Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) méthode pour créer un Expression<TDelegate> objet.

Propriétés

Body	Obtient le corps de l'expression lambda. (Hérité de LambdaExpression)
CanReduce	Indique que le nœud peut être réduit à un nœud plus simple. Si la valeur retournée est true, Reduce() peut être appelé pour produire la forme réduite. (Hérité de Expression)
Name	Obtient le nom de l'expression lambda. (Hérité de LambdaExpression)
NodeType	Retourne le type de nœud de cette Expression. (Hérité de LambdaExpression)
Parameters	Obtient les paramètres de l'expression lambda. (Hérité de LambdaExpression)
ReturnType	Obtient le type de retour de l'expression lambda. (Hérité de LambdaExpression)
TailCall	Obtient la valeur qui indique si l'expression lambda doit être compilée avec l'optimisation d'appel tail. (Hérité de LambdaExpression)
Type	Obtient le type statique de l'expression que ce Expression représente. (Hérité de LambdaExpression)

Méthodes

Accept(ExpressionVisitor)	Distribue à la méthode de visite spécifique à ce type de nœud. Par exemple, MethodCallExpression appelle VisitMethodCall(MethodCallExpression). (Hérité de Expression)
Compile()	Compile l'expression lambda décrite par l'arborescence de l'expression dans le code exécutable et produit un délégué qui représente l'expression lambda.
Compile(Boolean)	Compile l’expression lambda décrite par l’arborescence de l’expression dans du code interprété ou compilé, et produit un délégué qui représente l’expression lambda.
Compile(Boolean)	Produit un délégué interprété ou compilé qui représente l’expression lambda. (Hérité de LambdaExpression)
Compile(DebugInfoGenerator)	Produit un délégué qui représente l'expression lambda.
Compile(DebugInfoGenerator)	Produit un délégué qui représente l'expression lambda. (Hérité de LambdaExpression)
CompileToMethod(MethodBuilder)	Compile le lambda dans une définition de méthode. (Hérité de LambdaExpression)
CompileToMethod(MethodBuilder, DebugInfoGenerator)	Compile le lambda dans une définition de méthode, ainsi que des informations de débogage personnalisées. (Hérité de LambdaExpression)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Reduce()	Réduit le nœud en une expression plus simple. Si CanReduce retourne la valeur true, cela doit retourner une expression valide. Cette méthode peut retourner un autre nœud qui doit lui-même être réduit. (Hérité de Expression)
ReduceAndCheck()	Réduit le nœud en une expression plus simple. Si CanReduce retourne la valeur true, cela doit retourner une expression valide. Cette méthode peut retourner un autre nœud qui doit lui-même être réduit. (Hérité de Expression)
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. (Hérité de Expression)
ToString()	Retourne une représentation textuelle de Expression. (Hérité de Expression)
Update(Expression, IEnumerable<ParameterExpression>)	Crée une expression qui est semblable à celle-ci, mais en utilisant les enfants fournis. Si tous les enfants sont identiques, cette expression est retournée.
VisitChildren(ExpressionVisitor)	Réduit le nœud puis appelle le délégué visiteur sur l'expression réduite. La méthode lève une exception si le nœud n'est pas réductible. (Hérité de Expression)

S’applique à