type - when c#




Несколько случаев в инструкции switch (10)

.NET Framework 3.5 имеет диапазоны:

Перечислить. Изменить из MSDN

вы можете использовать его с «contains» и инструкцией IF, так как, как сказал кто-то, оператор SWITCH использует оператор «==».

Вот пример:

int c = 2;
if(Enumerable.Range(0,10).Contains(c))
    DoThing();
else if(Enumerable.Range(11,20).Contains(c))
    DoAnotherThing();

Но я думаю, что мы можем веселиться: поскольку вам не нужны значения возврата, и это действие не принимает параметров, вы можете легко использовать действия!

public static void MySwitchWithEnumerable(int switchcase, int startNumber, int endNumber, Action action)
{
    if(Enumerable.Range(startNumber, endNumber).Contains(switchcase))
        action();
}

Старый пример с помощью этого нового метода:

MySwitchWithEnumerable(c, 0, 10, DoThing);
MySwitchWithEnumerable(c, 10, 20, DoAnotherThing);

Поскольку вы передаете действия, а не значения, вы должны опустить скобки, это очень важно. Если вам нужна функция с аргументами, просто измените тип Action на Action<ParameterType> . Если вам нужны значения возврата, используйте Func<ParameterType, ReturnType> .

В C # 3.0 нет простого Partial Application, чтобы инкапсулировать тот факт, что параметр case одинаковый, но вы создаете небольшой вспомогательный метод (бит многословный, tho).

public static void MySwitchWithEnumerable(int startNumber, int endNumber, Action action){ 
    MySwitchWithEnumerable(3, startNumber, endNumber, action); 
}

Вот пример того, как новый функциональный импортированный оператор IMHO более мощный и элегантный, чем старый императивный.

Есть ли способ провалиться в нескольких случаях, не указывая case value: повторно?

Я знаю, что это работает:

switch (value)
{
   case 1:
   case 2:
   case 3:
      //do some stuff
      break;
   case 4:
   case 5:
   case 6:
      //do some different stuff
      break;
   default:
       //default stuff
      break;
}

но я хотел бы сделать что-то вроде этого:

switch (value)
{
   case 1,2,3:
      //Do Something
      break;
   case 4,5,6:
      //Do Something
      break;
   default:
      //Do the Default
      break;
}

Является ли этот синтаксис с другого языка, или я чего-то не хватает?


@ Дженнифер Оуэнс: вы абсолютно правы, код ниже не будет работать:

case 1 | 3 | 5:
//not working do something

Единственный способ сделать это:

case 1: case 2: case 3:
// do something
break;

Код, который вы ищете, работает на визуальном базовом уровне, где вы легко можете устанавливать диапазоны ... ни в коем случае не переключайтесь, или если еще блокировки удобны, я бы предложил в очень экстремальной точке сделать .dll с визуальным базовым и импортировать обратно к вашему проекту c #.

Примечание: эквивалент переключения в визуальном базисе - это случай выбора.


Вы можете оставить новую строку, которая дает вам:

case 1: case 2: case 3:
   break;

но я считаю этот плохой стиль.


Для этого вы должны использовать инструкцию goto. Такие как:

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

Думаю, об этом уже ответили. Тем не менее, я думаю, что вы все равно можете комбинировать оба варианта синтаксически лучшим способом:

switch (value)
{
case 1: case 2: case 3:          
    // Do Something
    break;
case 4: case 5: case 6: 
    // Do Something
    break;
default:
    // Do Something
    break;
}

Если у вас очень большое количество строк (или любого другого типа), делающих все то же самое, я рекомендую использовать список строк в сочетании со свойством string.Contains.

Поэтому, если у вас есть большой оператор switch:

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

Возможно, вы захотите заменить его выражением if следующим образом:

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

Этот масштаб хорошо подходит для любого количества строк.


На самом деле мне тоже не нравится команда GOTO, но это в официальных материалах MS, здесь все разрешены синтаксисы.

Если конечная точка списка операторов секции переключения достижима, возникает ошибка времени компиляции. Это известно как правило «без падения». Пример

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

является действительным, потому что ни один сегмент переключения не имеет конечной точки достижимости. В отличие от C и C ++ выполнение секции переключения не разрешается «проваливаться» в следующий раздел коммутатора, а пример

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

приводит к ошибке времени компиляции. Когда выполнение раздела коммутатора должно сопровождаться выполнением другого раздела коммутатора, необходимо использовать явный код goto или goto по умолчанию:

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

Несколько меток разрешены в разделе коммутатора. Пример

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

Я верю в этот конкретный случай, GOTO можно использовать, это на самом деле единственный способ провалиться.

источник: http://msdn.microsoft.com/en-us/library/aa664749%28v=vs.71%29.aspx


Немного поздно для оригинального вопроса, но я отправляю этот ответ в надежде, что кто-то, использующий более новую версию ( C # 7 - доступную по умолчанию в Visual Studio 2017 / .NET Framework 4.6.2 ), найдет ее полезной.

В C # 7 теперь с помощью оператора switch можно переключаться на основе диапазона и помогать с проблемой OP.

Пример:

int i = 5;

switch (i)
{
    case int n when (n >= 7):
        Console.WriteLine($"I am 7 or above: {n}");
        break;

    case int n when (n >= 4 && n <= 6 ):
        Console.WriteLine($"I am between 4 and 6: {n}");
        break;

    case int n when (n <= 3):
        Console.WriteLine($"I am 3 or less: {n}");
        break;
}

// Output: I am between 4 and 6: 5

Заметки:

  • Скобки ( и ) не требуются в условии when , но используются в этом примере, чтобы выделить сравнение (сравнения).
  • var также может использоваться вместо int . Например: case var n when n >= 7:

Один из менее известных аспектов переключения в C # заключается в том, что он полагается на operator =, и поскольку он может быть переоценен, вы можете иметь что-то вроде этого:


string s = foo();

switch (s) {
  case "abc": /*...*/ break;
  case "def": /*...*/ break;
}

Этот синтаксис из Visual Basic Select ... Case Statement :

Dim number As Integer = 8
Select Case number
    Case 1 To 5
        Debug.WriteLine("Between 1 and 5, inclusive")
        ' The following is the only Case clause that evaluates to True.
    Case 6, 7, 8
        Debug.WriteLine("Between 6 and 8, inclusive")
    Case Is < 1
        Debug.WriteLine("Equal to 9 or 10")
    Case Else
        Debug.WriteLine("Not between 1 and 10, inclusive")
End Select

Вы не можете использовать этот синтаксис в C #. Вместо этого вы должны использовать синтаксис из своего первого примера.





switch-statement