C# Declaración de cambio con/sin llaves ... ¿cuál es la diferencia?

Question

¿Ha permitido siempre C# omitir las llaves dentro de una declaración switch() entre las declaraciones case:?

¿Cuál es el efecto de omitirlos, como suelen hacer los programadores de JavaScript?

Ejemplo:

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

Las llaves no son necesarias, pero pueden ser útiles para introducir un nuevo espacio de declaración . Este comportamiento no ha cambiado desde C# 1.0 hasta donde yo sé.

El efecto de omitirlas es que todas las variables declaradas en algún lugar dentro de la declaración switch son visibles desde su punto de declaración en todas las ramas de casos.

véase también el ejemplo de Eric Lippert (caso 3 en el post):

Four switch oddities

ejemplo de Eric:

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

Esto no se compila porque int y y double y están en el mismo espacio de declaración introducido por th e switch declaración.Usted puede corregir el error mediante la separación de los espacios de declaración utilizando aparatos de ortopedia:

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

Answer 2

Las llaves son una parte opcional de la switch block, no son parte de las secciones de conmutación. Las llaves se pueden insertar dentro de las secciones de interruptor o se pueden insertar igualmente en cualquier lugar para controlar el alcance en su código.

Pueden ser útiles para limitar el alcance dentro del bloque de interruptores. Por ejemplo:

int x = 5; 

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

vs ...

int x = 5; 

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

Nota: C# será necesario que para establecer un valor a y dentro del bloque 5 caso en el primer ejemplo antes de usarlo. Esta es la protección contra el seguimiento de variables accidentales.

Answer 3

No son estrictamente necesarios, pero tan pronto como comience a declarar variables locales (en las ramas de cambio) son muy recomendables.

Esto no funcionará:

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

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

Esto compila pero es espeluznante:

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

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

Así que este es el mejor:

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

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

De una manera sencilla y fácil de leer. No desea obligar a los lectores a tener un conocimiento detallado de las reglas involucradas en el ejemplo del medio.

Answer 4

Los apoyos dentro del interruptor no es realmente parte de la estructura de conmutación en absoluto. Son solo bloques de alcance, que puede aplicar en el código en cualquier lugar que desee.

La diferencia entre tenerlos y no tenerlos es que cada bloque tiene su propio alcance. Puede declarar variables locales dentro del alcance, que no entren en conflicto con otras variables en otro ámbito.

Ejemplo:

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