Perché C # non ha scope locale in caso di blocchi?

Penso che una buona ragione sia che in ogni altro caso, l'ambito di una variabile locale "normale" è un blocco delimitato da parentesi graffe ( {} ). Le variabili locali che non sono normali appaiono in un costrutto speciale prima di un'istruzione (che di solito è un blocco), come una variabile di ciclo for o una variabile dichiarata in using .

Un'ulteriore eccezione sono le variabili locali nelle espressioni di query LINQ, ma queste sono completamente diverse dalle normali dichiarazioni delle variabili locali, quindi non credo ci sia una possibilità di confusione lì.

Per riferimento, le regole sono in §3.7 Scope della specifica C #:

• The scope of a local variable declared in a local-variable-declaration is the block in which the declaration occurs.

• The scope of a local variable declared in a switch-block of a switch statement is the switch-block.

• The scope of a local variable declared in a for-initializer of a for statement is the for-initializer, the for-condition, the for-iterator, and the contained statement of the for statement.

• The scope of a variable declared as part of a foreach-statement, using-statement, lock-statement or query-expression is determined by the expansion of the given construct.

(Anche se non sono completamente sicuro del perché il blocco switch sia menzionato esplicitamente, poiché non ha alcuna sintassi speciale per le declinazioni di variabili locali, a differenza di tutti gli altri costrutti menzionati.)

Ma lo fa. Puoi creare ambiti locali ovunque avvolgendo le linee 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.");
}

Citerò Eric Lippert, la cui risposta è abbastanza chiara sull'argomento:

A reasonable question is "why is this not legal?" A reasonable answer is "well, why should it be"? You can have it one of two ways. Either this is legal:

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

or this is legal:

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

but you can't have it both ways. The designers of C# chose the second way as seeming to be the more natural way to do it.

This decision was made on July 7th, 1999, just shy of ten years ago. The comments in the notes from that day are extremely brief, simply stating "A switch-case does not create its own declaration space" and then giving some sample code that shows what works and what does not.

To find out more about what was in the designers minds on this particular day, I'd have to bug a lot of people about what they were thinking ten years ago -- and bug them about what is ultimately a trivial issue; I'm not going to do that.

In short, there is no particularly compelling reason to choose one way or the other; both have merits. The language design team chose one way because they had to pick one; the one they picked seems reasonable to me.

Quindi, se non sei più intimo con il team di sviluppatori C # del 1999 di Eric Lippert, non conoscerai mai il motivo esatto!

Un modo semplificato di guardare l'ambito è considerare l'ambito per blocchi {} .

Poiché switch non contiene alcun blocco, non può avere ambiti diversi.

La spiegazione è semplice - è perché è così in C. Lingue come C ++, Java e C # hanno copiato la sintassi e l'ambito dell'istruzione switch per motivi di familiarità.

(Come affermato in un'altra risposta, gli sviluppatori di C # non hanno documentazione su come è stata presa questa decisione riguardo agli scope del caso, ma il principio non dichiarato per la sintassi C # era che, a meno che non avessero motivi convincenti per farlo in modo diverso, copiato Java.)

In C, le istruzioni case sono simili alle goto-label. L'istruzione switch è davvero una sintassi più bella per un goto calcolato . I casi definiscono i punti di ingresso nel blocco switch. Di default il resto del codice verrà eseguito, a meno che non ci sia un'uscita esplicita. Quindi ha senso solo che usano lo stesso scope.

(Più fondamentalmente: i Goto non sono strutturati - non definiscono o delimitano sezioni di codice, definiscono solo i punti di salto, quindi un'etichetta goto non può introdurre ambito di applicazione.)

C # mantiene la sintassi, ma introduce una salvaguardia contro il "fall through" richiedendo un'uscita dopo ogni caso (non vuoto). Ma questo cambia il modo in cui pensiamo all'interruttore! I casi sono ora rami alternativi , come i rami in un if-else. Ciò significa che ci aspetteremmo che ogni ramo definisca il proprio ambito proprio come se fossero clausole if o clausole di iterazione.

Quindi, in breve: i casi condividono lo stesso ambito perché questo è il modo in cui è in C. Ma sembra strano e incoerente in C # perché pensiamo ai casi come a diramazioni alternative piuttosto che a target goto.