C # Переключение оператора с / без фигурных скобок .... в чем разница?

Question

Всегда ли C # позволял вам опускать фигурные скобки внутри оператора switch() между case: операторами?

Каков эффект от их пропуска, как это часто делают программисты на JavaScript?

Пример:

switch(x)
{
  case OneWay:
  {                               //  <---- Omit this entire line
    int y = 123;
    FindYou(ref y);
    break;
  }                               //  <---- Omit this entire line
  case TheOther:
  {                               //  <---- Omit this entire line
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }                               //  <---- Omit this entire line
}

Answer 1

Вьющиеся фигурные скобки не требуются, но они могут пригодиться, чтобы ввести новое пространство объявления .Насколько я знаю, это поведение не изменилось с C # 1.0.

Эффект от их пропуска состоит в том, что все переменные, объявленные где-то внутри оператора switch, видны из их точки объявления во всех ветвях case.

См. Также пример Эрика Липперта (случай 3 в посте):

Четыре странности переключателя

Пример Эрика:

switch(x)
{
  case OneWay:
    int y = 123;
    FindYou(ref y);
    break;
  case TheOther:
    double y = 456.7; // illegal!
    GetchaGetcha(ref y);
    break;
}

Это не компилируется, потому что int y и double y находятся в одном и том же пространстве объявления, введенном оператором switch.Вы можете исправить ошибку, разделив пространства объявлений с помощью фигурных скобок:

switch(x)
{
  case OneWay:
  {
    int y = 123;
    FindYou(ref y);
    break;
  }
  case TheOther:
  {
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }
}

Answer 2

Фигурные скобки являются дополнительной частью блока переключателей , они не являются частью секций переключателей. Скобки могут быть вставлены в секции переключателей или одинаково вставлены в любом месте, чтобы контролировать область в вашем коде.

Они могут быть полезны для ограничения области действия в блоке переключателей. Например:

int x = 5;

switch(x)
{
case 4:
    int y = 3;
    break;
case 5:
    y = 4;
    //...                      
    break;
}

против ...

int x = 5;

switch(x)
{
  case 4:
  {
    int y = 3;
    break;
  }
  case 5:
  {
    y = 4;//compiling error
    //...                      
    break;
  }
}

Примечание: C # потребует от вас установить значение y в блоке case 5 в первом примере перед его использованием. Это защита от случайного изменения переменной.

Answer 3

Брекеты внутри коммутатора вообще не являются частью структуры коммутатора.Это просто блоки областей действия, которые вы можете применять в коде в любом месте.

Разница между наличием их и отсутствием в том, что каждый блок имеет свою собственную область.Внутри области вы можете объявить локальные переменные, которые не конфликтуют с другими переменными в другой области.

Пример:

int x = 42;
{
  int y = x;
}
{
  int y = x + 1; // legal, as it's in a separate scope
}

Answer 4

Они не являются строго необходимыми, но как только вы начнете объявлять локальные переменные (в ветвях переключателей), они очень рекомендуются.

Это не будет работать:

    // does not compile
    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            int j = 3;   // error
            ...
            break;
    }

Это компилируется, но это жутко:

    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            j = 3;
            ...
            break;
    }

Так что это лучше:

  switch (x)
    {
        case 1 : 
         {             
            int j = 1;
            ...
         }
         break;  // I prefer the break outside of the  { }

        case 3: 
         {
            int j = 3;
            ...
         }
         break;
    }

Просто держите это простым и читабельным.Вы не хотите требовать от читателей детального знания правил, используемых в среднем примере.