Expression.Switch Methode

Definitie

Naamruimte:: System.Linq.Expressions

Assembly's:: System.Core.dll, System.Linq.Expressions.dll

Assembly:: System.Core.dll

Assembly:: System.Linq.Expressions.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Hiermee maakt u een SwitchExpression instructie switch .

Overloads

Name	Description
Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])	Hiermee maakt u een SwitchExpression instructie die een `switch` standaardcase bevat.
Switch(Expression, SwitchCase[])	Hiermee maakt u een SwitchExpression`switch` instructie zonder een standaardcase.
Switch(Expression, Expression, SwitchCase[])	Hiermee maakt u een SwitchExpression instructie die een `switch` standaardcase bevat.
Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)	Hiermee maakt u een SwitchExpression instructie die een `switch` standaardcase bevat.
Switch(Expression, Expression, MethodInfo, SwitchCase[])	Hiermee maakt u een SwitchExpression instructie die een `switch` standaardcase bevat.
Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)	Hiermee maakt u een SwitchExpression instructie die een `switch` standaardcase bevat.

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

Hiermee maakt u een SwitchExpression instructie die een switch standaardcase bevat.

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

Parameters

type: Type

Het resultaattype van de schakeloptie.

switchValue: Expression

De waarde die moet worden getest op elke case.

defaultBody: Expression

Het resultaat van de schakeloptie als switchValue deze niet overeenkomt met een van de gevallen.

comparison: MethodInfo

De te gebruiken gelijkheidsvergelijkingsmethode.

cases: SwitchCase[]

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Van toepassing op

Switch(Expression, SwitchCase[])

Hiermee maakt u een SwitchExpressionswitch instructie zonder een standaardcase.

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

Parameters

switchValue: Expression

De waarde die moet worden getest op elke case.

cases: SwitchCase[]

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een expressie maakt die een switch-instructie vertegenwoordigt zonder een standaardcase.

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

Opmerkingen

Alle SwitchCase objecten in een SwitchExpression object moeten hetzelfde type hebben, tenzij het SwitchExpression type voidheeft.

Elk SwitchCase object heeft een impliciete break instructie, wat betekent dat er geen impliciete val doorloopt van het ene caselabel naar het andere.

Als switchValue deze niet overeenkomt met een van de gevallen, wordt er geen uitzondering gegenereerd.

Van toepassing op

Switch(Expression, Expression, SwitchCase[])

Hiermee maakt u een SwitchExpression instructie die een switch standaardcase bevat.

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

Parameters

switchValue: Expression

De waarde die moet worden getest op elke case.

defaultBody: Expression

Het resultaat van de schakeloptie als switchValue deze niet overeenkomt met een van de gevallen.

cases: SwitchCase[]

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een expressie maakt die een switch-instructie vertegenwoordigt met een standaardcase.

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

Opmerkingen

Alle SwitchCase objecten in een SwitchExpression object moeten hetzelfde type hebben, tenzij het SwitchExpression type voidheeft.

Elk SwitchCase object heeft een impliciete break instructie, wat betekent dat er geen impliciete val doorloopt van het ene caselabel naar het andere.

Als switchValue deze niet overeenkomt met een van de gevallen, wordt de standaardcase uitgevoerd die wordt vertegenwoordigd door defaultBody .

Van toepassing op

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

Hiermee maakt u een SwitchExpression instructie die een switch standaardcase bevat.

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

Parameters

switchValue: Expression

De waarde die moet worden getest op elke case.

defaultBody: Expression

Het resultaat van de schakeloptie als switchValue deze niet overeenkomt met een van de gevallen.

comparison: MethodInfo

De te gebruiken gelijkheidsvergelijkingsmethode.

cases: IEnumerable<SwitchCase>

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Van toepassing op

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

Hiermee maakt u een SwitchExpression instructie die een switch standaardcase bevat.

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

Parameters

switchValue: Expression

De waarde die moet worden getest op elke case.

defaultBody: Expression

Het resultaat van de schakeloptie als switchValue deze niet overeenkomt met een van de gevallen.

comparison: MethodInfo

De te gebruiken gelijkheidsvergelijkingsmethode.

cases: SwitchCase[]

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Van toepassing op

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

Hiermee maakt u een SwitchExpression instructie die een switch standaardcase bevat.

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

Parameters

type: Type

Het resultaattype van de schakeloptie.

switchValue: Expression

De waarde die moet worden getest op elke case.

defaultBody: Expression

Het resultaat van de schakeloptie als switchValue deze niet overeenkomt met een van de gevallen.

comparison: MethodInfo

De te gebruiken gelijkheidsvergelijkingsmethode.

cases: IEnumerable<SwitchCase>

De set cases voor deze switchexpressie.

Retouren

SwitchExpression

De gemaakte SwitchExpression.

Van toepassing op

Feedback

Is deze pagina nuttig?