Partager via


Expression.Switch Méthode

Définition

Crée un SwitchExpression qui représente une instruction switch.

Surcharges

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

Switch(Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch sans casse par défaut.

Switch(Expression, Expression, SwitchCase[])

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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);
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

Paramètres

type
Type

Type de résultat du commutateur.

switchValue
Expression

Valeur à tester pour chaque cas.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

S’applique à

Switch(Expression, SwitchCase[])

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch sans casse par défaut.

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);
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.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

Exemples

L’exemple suivant montre comment créer une expression qui représente une instruction switch sans casse par défaut.

// 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 les SwitchCase objets d’un SwitchExpression objet doivent avoir le même type, sauf si a SwitchExpression le type void.

Chaque SwitchCase objet a une instruction implicite break , ce qui signifie qu’il n’y a pas de passage implicite d’une étiquette de casse à l’autre.

Si switchValue ne correspond à aucun des cas, aucune exception n’est levée.

S’applique à

Switch(Expression, Expression, SwitchCase[])

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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);
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.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

Exemples

L’exemple suivant montre comment créer une expression qui représente une instruction switch avec une casse par défaut.

// 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 les SwitchCase objets d’un SwitchExpression objet doivent avoir le même type, sauf si a SwitchExpression le type void.

Chaque SwitchCase objet a une instruction implicite break , ce qui signifie qu’il n’y a pas de passage implicite d’une étiquette de casse à l’autre.

Si switchValue ne correspond à aucun des cas, le cas par défaut représenté par defaultBody est exécuté.

S’applique à

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

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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);
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.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.

cases
IEnumerable<SwitchCase>

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

S’applique à

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

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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);
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.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.

cases
SwitchCase[]

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

S’applique à

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

Source:
SwitchExpression.cs
Source:
SwitchExpression.cs
Source:
SwitchExpression.cs

Crée un SwitchExpression qui représente une instruction switch avec la casse par défaut.

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);
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

Paramètres

type
Type

Type de résultat du commutateur.

switchValue
Expression

Valeur à tester pour chaque cas.

defaultBody
Expression

Résultat du commutateur si switchValue ne correspond à aucun des cas.

comparison
MethodInfo

Méthode de comparaison d'égalité à utiliser.

cases
IEnumerable<SwitchCase>

Ensemble de cas pour cette expression de switch.

Retours

Élément SwitchExpression créé.

S’applique à