Expression.Switch Méthode

Définition

Crée un SwitchExpression qui représente une instruction switch.Creates a SwitchExpression that represents a switch statement.

Surcharges

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

Switch(Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch sans casse par défaut.Creates a SwitchExpression that represents a switch statement without a default case.

Switch(Expression, Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Paramètres

type
Type

Type de résultat du commutateur.The result type of the switch.

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.The result of the switch if switchValue does not match any of the cases.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.The equality comparison method to use.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

Switch(Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch sans casse par défaut.Creates a SwitchExpression that represents a switch statement without a default case.

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

Paramètres

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

Exemples

L’exemple suivant montre comment créer une expression qui représente une instruction switch sans casse par défaut.The following example demonstrates how to create an expression that represents a switch statement without a default case.

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

Remarques

Tous SwitchCase les objets d' SwitchExpression un objet doivent avoir le même type, sauf SwitchExpression si le est voiddu type.All SwitchCase objects in a SwitchExpression object must have the same type, unless the SwitchExpression has the type void.

Chaque SwitchCase objet possède une instruction break implicite, ce qui signifie qu’il n’y a pas de passage implicite d’une étiquette case à une autre.Each SwitchCase object has an implicit break statement, which means that there is no implicit fall through from one case label to another.

Si switchValue ne correspond à aucun des cas, aucune exception n’est levée.If switchValue does not match any of the cases, no exception is thrown.

Switch(Expression, Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Paramètres

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.The result of the switch if switchValue does not match any of the cases.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

Exemples

L’exemple suivant montre comment créer une expression qui représente une instruction switch qui a un cas par défaut.The following example demonstrates how to create an expression that represents a switch statement that has a default case.

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

Remarques

Tous SwitchCase les objets d' SwitchExpression un objet doivent avoir le même type, sauf SwitchExpression si le est voiddu type.All SwitchCase objects in a SwitchExpression object must have the same type, unless the SwitchExpression has the type void.

Chaque SwitchCase objet possède une instruction break implicite, ce qui signifie qu’il n’y a pas de passage implicite d’une étiquette case à une autre.Each SwitchCase object has an implicit break statement, which means that there is no implicit fall through from one case label to another.

Si switchValue ne correspond à aucun des cas, le cas par défaut représenté par defaultBody est exécuté.If switchValue does not match any of the cases, the default case represented by defaultBody is run.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Paramètres

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.The result of the switch if switchValue does not match any of the cases.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.The equality comparison method to use.

cases
IEnumerable<SwitchCase>

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Paramètres

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.The result of the switch if switchValue does not match any of the cases.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.The equality comparison method to use.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Paramètres

type
Type

Type de résultat du commutateur.The result type of the switch.

switchValue
Expression

Valeur à tester pour chaque cas.The value to be tested against each case.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.The result of the switch if switchValue does not match any of the cases.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.The equality comparison method to use.

cases
IEnumerable<SwitchCase>

Ensemble de cas pour cette expression de switch.The set of cases for this switch expression.

Retours

Élément SwitchExpression créé.The created SwitchExpression.

S’applique à