Condividi tramite


SwitchExpression Classe

Definizione

Rappresenta un'espressione di controllo che gestisce più selezioni passando il controllo a SwitchCase.

public ref class SwitchExpression sealed : System::Linq::Expressions::Expression
public sealed class SwitchExpression : System.Linq.Expressions.Expression
type SwitchExpression = class
    inherit Expression
Public NotInheritable Class SwitchExpression
Inherits Expression
Ereditarietà
SwitchExpression

Esempio

Nell'esempio seguente viene illustrato come creare un'espressione che rappresenta un'istruzione switch con maiuscole e minuscole predefinite usando il Switch metodo .

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

// An expression that represents the switch value.
ConstantExpression switchValue = Expression.Constant(3);

// This expression represents a switch statement
// that has a default case.
SwitchExpression switchExpr =
    Expression.Switch(
        switchValue,
        Expression.Call(
                    null,
                    typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),
                    Expression.Constant("Default")
                ),
        new SwitchCase[] {
            Expression.SwitchCase(
                Expression.Call(
                    null,
                    typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),
                    Expression.Constant("First")
                ),
                Expression.Constant(1)
            ),
            Expression.SwitchCase(
                Expression.Call(
                    null,
                    typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),
                    Expression.Constant("Second")
                ),
                Expression.Constant(2)
            )
        }
    );

// The following statement first creates an expression tree,
// then compiles it, and then runs it.
Expression.Lambda<Action>(switchExpr).Compile()();

// This code example produces the following output:
//
// Default
' Add the following directive to the file:
' Imports System.Linq.Expressions

' An expression that represents the switch value.
Dim switchValue As ConstantExpression = Expression.Constant(3)

' This expression represents a switch statement 
' that has a default case.
Dim switchExpr As SwitchExpression =
Expression.Switch(
    switchValue,
    Expression.Call(
                Nothing,
                GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)}),
                Expression.Constant("Default")
            ),
    New SwitchCase() {
        Expression.SwitchCase(
            Expression.Call(
                Nothing,
                GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)}),
                Expression.Constant("First")
            ),
            Expression.Constant(1)
        ),
        Expression.SwitchCase(
            Expression.Call(
                Nothing,
                GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)}),
                Expression.Constant("Second")
            ),
            Expression.Constant(2)
        )
    }
)

' The following statement first creates an expression tree,
' then compiles it, and then runs it.
Expression.Lambda(Of Action)(switchExpr).Compile()()

' This code example produces the following output:
'
' Default

Proprietà

CanReduce

Indica che il nodo può essere ridotto a un nodo più semplice. Se restituisce true, è possibile chiamare Reduce() per generare la forma ridotta.

(Ereditato da Expression)
Cases

Ottiene la raccolta di oggetti SwitchCase per l'opzione.

Comparison

Ottiene il metodo di confronto di uguaglianze, se presente.

DefaultBody

Ottiene il test per lo switch.

NodeType

Restituisce il tipo di nodo di questo oggetto Expression. I nodi di estensione devono restituire Extension quando si esegue l'override di questo metodo.

SwitchValue

Ottiene il test per lo switch.

Type

Ottiene il tipo statico dell'espressione rappresentata da Expression.

Metodi

Accept(ExpressionVisitor)

Invia al metodo Visit specifico per questo tipo di nodo. Ad esempio, MethodCallExpression chiama VisitMethodCall(MethodCallExpression).

(Ereditato da Expression)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
Reduce()

Riduce questo nodo a un'espressione più semplice. Se CanReduce restituisce true, deve essere restituita un'espressione valida. Questo metodo può restituire un altro nodo che deve essere a sua volta ridotto.

(Ereditato da Expression)
ReduceAndCheck()

Riduce questo nodo a un'espressione più semplice. Se CanReduce restituisce true, deve essere restituita un'espressione valida. Questo metodo può restituire un altro nodo che deve essere a sua volta ridotto.

(Ereditato da Expression)
ReduceExtensions()

Riduce l'espressione a un tipo di nodo noto (diverso da un nodo di estensione) o restituisce solo l'espressione se è già un tipo noto.

(Ereditato da Expression)
ToString()

Restituisce una rappresentazione testuale di Expression.

(Ereditato da Expression)
Update(Expression, IEnumerable<SwitchCase>, Expression)

Crea una nuova espressione simile a questa, ma che usa gli elementi figlio specificati. Se tutti gli elementi figlio sono uguali, verrà restituita questa espressione.

VisitChildren(ExpressionVisitor)

Riduce il nodo, quindi chiama il delegato del visitatore sull'espressione ridotta. Se il nodo non è riducibile, il metodo genera un'eccezione.

(Ereditato da Expression)

Si applica a