Pourquoi ne peut-on pas définir une variable dans une instruction if?

Peut-être cette question a été répondu avant, mais le mot if se produit si souvent, il est difficile d'en trouver.

L'exemple n'a pas de sens (l'expression est toujours vrai), mais il illustre ma question.

Pourquoi est-ce code valide:

StringBuilder sb;
if ((sb = new StringBuilder("test")) != null) {
    Console.WriteLine(sb);
}

Mais ce code n'est pas:

if ((StringBuilder sb = new StringBuilder("test")) != null) {
    Console.WriteLine(sb);
}

J'ai trouvé une question similaire concernant un while déclaration. La accepté de répondre, il dit que, dans un while déclaration, il serait dire que la variable est définie dans chaque boucle. Mais pour ma if déclaration exemple, qui n'est pas le cas.

Quelle est donc la raison pour laquelle nous ne sommes pas autorisés à le faire?

La déclaration de la Variable est une instruction. Les Conditions l'exigent, une expression qui a une valeur, quelque chose que les déclarations ne sont pas et n'ont pas.
Jeff est sur place. Lire sur les liens suivants. Déclarations: msdn.microsoft.com/en-us/library/ms173143(v=VS.100).aspx les Expressions: msdn.microsoft.com/en-us/library/ms173144(v=VS.100).aspx
eh bien, alors changer le spec-à-dire qu'une déclaration de variable peut être utilisée comme une expression. Ce n'est pas une raison fondamentale pour laquelle cela ne peut pas être. C++ est-il juste comme ça.
Qui est presque arrivé en C#6, mais a été tiré jusqu'à ce que j'ai compris en faveur de la construction d'une meilleure spécification pour une utilisation avec le pattern matching. Cela va changer dans une prochaine version de C#, mais pas possible dans les versions actuelles.
Voir stackoverflow.com/questions/33180221/... pourquoi cela a été abandonnée pour C# 6

InformationsquelleAutor comecme | 2011-07-02

c#language-design scope

39

C'est parce que la section 8.5.1 du langage C# spec. membres:

En outre, une variable d'initialiseur dans une déclaration de variable locale correspond exactement à une instruction d'affectation, qui est inséré immédiatement après la déclaration.

Cela signifie que, lorsque vous faites:
```
StringBuilder sb = new StringBuilder("test")
```
Vous êtes, en effet, de faire exactement la même chose que:
```
StringBuilder sb; sb = new StringBuilder("test")
```
En tant que tel, il n'est plus une valeur de retour pour votre chèque à l'encontre de != null, comme l'affectation n'est pas une expression unique, mais plutôt une déclaration, qui est un local variable de demande de déclaration composé d'un identifiant suivie par une expression.

La spécification du langage donne cet exemple, en précisant que cela:
```
void F() {
   int x = 1, y, z = x * 2;
}
```
Est exactement équivalent à:
```
void F() {
   int x; x = 1;
   int y;
   int z; z = x * 2;
}
```
- Je suppose que d'une boucle for est un cas particulier alors?
- Strictement ce n'est plus de dire COMMENT ils l'ont fait, POURQUOI. Je ne vois absolument aucune raison pour laquelle un "int x" ne pourrait pas sortir de la référence à la variable sur la pile, qui est "int x=1" pourrait tout aussi bien être décodé logiquement que "(int x)=1" - avec les nouveaux tuples en c#7.0 ce qui est encore plus idiot qu'il n'est PAS permis (il est permis si vous déclarez TOUS les éléments du tuple tout de même).
- à la fin de la journée, à chaque question, comme c'est le même pourquoi - parce que les concepteurs ont pris cette décision. Cela explique la décision et le pourquoi de la mise en œuvre doit être de cette façon à correspondre à la spécification.
- eh bien, c'était une réponse facile.... SOUVENT Pourquoi remettre en question ce genre peut être répondu avec qui il serait en quelque sorte être en conflit avec quelque chose d'autre. Ce n'est PAS le cas ici, donc, ici, il n'y a pas de raisons, mais il peut être excusé pourquoi il n'est pas (actuellement) admis comme vous l'avez fait.
- Pas de. Une boucle est une instruction d'initialisation, une expression de condition, et d'un coup instruction, puis la boucle déclaration.
InformationsquelleAutor Reed Copsey
26

Essayer C#7 du Pattern Matching.

À l'aide de votre exemple:
```
if (new StringBuilder("test") is var sb && sb != null) {
    Console.WriteLine(sb);
}
```
- Qui fournit la syntaxe que j'ai demandé. Seul inconvénient, c'est que la variable n'est pas dans l'étendue du bloc si, mais il est défini pour le même champ d'application de la if déclaration.
- Le roslyn équipe de notes pour ce choix de 7/15/16.
- sly! neat! encore, je préfère construit-int première classe if(var sb = F() ; sb != null) comme dans le bon vieux for(var sb = ; sb!=null ;)
- aussi, oh mon dieu, je comprends pattern-matching contre un type de béton, mais un modèle is var est juste.. hilarant. C'est presque comme si quelqu'un spécialement conçu permis var l'inférence de type ici là pour ça
InformationsquelleAutor Jecoms
9

Cela a à voir avec la différence entre une déclaration et une expression. Une expression a une valeur, tandis qu'une déclaration n'est pas.

À l'aide de vos exemples, de l'avis de ces classifications:
```
StringBuilder sb; //statement

sb = new StringBuilder("test") //expression

StringBuilder sb = new StringBuilder("test"); //statement
```
Avis que seule la partie centrale est une expression.

Maintenant nous nous déplaçons sur votre instruction conditionnelle. La syntaxe d'utilisation de la non-opérateur = est
```
expression != expression
```
Donc sur les deux côtés de la != vous besoin de quelque chose qui possède une valeur (ce qui est tout à fait logique). Ergo, vous ne pouvez pas avoir les déclarations sur chaque côté de l'opérateur. C'est pourquoi une version de votre code fonctionne, tandis que l'autre ne l'est pas.

InformationsquelleAutor Ken Wayne VanderLinde
4

Au lieu de:
```
if ((StringBuilder sb = new StringBuilder("test")) != null) {
    Console.WriteLine(sb);
}
```
On pourrait aussi écrire:
```
for (StringBuilder sb = new StringBuilder("test"); sb != null; sb = null) {
    Console.WriteLine(sb);
}
```
Cette boucle for s'exécute une fois, si votre variable-il pas la valeur null. À la fin de la boucle, votre variable temporaire est définie sur null. La condition de la boucle, puis évalue à false, et de la prochaine instruction se poursuit après l'accolade fermante est exécuté. Exactement comme si votre déclaration prévu à l'origine.
- Ceci est très similaire à la question, mais seulement les programmeurs expérimentés permettra de repérer rapidement ce que vous faites. Toutefois, une solution élégante.
InformationsquelleAutor user809316

Vous devez vous connecter pour publier un commentaire.