Déclarations valides en tant que corps d'une fonction avec n'importe quel type de retour

Question

Cette question (ou plus précisément cette answer) m'a fait me demander: quelles instructions sont valables en C# comme le corps d'une fonction avec n'importe quel type de retour?

Ainsi, par exemple:

public void Foo() 
{ 
    while (true) { } 
} 

public int Foo() 
{ 
    while (true) { } 
} 

Les deux fonctions sont des fonctions valides C#, même si le second ne renvoie pas vraiment une int.

Donc, je sais que les boucles infinies (par exemple for(;;)) et throw new Exception() comme throw instructions sont valides comme le corps de toute fonction, mais y at-il plus d'instructions avec cette propriété?

---

Mise à jour:

Une autre solution est venue à mon esprit, une récursion infinie:

public string Foo() 
    { 
     return Foo(); 
    } 

Answer 1

Intéressant, un exemple qui est pas vraiment différent de votre deuxième extrait serait :

public static int Foo() 
{ 
    do {} 
    while (true); 
} 

Mais je ne pense pas que compte vraiment comme "différent".

En outre, un autre exemple de la raison pour laquelle goto est le mal:

public static int Foo() 
{ 
    start: 
    goto start; 
} 

Il est également intéressant de noter que cela ne donne une erreur de compilation:

public static int Foo() 
{ 
    bool b = true; 
    while (b) 
    { 
    } 
} 

Même si b ne change pas. Mais si vous explicitement rendre constante:

public static int Foo() 
{ 
    const bool b = true; 
    while (b) 
    { 
    } 
} 

Il fonctionne à nouveau.

Answer 2

est presque le même que l'exemple goto mais avec un switch impliqué:

public int Foo() 
{ 
    switch (false) 
    { 
     case false: 
     goto case false; 
    } 
} 

Je ne sais pas si cela est considéré comme un nouveau.

Il est intéressant, ce qui suit ne compilera pas:

public static int Foo(bool b) 
{ 
    switch (b) 
    { 
     case true: 
     case false: 
      goto case false; 
    } 
} 

Evidemment le compilateur n'a pas « connaissance » qu'un booléen ne peut avoir deux valeurs possibles. Vous devez couvrir explicitement tous les résultats « possibles »:

public static int Foo(bool b) 
{ 
    switch (b) 
    { 
     case true: 
     case false: 
     default: 
      goto case true; 
    } 
} 

Ou dans sa forme la plus simple:

public static int Foo(bool b) 
{ 
    switch (b) 
    { 
     default: 
      goto default; 
    } 
} 

Ouais ... Je suis ennuyé au travail aujourd'hui.

Answer 3

Non-vide & no return;

public IEnumerable Foo() 
{ 
    yield break; 
}