exception arithmétique en C#

Question

Pourquoi en C# est l'exemple A valide, compilable et va juste envelopper alors que les exemples B ne compileront pas?

A

int val = 0; 
val = val + Int32.MaxValue +2; 

ou

int val = Int32.MaxValue; 
val++; 

B

int val = 0; 
val = 2147483647 + 1; 

ou

int val = 0; 
int val = Int32.MaxValue + 1; 

Je sais Par défaut, les exceptions arithmétiques ne sont pas vérifiées par défaut, à moins que vous ne le fassiez explicitement en utilisant la méthode, le bloc ou l'attribut checked dans la configuration. Ma question se rapporte plus au compilateur alors comment une exception arithmétique se produit.

Answer 1

Vos exemples B sont constant-folded au moment de la compilation, indiquant au compilateur que le dépassement est garanti. Parce que vos exemples A utilisent des variables, les expressions ne peuvent pas être (complètement) constantes, donc le compilateur ne peut pas garantir que les valeurs entraîneront un débordement.

Par exemple ...

int val = 0; 
// some other thread changes `val` to -5... 
val = val + Int32.MaxValue +2; // no overflow 

Cependant, si vous savez que val ne changera pas, et d'attribuer 0 à un const int:

const int startval = 0; 
int val = startval + Int32.MaxValue + 2; 

Vous pouvez obtenir votre compile- le dépassement de temps revient en arrière car la valeur peut être complètement déterminée et donc pliée en permanence.

Answer 2

Cela a simplement à voir avec les limites de la vérification du temps de compilation. Certaines choses ne peuvent être connues qu'à l'exécution.

Answer 3

Je sais que les exceptions arithmétiques ne sont pas vérifiées par défaut, à moins que vous ne explicitement en utilisant la méthode INSPECTÉ bloc ou attribut dans la configuration

Vous ne savent parce que cette déclaration est incorrecte. Et en fait, vous savez que c'est incorrect parce que vous avez fourni un cas où votre déclaration est prouvée fausse!

Je vous renvoie à l'article 7.6.12 de la spécification C#, une partie dont je reproduis ici pour votre commodité:

Pour les expressions non constantes (expressions qui sont évaluées lors de l'exécution) qui le contexte de contrôle de dépassement de capacité par défaut n'est pas coché sauf si des facteurs externes (tels que les commutateurs du compilateur et la configuration de l'environnement d'exécution) nécessitent une évaluation vérifiée.

Pour les expressions constantes (expressions pouvant être entièrement évaluées au moment de la compilation), le contexte de vérification de dépassement de capacité par défaut est toujours vérifié.À moins qu'une expression constante ne soit explicitement placée dans un contexte non contrôlé, les dépassements qui se produisent lors de l'évaluation à la compilation de l'expression provoquent toujours des erreurs de compilation.

Voir les spécifications pour plus de détails.