SwitchExpression Clase

Definición

Representa una expresión de control que controla varias selecciones pasando el control 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
Herencia
SwitchExpression

Ejemplos

En el ejemplo siguiente se muestra cómo crear una expresión que representa una instrucción switch que tiene un caso predeterminado mediante el Switch método .

// 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

Propiedades

Nombre Description
CanReduce

Indica que el nodo se puede reducir a un nodo más sencillo. Si devuelve true, se puede llamar a Reduce() para generar el formulario reducido.

(Heredado de Expression)
Cases

Obtiene la colección de SwitchCase objetos para el modificador.

Comparison

Obtiene el método de comparación de igualdad, si existe.

DefaultBody

Obtiene la prueba del modificador.

NodeType

Devuelve el tipo de nodo de esta expresión. Los nodos de extensión deben devolverse Extension al invalidar este método.

SwitchValue

Obtiene la prueba del modificador.

Type

Obtiene el tipo estático de la expresión que Expression representa.

Métodos

Nombre Description
Accept(ExpressionVisitor)

Envía al método de visita específico para este tipo de nodo. Por ejemplo, MethodCallExpression llama a VisitMethodCall(MethodCallExpression).

(Heredado de Expression)
Equals(Object)

Determina si el objeto especificado es igual al objeto actual.

(Heredado de Object)
GetHashCode()

Actúa como función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Objectactual.

(Heredado de Object)
Reduce()

Reduce este nodo a una expresión más sencilla. Si CanReduce devuelve true, debe devolver una expresión válida. Este método puede devolver otro nodo que se debe reducir.

(Heredado de Expression)
ReduceAndCheck()

Reduce este nodo a una expresión más sencilla. Si CanReduce devuelve true, debe devolver una expresión válida. Este método puede devolver otro nodo que se debe reducir.

(Heredado de Expression)
ReduceExtensions()

Reduce la expresión a un tipo de nodo conocido (que no es un nodo de extensión) o simplemente devuelve la expresión si ya es un tipo conocido.

(Heredado de Expression)
ToString()

Devuelve una representación textual de .Expression

(Heredado de Expression)
Update(Expression, IEnumerable<SwitchCase>, Expression)

Crea una nueva expresión similar a esta, pero que usa los elementos secundarios proporcionados. Si todos los elementos secundarios son iguales, devolverá esta expresión.

VisitChildren(ExpressionVisitor)

Reduce el nodo y, a continuación, llama al delegado de visitante en la expresión reducida. El método produce una excepción si el nodo no se puede deducir.

(Heredado de Expression)

Se aplica a