¿Cómo comprobar si un doble se puede convertir en un Int32?

Question

Tengo un doble valor que me gustaría convertir a Int32. ¿Cómo puedo verificar antes de convertir si se puede convertir?

A veces el valor no está definido y la conversión a Int32 arroja una excepción OverflowException.

ya lo intentó poner a prueba esa manera:

double value = getSomeValue(); 
if (value == Double.NAN) { 
value =0; 
} 
int v = Convert.ToInt32(value); 

Pero esto no cubre todos los casos.

Answer 1

Quizás esto?

Actualización: I cree la actualización siguiente aborda las causas límite. He probado esto en todos los casos en que pude pensar en verificar la salida contra un método que intenta Convert.ToInt32 directamente y capta la excepción.

static bool TryConvertToInt32(double value, out int result) 
{ 
    const double Min = int.MinValue - 0.5; 
    const double Max = int.MaxValue + 0.5; 

    // Notes: 
    // 1. double.IsNaN is needed for exclusion purposes because NaN compares 
    // false for <, >=, etc. for every value (including itself). 
    // 2. value < Min is correct because -2147483648.5 rounds to int.MinValue. 
    // 3. value >= Max is correct because 2147483648.5 rounds to int.MaxValue + 1. 
    if (double.IsNaN(value) || value < Min || value >= Max) 
    { 
     result = 0; 
     return false; 
    } 

    result = Convert.ToInt32(value); 
    return true; 
} 

Answer 2

usted podría intentar algo como esto:

(value>=Int32.MinValue)&&(value<=Int32.MaxValue) 

Esto probablemente falsamente rechazar los valores que están fuera del rango de valores de int pero se redondean en ella. Así que es posible que desee extender el intervalo un poco.

Por ejemplo, Int32.MaxValue+0.1 se rechaza.

¿Cómo quieres tratar dobles no integrales? Este código los acepta y redondea silenciosamente la parte fraccionaria. Las sugerencias basadas en int.TryParse(value.ToString(),...) arrojarán considerar que tales dobles son inválidos.

Answer 3

Compruebe si Double.IsNaN y asegurarse de que está entre int.MinValue y int.MaxValue,

Answer 4

Se podría comparar a la gama de un Int32.

if(value <= (double)Int32.MAX_VALUE && value >= (double)Int32.MIN_VALUE) 
    return (Int32)value; 
return 0; 

Por supuesto, si usted quiere devolver el valor Max/Min cuando el doble es demasiado grande, se puede hacer esto:

if(value <= (double)Int32.MAX_VALUE && value >= (double)Int32.MIN_VALUE) 
    return (Int32)value; 
if(value > (double)Int32.MAX_VALUE) 
    return Int32.MAX_VALUE; 
if(value < (double)Int32.MIN_VALUE) 
    return Int32.MIN_VALUE; 
return 0; 

Answer 5

A menos que sea absolutamente necesario el rendimiento, lo que acerca del uso de manejo de excepciones ?

Answer 6

intentar algo como esto:

double d = Double.NaN; 
int i; 
if(Int32.TryParse(d.ToString(), out i)) 
{ 
    Console.WriteLine("Success"); 
    Console.WriteLine(i); 
} else { 
    Console.WriteLine("Fail"); 
}