Expression.Switch Méthode

Référence

Définition

Espace de noms:: System.Linq.Expressions

Assembly:: System.Linq.Expressions.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

SwitchExpression

É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

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.

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

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

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

SwitchExpression

É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

SwitchExpression

É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

SwitchExpression

Élément SwitchExpression créé.

S’applique à

Partager via

Expression.Switch Méthode

Définition

Surcharges

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

Paramètres

Retours

S’applique à

Switch(Expression, SwitchCase[])

Paramètres

Retours

Exemples

Remarques

S’applique à

Switch(Expression, Expression, SwitchCase[])

Paramètres

Retours

Exemples

Remarques

S’applique à

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

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

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

Paramètres

Retours

S’applique à

Ressources supplémentaires