Déclaration C # Switch avec / sans accolades… quelle est la différence?

Est-ce que C # vous a toujours permis d’omettre les accolades dans une instruction switch() entre les case: instructions?

Quel est l’effet de les omettre, comme le font souvent les programmeurs JavaScript?

Exemple:

 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 } 

Les accolades ne sont pas obligatoires, mais elles peuvent être utiles pour introduire un nouvel espace de déclaration . Ce comportement n’a pas changé depuis C # 1.0 à ma connaissance.

L’omission de ces dernières est que toutes les variables déclarées quelque part dans l’instruction switch sont visibles depuis leur sharepoint déclaration dans toutes les twigs de cas.

Voir aussi l’exemple d’Eric Lippert (cas 3 dans le post):

Quatre bizarreries

L’exemple d’Eric:

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

Cela ne comstack pas car int y et double y sont dans le même espace de déclaration introduit par l’instruction switch . Vous pouvez corriger l’erreur en séparant les espaces de déclaration en utilisant des accolades:

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

Les accolades sont une partie facultative du bloc de commutation , elles ne font pas partie des sections de commutateur. Les accolades peuvent être insérées dans les sections de commutateur ou insérées de manière égale n’importe où pour contrôler la scope de votre code.

Ils peuvent être utiles pour limiter la scope dans le bloc de commutation. Par exemple:

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

contre…

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

Remarque: C # vous demandera de définir une valeur sur y dans le bloc 5 du premier exemple avant de l’utiliser. Ceci est une protection contre le suivi accidentel des variables.

Les accolades à l’intérieur du commutateur ne font en fait pas partie de la structure du commutateur. Ce ne sont que des blocs de scope que vous pouvez appliquer en code, où vous voulez.

La différence entre les avoir et ne pas en avoir est que chaque bloc a sa propre scope. Vous pouvez déclarer des variables locales dans la scope, ce qui n’entre pas en conflit avec d’autres variables d’une autre étendue.

Exemple:

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

Ils ne sont pas ssortingctement nécessaires, mais dès que vous commencez à déclarer des variables locales (dans les twigs du commutateur), elles sont très recommandées.

Cela ne marchera pas:

  // does not comstack switch (x) { case 1 : int j = 1; ... break; case 3: int j = 3; // error ... break; } 

Cela comstack mais c’est effrayant:

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

Donc c’est mieux:

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

Restez simple et lisible. Vous ne voulez pas obliger les lecteurs à avoir une connaissance détaillée des règles impliquées dans l’exemple moyen.