Expression.Switch Méthode

Définition

Espace de noms:

System.Linq.Expressions

Assembly:

System.Linq.Expressions.dll

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

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

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

SwitchExpression

Élément SwitchExpression créé.

Switch(Expression, SwitchCase[])

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

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

SwitchExpression

É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.

Switch(Expression, Expression, SwitchCase[])

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

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

SwitchExpression

É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é.

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

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

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

SwitchExpression

Élément SwitchExpression créé.

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

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

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

SwitchExpression

Élément SwitchExpression créé.

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

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

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

SwitchExpression

Élément SwitchExpression créé.