BlockExpression Klasse

Definition

Stellt einen Block mit einer Sequenz von Ausdrücken dar, für die Variablen definiert werden können.Represents a block that contains a sequence of expressions where variables can be defined.

public ref class BlockExpression : System::Linq::Expressions::Expression
public class BlockExpression : System.Linq.Expressions.Expression
type BlockExpression = class
    inherit Expression
Public Class BlockExpression
Inherits Expression
Vererbung
BlockExpression

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie ein Block Ausdruck erstellt wird.The following code example shows how to create a block expression. Der Block Ausdruck besteht aus zwei MethodCallExpression -Objekten und einem- ConstantExpression Objekt.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

Hinweise

Die- Block Methoden können verwendet werden, um eine zu erstellen BlockExpression .The Block methods can be used to create a BlockExpression.

Eigenschaften

CanReduce

Gibt an, dass der Knoten zu einem einfacheren Knoten reduziert werden kann.Indicates that the node can be reduced to a simpler node. Wenn true zurückgegeben wird, kann Reduce() aufgerufen werden, um das reduzierte Formular zu erzeugen.If this returns true, Reduce() can be called to produce the reduced form.

(Geerbt von Expression)
Expressions

Ruft die Ausdrücke in diesem Block ab.Gets the expressions in this block.

NodeType

Gibt den Knotentyp dieses Ausdrucks zurück.Returns the node type of this expression. Erweiterungsknoten sollten Extension beim Überschreiben dieser Methode zurückgeben.Extension nodes should return Extension when overriding this method.

Result

Ruft den letzten Ausdruck in diesem Block ab.Gets the last expression in this block.

Type

Ruft den statischen Typ des Ausdrucks ab, den dieser Expression darstellt.Gets the static type of the expression that this Expression represents.

Variables

Ruft die in diesem Block definierten Variablen ab.Gets the variables defined in this block.

Methoden

Accept(ExpressionVisitor)

Sendet an die spezifische Visit-Methode für diesen Knotentyp.Dispatches to the specific visit method for this node type. Beispielsweise ruft MethodCallExpression die Methode VisitMethodCall(MethodCallExpression) auf.For example, MethodCallExpression calls the VisitMethodCall(MethodCallExpression).

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Reduce()

Reduziert diesen Knoten zu einem einfacheren Ausdruck.Reduces this node to a simpler expression. Wenn CanReduce true zurückgibt, sollte ein gültiger Ausdruck zurückgegeben werden.If CanReduce returns true, this should return a valid expression. Diese Methode kann einen anderen Knoten zurückgeben, der selbst reduziert werden muss.This method can return another node which itself must be reduced.

(Geerbt von Expression)
ReduceAndCheck()

Reduziert diesen Knoten zu einem einfacheren Ausdruck.Reduces this node to a simpler expression. Wenn CanReduce true zurückgibt, sollte ein gültiger Ausdruck zurückgegeben werden.If CanReduce returns true, this should return a valid expression. Diese Methode kann einen anderen Knoten zurückgeben, der selbst reduziert werden muss.This method can return another node which itself must be reduced.

(Geerbt von Expression)
ReduceExtensions()

Reduziert den Ausdruck zu einem bekannten Knotentyp (kein Erweiterungsknoten) oder gibt nur den Ausdruck zurück, wenn es sich um einen bereits bekannten Typ handelt.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.

(Geerbt von Expression)
ToString()

Gibt eine Textdarstellung des Expression zurück.Returns a textual representation of the Expression.

(Geerbt von Expression)
Update(IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Erstellt einen neuen Ausdruck, der diesem ähnelt, verwendet jedoch die angegebenen untergeordneten Elemente.Creates a new expression that is like this one, but using the supplied children. Wenn alle untergeordneten Elemente identisch sind, wird dieser Ausdruck zurückgegeben.If all of the children are the same, it will return this expression.

VisitChildren(ExpressionVisitor)

Reduziert den Knoten und ruft dann den Visitor-Delegaten für den reduzierten Ausdruck auf.Reduces the node and then calls the visitor delegate on the reduced expression. Die Methode löst eine Ausnahme aus, wenn der Knoten nicht reduziert werden kann.The method throws an exception if the node is not reducible.

(Geerbt von Expression)

Gilt für: