Dividir por cero con VisualBasic seguro que no adivinas el resultado

Cuando salió Visual Basic .NET muchos se quejaron de que ya no era Visual Basic, que era otra cosa... parecida pero otra cosa. Yo desde mi modesta posición, quiero desde aquí confirmar de que Visual Basic .NET realmente sigue siendo Visual Basic. Para eso os remito al siguiente ejemplo.

Tomemos dos pequeños programas, uno escrito en Visual Basic .NET y el otro en Csharp. Y probemos el resultado con un compilador y con el otro.

    Try
            Dim a As Integer = 1
            Dim b As Integer = 0
            Dim c As Double = a / b
            MessageBox.Show(c.ToString)
    Catch ex As DivideByZeroException
            MessageBox.Show("DivideByZeroException")
    Catch ex As Exception
            MessageBox.Show("Exception")
    End Try

Y por otro lado:

    try
    {
            int a = 0, b = 0;
            decimal c = a / b;
            MessageBox.Show(c.ToString());
    }
    catch (DivideByZeroException)
    {
            MessageBox.Show("DivideByZeroException");
    }
    catch (Exception)
    {
            MessageBox.Show("Exception");
    }

Como se suele decir, cuando se divide algo entre 0 debería aparecer una excepción de DivideByZero... por lo menos así me lo enseñaron a mi, y así ocurre con csharp. Pero no. En Visual Basic obtenemos otro valor... (que siendo sinceros no está mal)... obtenemos: "Infinito".

Ahora la explicación:

Yo divido dos enteros entre si, y obtengo un Double, para eso estoy (o debería) usar el operador divide que tiene implementado el tipo Integer y obtener un Double. Por definición de este tipo/operador cuando se divide algo por Cero se obtiene la excepción DivideByZeroException.

Si en vez de int/integer hubiese usado Double para guardar los números habría obtenido tanto en Visual Basic como en Csharp "Infinito". Y es que aquí viene lo curioso, el tipo Double además de números finitos puede guardar otros números:

Por lo que si se dividen dos doubles en .NET se puede obtener de resultado un infinito. El problema es que Visual Basic cuando ve nuestra división él por su cuenta y riesgo convierte los Integers en Doubles, y claro con Doubles si que se puede obtener el resultado de Infinito y por eso no aparece ninguna excepción por ningún lado.

Y es lo que digo yo, y por mucho que traten de convencernos, cuando se programa con Visual Basic el compilador asume que el programador no tiene ni idea y el compilador intenta "arreglar" el código; por desgracia la suele cagar. Por eso digo que VB .NET sigue siendo VB... a estas alturas sigue siendo un lenguaje para principiantes por mucho que nos pese o nos intenten decir lo contrario.

Bueno, en el fondo creo que no queda claro, pero, otro día ya escribiré sobre otras lineas de código curiosas de nuestro amiguito.