Meerdere hoofdletters in switch-statement

13

Eigenlijk vind ik het Goto-commando ook niet leuk, maar het is in officiële Microsoft-materialen, en hier zijn allemaal toegestane syntaxis.

Als het eindpunt van de instructielijst van een switch-sectie bereikbaar is, treedt er een compileer-tijdfout op. Dit staat bekend als de “No Fall Through” -regel. Het voorbeeld

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
default:
   CaseOthers();
   break;
}

is geldig omdat er geen sectie-sectie een bereikbaar eindpunt heeft. In tegenstelling tot C en C++ is de uitvoering van een switch-sectie niet toegestaan ​​om “door te vallen” naar de sectie Volgende schakelaar, en het voorbeeld

switch (i) {
case 0:
   CaseZero();
case 1:
   CaseZeroOrOne();
default:
   CaseAny();
}

resulteert in een compilertijdfout. Wanneer de uitvoering van een switch-sectie moet worden gevolgd door uitvoering van een ander schakelaargedeelte, moet een expliciete GOTO- of GOTO-standaardverklaring worden gebruikt:

switch (i) {
case 0:
   CaseZero();
   goto case 1;
case 1:
   CaseZeroOrOne();
   goto default;
default:
   CaseAny();
   break;
}

Meerdere labels zijn toegestaan ​​in een schakelgedeelte. Het voorbeeld

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
case 2:
default:
   CaseTwo();
   break;
}

Ik geloof dat in dit specifieke geval de GOTO kan worden gebruikt, en het is eigenlijk de enige manier om er doorheen te komen.

Bron

Antwoord 14

In C# 8.0 kun je de nieuwe van expressie wisselensyntaxis die ideaal is voor uw geval.

var someOutput = value switch
{
    >= 1 and <= 3 => <Do some stuff>,
    >= 4 and <= 6 => <Do some different stuff>,
    _ => <Default stuff>
};

Antwoord 15

Er lijkt ontzettend veel werk te zijn gestoken in het vinden van manieren om een van de minst gebruikte syntaxis van C# er op de een of andere manier beter uit te laten zien of beter te laten werken. Persoonlijk vind ik de switch-statement zelden de moeite waard om te gebruiken. Ik raad je ten zeerste aan om te analyseren welke gegevens je aan het testen bent en welke eindresultaten je wilt.

Stel bijvoorbeeld dat u snel waarden in een bekend bereik wilt testen om te zien of het priemgetallen zijn. U wilt voorkomen dat uw code de verspillende berekeningen doet en u kunt online een lijst met priemgetallen vinden in het bereik dat u wilt. Je zou een massieve switch-instructie kunnen gebruiken om elke waarde te vergelijken met bekende priemgetallen.

Of u kunt gewoon een matrixkaart van priemgetallen maken en onmiddellijk resultaat krijgen:

   bool[] Primes = new bool[] {
        false, false, true, true, false, true, false,    
        true, false, false, false, true, false, true,
        false,false,false,true,false,true,false};
    private void button1_Click(object sender, EventArgs e) {
        int Value = Convert.ToInt32(textBox1.Text);
        if ((Value >= 0) && (Value < Primes.Length)) {
            bool IsPrime = Primes[Value];
            textBox2.Text = IsPrime.ToString();
        }
    }

Misschien wil je zien of een teken in een string hexadecimaal is. Je zou een lelijke en ietwat grote switch-statement kunnen gebruiken.

Of je kunt ofwel reguliere expressies gebruiken om de char te testen of de IndexOf-functie gebruiken om naar de char te zoeken in een reeks bekende hexadecimale letters:

       private void textBox2_TextChanged(object sender, EventArgs e) {
        try {
            textBox1.Text = ("0123456789ABCDEFGabcdefg".IndexOf(textBox2.Text[0]) >= 0).ToString();
        } catch {
        }
    }

Stel dat je een van de 3 verschillende acties wilt uitvoeren, afhankelijk van een waarde die in het bereik van 1 tot 24 ligt. Ik raad je aan een set IF-instructies te gebruiken. En als dat te complex werd (of de getallen waren groter, zoals 5 verschillende acties, afhankelijk van een waarde in het bereik van 1 tot 90), gebruik dan een opsomming om de acties te definiëren en een matrixkaart van de opsommingen te maken. De waarde zou dan worden gebruikt om te indexeren in de matrixkaart en de opsomming te krijgen van de gewenste actie. Gebruik dan ofwel een kleine set IF-statements of een heel eenvoudig switch-statement om de resulterende opsommingswaarde te verwerken.

Het leuke van een matrixkaart die een reeks waarden in acties omzet, is dat deze eenvoudig door code kan worden gewijzigd. Met vast bedrade code kun je het gedrag tijdens runtime niet gemakkelijk veranderen, maar met een array-kaart is het gemakkelijk.

Antwoord 16

Als je een heel groot aantal strings (of een ander type) hebt die allemaal hetzelfde doen, raad ik het gebruik van een stringlijst aan in combinatie met de eigenschap string.Contains.

Dus als je een grote switch-statement hebt, zoals:

switch (stringValue)
{
    case "cat":
    case "dog":
    case "string3":
    ...
    case "+1000 more string": // Too many string to write a case for all!
        // Do something;
    case "a lonely case"
        // Do something else;
    .
    .
    .
}

Misschien wilt u het vervangen door een if-statement zoals dit:

// Define all the similar "case" string in a List
List<string> listString = new List<string>(){ "cat", "dog", "string3", "+1000 more string"};
// Use string.Contains to find what you are looking for
if (listString.Contains(stringValue))
{
    // Do something;
}
else
{
    // Then go back to a switch statement inside the else for the remaining cases if you really need to
}

Deze schaal goed voor een willekeurig aantal tekenreeksen.

Antwoord 17

Ik denk dat deze beter is in C# 7 of hoger.

switch (value)
{
    case var s when new[] { 1,2 }.Contains(s):
    // Do something
     break;
    default:
    // Do the default
    break;
 }

Je kunt het bereik ook controleren in de C#-switch: Switch case: kan ik een bereik gebruiken in plaats van een één nummer
Of als u de basis van
C#-switchcase

Antwoord 18

Om toe te voegen aan het gesprek, met .NET 4.6.2 kon ik ook het volgende doen.
Ik heb de code getest en het werkte voor mij.

U kunt ook meerdere “OF”-instructies doen, zoals hieronder:

           switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when b.Contains("text3") || b.Contains("text4") || b.Contains("text5"):
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

Je kunt ook controleren of het overeenkomt met een waarde in een array:

           string[] statuses = { "text3", "text4", "text5"};
            switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when statuses.Contains(value):                        
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

Antwoord 19

U kunt ook voorwaarden hebben die totaal anders zijn

           bool isTrue = true;
            switch (isTrue)
            {
                case bool ifTrue when (ex.Message.Contains("not found")):
                case bool ifTrue when (thing.number = 123):
                case bool ifTrue when (thing.othernumber != 456):
                    response.respCode = 5010;
                    break;
                case bool ifTrue when (otherthing.text = "something else"):
                    response.respCode = 5020;
                    break;
                default:
                    response.respCode = 5000;
                    break;
            }

Antwoord 20

Hiervoor zou je een goto-statement gebruiken. Zoals:

   switch(value){
    case 1:
        goto case 3;
    case 2:
        goto case 3;
    case 3:
        DoCase123();
    //This would work too, but I'm not sure if it's slower
    case 4:
        goto case 5;
    case 5:
        goto case 6;
    case 6:
        goto case 7;
    case 7:
        DoCase4567();
    }