Il modo migliore per gestire l'overflow integer in C#?

Question

La gestione di overflow di numeri interi è un'operazione comune, ma qual è il modo migliore di gestirli in C#? C'è dello zucchero sintattico per renderlo più semplice rispetto ad altre lingue? O è davvero il modo migliore?

int x = foo(); 
int test = x * common; 
if(test/common != x) 
    Console.WriteLine("oh noes!"); 
else 
    Console.WriteLine("safe!"); 

Answer 1

non ho bisogno di usare questo spesso, ma è possibile utilizzare la parola chiave checked:

int x = foo(); 
int test = checked(x * common); 

si tradurrà in un'eccezione di runtime se overflow. Da MSDN:

In un contesto controllato, se un'espressione produce un valore che è fuori del campo del tipo di destinazione, il risultato dipende se l'espressione è costante e non costante. Le espressioni costanti causano errori di compilazione, mentre le espressioni non costanti vengono valutate in fase di esecuzione e generano eccezioni.

Vorrei anche sottolineare che c'è un altro C# parola chiave, unchecked, che ovviamente fa il contrario di checked e ignora overflow. Potresti chiederti quando useresti mai unchecked dal momento che sembra essere il comportamento predefinito. Bene, c'è un'opzione del compilatore C# che definisce come vengono gestite le espressioni al di fuori di checked e unchecked: /checked. Puoi impostarlo nelle impostazioni di generazione avanzate del tuo progetto.

Se si dispone di molte espressioni da controllare, la cosa più semplice da fare sarebbe in realtà impostare l'opzione di creazione /checked. Quindi qualsiasi espressione che trabocca, a meno che non sia stata completata in unchecked, comporterebbe un'eccezione di runtime.

Answer 2

A volte, il modo più semplice è il modo migliore . Non riesco a pensare un modo migliore per scrivere quello che hai scritto, ma si può brevemente per:

int x = foo(); 

if ((x * common)/common != x) 
    Console.WriteLine("oh noes!"); 
else 
    Console.WriteLine("safe!"); 

Nota che non ho rimuovere la variabile x perché sarebbe sciocco a chiamare i foo() tre volte .

Answer 3

Il modo migliore è come Micheal ha detto: utilizzare Parola chiave verificata. questo può essere fatto come:

int x = int.MaxValue; 
try 
{ 
    checked 
    { 
     int test = x * 2; 
     Console.WriteLine("No Overflow!"); 
    } 
} 
catch (OverflowException ex) 
{ 
    Console.WriteLine("Overflow Exception caught as: " + ex.ToString()); 
} 

Answer 4

provare il vecchio filo seguente

int x = foo(); 
try { 
    int test = checked (x * common); 
    Console.WriteLine("safe!"); 
} catch (OverflowException) { 
    Console.WriteLine("oh noes!"); 
} 

Answer 5

, ma ho appena imbattuto in questo. Non volevo usare le eccezioni. Quello che ho finito con era:

long a = (long)b * (long)c; 
if(a>int.MaxValue || a<int.MinValue) 
    do whatever you want with the overflow 
return((int)a); 

Answer 6

Così, mi sono imbattuto in questo punto dopo il fatto, ed è in gran parte risposto alla mia domanda, ma per il mio caso particolare (in chiunque evento altro ha gli stessi requisiti), I voluto nulla che possa traboccare il valore positivo di un int firmato a stabilirsi proprio in int.MaxValue:

int x = int.MaxValue - 3; 
int someval = foo(); 

try 
{ 
    x += someval; 
} 

catch (OverflowException) 
{ 
    x = int.MaxValue; 
}