NaN, Infinity y Divide by Zero en VB.NET

Los libros de programación para principiantes suelen incluir esta advertencia: '¡No divida por cero! ¡Recibirás un error de tiempo de ejecución!'

Las cosas han cambiado en VB.NET . aunque hay mas programación opciones y el cálculo es más preciso, no siempre es fácil ver por qué las cosas suceden de la forma en que lo hacen.

Aquí, aprendemos cómo manejar la división por cero utilizando el manejo estructurado de errores de VB.NET. Y en el camino, también cubrimos las nuevas constantes de VB.NET: NaN, Infinity y Epsilon.

Qué sucede si ejecuta 'Dividir por cero' en VB.NET

Si ejecuta un escenario de 'dividir por cero' en VB.NET, obtiene este resultado:

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

Entonces, ¿qué está pasando aquí? La respuesta es que VB.NET en realidad le da la respuesta matemáticamente correcta. Matemáticamente, tú pueden divide por cero, pero lo que obtienes es 'infinito'.

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

El valor 'infinito' no es demasiado útil para la mayoría de las aplicaciones comerciales. (A menos que el CEO se pregunte cuál es el límite superior de su bono de acciones). Pero evita que sus aplicaciones se bloqueen en una excepción de tiempo de ejecución como lo hacen los lenguajes menos potentes.

VB.NET le brinda aún más flexibilidad al permitirle incluso realizar cálculos. Mira esto:

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

Para permanecer matemáticamente correcto, VB.NET le da la respuesta NaN (No es un número) para algunos cálculos como 0/0.

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

VB.NET también puede diferenciar entre infinito positivo e infinito negativo:

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

Además de PositiveInfinity y NegativeInfinity, VB.NET también proporciona Epsilon, el valor Double positivo más pequeño mayor que cero.

Tenga en cuenta que todas estas nuevas capacidades de VB.NET solo están disponibles con tipos de datos de coma flotante (doble o simple). Y esta flexibilidad puede conducir a cierta confusión Try-Catch-Finally (manejo estructurado de errores). Por ejemplo, el código .NET anterior se ejecuta sin generar ningún tipo de excepción, por lo que codificarlo dentro de un bloque Try-Catch-Finally no ayudará. Para probar una división por cero, tendría que codificar una prueba algo como:

|_+_||_+_|

Incluso si codifica el programa (usando Integer en lugar de Single o Double), aún obtiene una excepción de 'Desbordamiento', no una excepción de 'Dividir por cero'. Si busca en la web otra ayuda técnica, notará que todos los ejemplos prueban OverflowException.

.NET en realidad tiene la excepción DivideByZeroException como un tipo legítimo. Pero si el código nunca activa la excepción, ¿cuándo verá este error elusivo?

Cuándo verá DivideByZeroException

Como resulta, microsoft La página de MSDN sobre los bloques Try-Catch-Finally en realidad utiliza ejemplos de división por cero para ilustrar cómo codificarlos. Pero hay una 'trampa' sutil que no explican. Su código se ve así:

|_+_||_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|
|_+_|

este codigo lo hace desencadenar una división real por excepción cero.

Pero, ¿por qué este código desencadena la excepción y nada de lo que hemos codificado antes lo hace? ¿Y qué no está explicando Microsoft?

Observe que la operación que utilizan es no divide ('/'), ¡es una división entera ('')! (Otros ejemplos de Microsoft en realidad declaran las variables como Integer.) Como resultado, el cálculo de enteros es el solamente caso que en realidad arroja esa excepción. Hubiera sido bueno que Microsoft (y las demás páginas que copian su código) explicaran ese pequeño detalle.