Expression.Switch Metodo

Definizione

Spazio dei nomi:

System.Linq.Expressions

Assembly:

System.Linq.Expressions.dll

Crea SwitchExpression che rappresenta un'istruzione switch.

Overload

Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])	Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.
Switch(Expression, SwitchCase[])	Crea un oggetto a SwitchExpression che rappresenta un'istruzioneswitch senza un case predefinito.
Switch(Expression, Expression, SwitchCase[])	Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.
Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)	Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.
Switch(Expression, Expression, MethodInfo, SwitchCase[])	Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.
Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)	Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])

Origine:

SwitchExpression.cs

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(Type ^ type, System::Linq::Expressions::Expression ^ switchValue, System::Linq::Expressions::Expression ^ defaultBody, System::Reflection::MethodInfo ^ comparison, ... cli::array <System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (Type? type, System.Linq.Expressions.Expression switchValue, System.Linq.Expressions.Expression? defaultBody, System.Reflection.MethodInfo? comparison, params System.Linq.Expressions.SwitchCase[]? cases);

static member Switch : Type * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Reflection.MethodInfo * System.Linq.Expressions.SwitchCase[] -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (type As Type, switchValue As Expression, defaultBody As Expression, comparison As MethodInfo, ParamArray cases As SwitchCase()) As SwitchExpression

Parametri

type

Type

Tipo di risultato dell'opzione.

switchValue

Expression

Valore da testare a fronte di ogni case.

defaultBody

Expression

Risultato dell'opzione se switchValue non corrisponde ad alcun caso.

comparison

MethodInfo

Metodo di confronto di uguaglianze da usare.

cases

SwitchCase[]

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.

Switch(Expression, SwitchCase[])

Origine:

SwitchExpression.cs

Crea un oggetto a SwitchExpression che rappresenta un'istruzioneswitch senza un case predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(System::Linq::Expressions::Expression ^ switchValue, ... cli::array <System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (System.Linq.Expressions.Expression switchValue, params System.Linq.Expressions.SwitchCase[]? cases);

static member Switch : System.Linq.Expressions.Expression * System.Linq.Expressions.SwitchCase[] -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (switchValue As Expression, ParamArray cases As SwitchCase()) As SwitchExpression

Parametri

switchValue

Expression

Valore da testare a fronte di ogni case.

cases

SwitchCase[]

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.

Esempio

Nell'esempio seguente viene illustrato come creare un'espressione che rappresenta un'istruzione switch senza maiuscole/minuscole predefinite.

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

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

// This expression represents a switch statement
// without a default case.
SwitchExpression switchExpr =
    Expression.Switch(
        switchValue,
        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:
//
// Second

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

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

' This expression represents a switch statement 
' without a default case.
Dim switchExpr As SwitchExpression =
Expression.Switch(
    switchValue,
    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:
'
' Second

Commenti

Tutti gli SwitchCase oggetti in un SwitchExpression oggetto devono avere lo stesso tipo, a meno che non SwitchExpression abbia il tipo void.

Ogni SwitchCase oggetto ha un'istruzione implicita break , il che significa che non vi è alcun passaggio implicito da un'etichetta case a un'altra.

Se switchValue non corrisponde ad alcun caso, non viene generata alcuna eccezione.

Switch(Expression, Expression, SwitchCase[])

Origine:

SwitchExpression.cs

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(System::Linq::Expressions::Expression ^ switchValue, System::Linq::Expressions::Expression ^ defaultBody, ... cli::array <System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (System.Linq.Expressions.Expression switchValue, System.Linq.Expressions.Expression? defaultBody, params System.Linq.Expressions.SwitchCase[]? cases);

static member Switch : System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.SwitchCase[] -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (switchValue As Expression, defaultBody As Expression, ParamArray cases As SwitchCase()) As SwitchExpression

Parametri

switchValue

Expression

Valore da testare a fronte di ogni case.

defaultBody

Expression

Risultato dell'opzione se switchValue non corrisponde ad alcun caso.

cases

SwitchCase[]

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.

Esempio

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

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

Commenti

Tutti gli SwitchCase oggetti in un SwitchExpression oggetto devono avere lo stesso tipo, a meno che non SwitchExpression abbia il tipo void.

Ogni SwitchCase oggetto ha un'istruzione implicita break , il che significa che non vi è alcun passaggio implicito da un'etichetta case a un'altra.

Se switchValue non corrisponde ad alcun caso, viene eseguito il case predefinito rappresentato da defaultBody .

Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Origine:

SwitchExpression.cs

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(System::Linq::Expressions::Expression ^ switchValue, System::Linq::Expressions::Expression ^ defaultBody, System::Reflection::MethodInfo ^ comparison, System::Collections::Generic::IEnumerable<System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (System.Linq.Expressions.Expression switchValue, System.Linq.Expressions.Expression? defaultBody, System.Reflection.MethodInfo? comparison, System.Collections.Generic.IEnumerable<System.Linq.Expressions.SwitchCase>? cases);

static member Switch : System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Reflection.MethodInfo * seq<System.Linq.Expressions.SwitchCase> -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (switchValue As Expression, defaultBody As Expression, comparison As MethodInfo, cases As IEnumerable(Of SwitchCase)) As SwitchExpression

Parametri

switchValue

Expression

Valore da testare a fronte di ogni case.

defaultBody

Expression

Risultato dell'opzione se switchValue non corrisponde ad alcun caso.

comparison

MethodInfo

Metodo di confronto di uguaglianze da usare.

cases

IEnumerable<SwitchCase>

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.

Switch(Expression, Expression, MethodInfo, SwitchCase[])

Origine:

SwitchExpression.cs

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(System::Linq::Expressions::Expression ^ switchValue, System::Linq::Expressions::Expression ^ defaultBody, System::Reflection::MethodInfo ^ comparison, ... cli::array <System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (System.Linq.Expressions.Expression switchValue, System.Linq.Expressions.Expression? defaultBody, System.Reflection.MethodInfo? comparison, params System.Linq.Expressions.SwitchCase[]? cases);

static member Switch : System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Reflection.MethodInfo * System.Linq.Expressions.SwitchCase[] -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (switchValue As Expression, defaultBody As Expression, comparison As MethodInfo, ParamArray cases As SwitchCase()) As SwitchExpression

Parametri

switchValue

Expression

Valore da testare a fronte di ogni case.

defaultBody

Expression

Risultato dell'opzione se switchValue non corrisponde ad alcun caso.

comparison

MethodInfo

Metodo di confronto di uguaglianze da usare.

cases

SwitchCase[]

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.

Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Origine:

SwitchExpression.cs

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.

public:
 static System::Linq::Expressions::SwitchExpression ^ Switch(Type ^ type, System::Linq::Expressions::Expression ^ switchValue, System::Linq::Expressions::Expression ^ defaultBody, System::Reflection::MethodInfo ^ comparison, System::Collections::Generic::IEnumerable<System::Linq::Expressions::SwitchCase ^> ^ cases);

public static System.Linq.Expressions.SwitchExpression Switch (Type? type, System.Linq.Expressions.Expression switchValue, System.Linq.Expressions.Expression? defaultBody, System.Reflection.MethodInfo? comparison, System.Collections.Generic.IEnumerable<System.Linq.Expressions.SwitchCase>? cases);

static member Switch : Type * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Reflection.MethodInfo * seq<System.Linq.Expressions.SwitchCase> -> System.Linq.Expressions.SwitchExpression

Public Shared Function Switch (type As Type, switchValue As Expression, defaultBody As Expression, comparison As MethodInfo, cases As IEnumerable(Of SwitchCase)) As SwitchExpression

Parametri

type

Type

Tipo di risultato dell'opzione.

switchValue

Expression

Valore da testare a fronte di ogni case.

defaultBody

Expression

Risultato dell'opzione se switchValue non corrisponde ad alcun caso.

comparison

MethodInfo

Metodo di confronto di uguaglianze da usare.

cases

IEnumerable<SwitchCase>

Set di case per questa espressione switch.

Restituisce

SwitchExpression

Oggetto SwitchExpression creato.