LambdaExpression Classe

Référence

Définition

Espace de noms:: System.Linq.Expressions

Assembly:: System.Linq.Expressions.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Source:: LambdaExpression.cs

Source:: LambdaExpression.cs

Source:: LambdaExpression.cs

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.

Décrit une expression lambda. Capture un bloc de code semblable au corps d'une méthode .NET.

public ref class LambdaExpression abstract : System::Linq::Expressions::Expression

public ref class LambdaExpression : System::Linq::Expressions::Expression

public abstract class LambdaExpression : System.Linq.Expressions.Expression

public class LambdaExpression : System.Linq.Expressions.Expression

type LambdaExpression = class
    inherit Expression

Public MustInherit Class LambdaExpression
Inherits Expression

Public Class LambdaExpression
Inherits Expression

Héritage: Object

Expression
LambdaExpression

Dérivé: System.Linq.Expressions.Expression<TDelegate>

Exemples

L’exemple suivant montre comment créer une expression qui représente une expression lambda qui ajoute 1 à l’argument passé à l’aide de la Lambda méthode .

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

// A parameter for the lambda expression.
ParameterExpression paramExpr = Expression.Parameter(typeof(int), "arg");

// This expression represents a lambda expression
// that adds 1 to the parameter value.
LambdaExpression lambdaExpr = Expression.Lambda(
    Expression.Add(
        paramExpr,
        Expression.Constant(1)
    ),
    new List<ParameterExpression>() { paramExpr }
);

// Print out the expression.
Console.WriteLine(lambdaExpr);

// Compile and run the lamda expression.
// The value of the parameter is 1.
Console.WriteLine(lambdaExpr.Compile().DynamicInvoke(1));

// This code example produces the following output:
//
// arg => (arg +1)
// 2

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

' A parameter for the lambda expression.
Dim paramExpr As ParameterExpression = Expression.Parameter(GetType(Integer), "arg")

' This expression represents a lambda expression
' that adds 1 to the parameter value.
Dim lambdaExpr As LambdaExpression = Expression.Lambda(
        Expression.Add(
            paramExpr,
            Expression.Constant(1)
        ),
        New List(Of ParameterExpression)() From {paramExpr}
    )

' Print out the expression.
Console.WriteLine(lambdaExpr)

' Compile and run the lamda expression.
' The value of the parameter is 1.
Console.WriteLine(lambdaExpr.Compile().DynamicInvoke(1))

' This code example produces the following output:
'
' arg => (arg +1)
' 2

Remarques

Le LambdaExpression type représente une expression lambda sous la forme d’une arborescence d’expressions. Le Expression<TDelegate> type, qui dérive de LambdaExpression et capture plus explicitement le type de l’expression lambda, peut également être utilisé pour représenter une expression lambda. Au moment de l’exécution, un nœud d’arborescence d’expressions qui représente une expression lambda est toujours de type Expression<TDelegate>.

La valeur de la NodeType propriété d’un LambdaExpression est Lambda.

Utilisez les méthodes de Lambda fabrique pour créer un LambdaExpression objet.

Propriétés

Body	Obtient le corps de l'expression lambda.
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.
NodeType	Retourne le type de nœud de cette Expression.
NodeType	Obtient le type de nœud de ce Expression. (Hérité de Expression)
Parameters	Obtient les paramètres de l'expression lambda.
ReturnType	Obtient le type de retour de l'expression lambda.
TailCall	Obtient la valeur qui indique si l'expression lambda doit être compilée avec l'optimisation d'appel tail.
Type	Obtient le type statique de l'expression que ce Expression représente.
Type	Obtient le type statique de l'expression que ce Expression représente. (Hérité de Expression)

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()	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.
Compile(DebugInfoGenerator)	Produit un délégué qui représente l'expression lambda.
CompileToMethod(MethodBuilder)	Compile le lambda dans une définition de méthode.
CompileToMethod(MethodBuilder, DebugInfoGenerator)	Compile le lambda dans une définition de méthode, ainsi que des informations de débogage personnalisées.
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)
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 à

Partager via