¿Cuál es el propósito de las llaves adicionales en la caja del interruptor?

Question

Tengo curiosidad acerca de esta cosa ... ver ejemplo:

switch(x) 
{ 
    case(a): 
     { 
     //do stuff 
     } 
     break; 
    case(b): 
     //do stuff 
     break; 
} 

Toda mi vida lo he hecho, como el caso b, pero desde C# permite que lo use, y Visual Studio me permite a colapsar esa cosa, tengo curiosidad, ¿cuál es la diferencia real entre el caso a (con llaves) y el caso b?

Answer 1

Las llaves {} se utilizan para definir un alcance para un conjunto de operaciones. Curiosamente, la siguiente compilará y trabajo:

private void ConnectionStateChange(object sender, StateChangeEventArgs e) 
{ 
    string s = "hi"; 
    switch(s) 
    { 
     case "hi": 
      { 
       int a = 1; 
       a++; 
      } 
      { 
       int a = 2; 
       a++; 
      } 
      break; 
    } 

    { 
     int a = 1; 
     a++; 
    } 
    { 
     int a = 2; 
     a++; 
    } 
} 

Como se puede ver, en la que un método que he creado cuatro variables, cada una llamada a. Cada uno está completamente separado porque, como variables locales, existen solo dentro de su propio alcance.

¿Tiene algún sentido?

Answer 2

Crea un nuevo ámbito en el que puede crear nuevas variables.

Answer 3

Crea un nuevo alcance para las variables que utilizó. El alcance de las variables puede ser complicado a veces. Por ejemplo, en el código que publicaste;

switch(x) 
{ 
    case(a): 
     { 
     int i = 0; 
     } 
     break; 
    case(b): 
     i = 1; // Error: The name 'i' doesn't exist in the current context 
     break; 
} 

El error tiene sentido aquí como en case(b) variables a se accede fuera de alcance. Ahora, por otro lado,

switch(x) 
{ 
    case(a): 
     { 
     int i = 0; 
     } 
     break; 
    case(b): 
     int i = 1; // Error: A local variable named 'i' cannot be declared in this scope because it would give a different meaning to 'i', which is already used in a 'child' scope to denote something else 
     break; 
} 

Los dos errores anteriores se ven contradictorios entre sí. Para evitar esto se debe definir el alcance por separado en ambas sentencias case,

switch(x) 
{ 
    case(a): 
     { 
     int i = 0; 
     } 
     break; 
    case(b): 
     { 
     int i = 1; // No error 
     } 
     break; 
} 

Eric Lippert compartieron una muy buena link to his blog para explicar los alcances variables en la declaración de caso. Deberías echarle un vistazo.

Answer 4

Un par de llaves (no soportes - [] - y no paréntesis - () - pero tirantes{}) con cero o más declaraciones en ellas es una declaración social en C#, y por lo tanto puede aparecer en cualquier lugar donde una declaración pueda aparecer legalmente.

Como otros han señalado, la razón típica para ello se debe a que tal declaración introduce un nuevo espacio de declaración de variables locales, que a su vez define el alcance de las variables locales declaradas dentro de ella. (Recordemos que el "alcance" de un elemento es la región de texto del programa en el que el elemento puede ser referido por su nombre no calificado.)

observo que esto es particularmente interesante en un comunicado switch porque las reglas de alcance en un cambio son un poco extrañas. Para los detalles de lo extraño, consulte la "Caso 3:" en mi artículo sobre el tema:

http://ericlippert.com/2009/08/13/four-switch-oddities/