¿Por qué C # no tiene alcance local en los bloques de casos?

Creo que una buena razón es que, en cualquier otro caso, el alcance de una variable local "normal" es un bloque delimitado por llaves ( {} ). Las variables locales que no son normales aparecen en una construcción especial antes de una declaración (que generalmente es un bloque), como una variable de bucle for o una variable declarada en using .

Una excepción más son las variables locales en las expresiones de consulta LINQ, pero son completamente diferentes de las declaraciones de variables locales normales, por lo que no creo que exista una posibilidad de confusión.

Para referencia, las reglas están en §3.7 Ámbitos de la especificación de C #:

  

• El alcance de una variable local declarada en una local-variable-declaraciones es el bloque en el que se produce la declaración.

  

• El alcance de una variable local declarada en un switch-block de una declaración switch es el switch-block .

  

• El alcance de una variable local declarada en un for-initializer de una declaración for es el for-initializer , el for- condicion , el for-iterator y la sentencia contenida de la sentencia for .

  

• El alcance de una variable declarada como parte de una foreach-statement , using-statement , lock-statement o < em> query-expression está determinada por la expansión de la construcción dada.

  

(Aunque no estoy completamente seguro de por qué se menciona explícitamente el bloque switch , ya que no tiene una sintaxis especial para las declaciones de variables locales, a diferencia de todas las otras construcciones mencionadas).

Pero lo hace. Puedes crear ámbitos locales en cualquier lugar envolviendo líneas con {}

switch (criterion.ChangeAction)
{
  case BindingType.Inherited:
    {
      var action = (byte)ChangeAction.Inherit;
      return (x => x.Action == action);
    }
  case BindingType.ExplicitValue:
    {
      var action = (byte)ChangeAction.SetValue;
      return (x => x.Action == action);
    }
  default:
    // TODO: Localize errors
    throw new InvalidOperationException("Invalid criterion.");
}

Citaré a Eric Lippert, cuya respuesta es bastante clara sobre el tema:

  

Una pregunta razonable es "¿por qué esto no es legal?" Una respuesta razonable   es "bien, ¿por qué debería ser"? Puedes tenerlo de una de dos maneras. Ya sea   esto es legal:

switch(y) 
{ 
    case 1:  int x = 123; ...  break; 
    case 2:  int x = 456; ...  break; 
}

     

o esto es legal:

switch(y) 
{
    case 1:  int x = 123; ... break; 
    case 2:  x = 456; ... break; 
}

     

pero no puedes tenerlo de ambas maneras. Los diseñadores de C # eligieron.   La segunda forma parece ser la forma más natural de hacerlo.

     

Esta decisión se tomó el 7 de julio de 1999, hace apenas diez años.   Los comentarios en las notas de ese día son extremadamente breves, simplemente   indicando "Un caso de conmutación no crea su propio espacio de declaración" y   luego, proporcione un código de ejemplo que muestre qué funciona y qué no.

     

Para obtener más información sobre lo que estaba en la mente de los diseñadores sobre esto   Un día en particular, tendría que molestar a mucha gente sobre lo que eran   Hace diez años, pensé en lo que en última instancia es un error.   cuestión trivial; No voy a hacer eso.

     

En resumen, no hay una razón particularmente convincente para elegir una forma   o el otro; ambos tienen méritos. El equipo de diseño de idiomas eligió una forma.   porque tenían que escoger uno; el que escogieron parece razonable   yo.

Por lo tanto, a menos que esté más involucrado con el equipo de desarrolladores de C # de 1999 que con Eric Lippert, ¡nunca sabrá la razón exacta!

Una forma simplificada de ver el alcance es considerar el alcance por bloques {} .

Dado que switch no contiene ningún bloque, no puede tener diferentes ámbitos.

La explicación es simple: se debe a que es así en C. Lenguajes como C ++, Java y C # han copiado la sintaxis y el alcance de la declaración del conmutador en aras de la familiaridad.

(Como se indicó en otra respuesta, los desarrolladores de C # no tienen documentación sobre cómo se tomó esta decisión con respecto a los alcances de los casos. Pero el principio no declarado para la sintaxis de C # era que, a menos que tuvieran razones convincentes para hacerlo de manera diferente, Java copiado.)

En C, las declaraciones de casos son similares a goto-labels. La declaración de cambio es realmente una sintaxis más agradable para un goto computado . Los casos definen los puntos de entrada en el bloque de interruptores. Por defecto, el resto del código se ejecutará, a menos que haya una salida explícita. Así que solo tiene sentido que usen el mismo ámbito.

(Más fundamentalmente. Los Goto no están estructurados, no definen ni delimitan secciones de código, solo definen puntos de salto. Por lo tanto, una etiqueta goto no puede introducir una alcance.)

C # conserva la sintaxis, pero introduce una protección contra "caídas" al requerir una salida después de cada cláusula de caso (no vacía). ¡Pero esto cambia la forma en que pensamos en el cambio! Los casos ahora son ramas alternativas , como las ramas en if-else. Esto significa que esperaríamos que cada rama defina su propio alcance, como las cláusulas if y las cláusulas de iteración.

En resumen: los casos comparten el mismo alcance porque así es como está en C. Pero parece extraño e inconsistente en C # porque consideramos los casos como ramas alternativas en lugar de ir a objetivos.