NaN, Infinity et Divide by Zero dans VB.NET

Les livres de programmation pour débutants incluent généralement cet avertissement : 'Ne divisez pas par zéro !' Vous obtiendrez une erreur d'exécution !'

Les choses ont changé en VB.NET . Bien qu'il y ait plus programmation options et le calcul est plus précis, il n'est pas toujours facile de voir pourquoi les choses se passent comme elles se passent.

Ici, nous apprenons à gérer la division par zéro à l'aide de la gestion structurée des erreurs de VB.NET. Et en cours de route, nous couvrons également les nouvelles constantes VB.NET : NaN, Infinity et Epsilon.

Que se passe-t-il si vous exécutez 'Diviser par zéro' dans VB.NET

Si vous exécutez un scénario 'diviser par zéro' dans VB.NET, vous obtenez ce résultat :

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

Alors que se passe-t-il ici ? La réponse est que VB.NET vous donne en fait la réponse mathématiquement correcte. Mathématiquement, vous boîte divisez par zéro, mais vous obtenez 'l'infini'.

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

La valeur 'infinity' n'est pas très utile pour la plupart des applications métier. (À moins que le PDG ne se demande quelle est la limite supérieure de son bonus d'actions.) Mais cela empêche vos applications de planter sur une exception d'exécution comme le font les langages moins puissants.

VB.NET vous donne encore plus de flexibilité en vous permettant même d'effectuer des calculs. Regarde ça:

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

Pour rester mathématiquement correct, VB.NET vous donne la réponse NaN (Not a Number) pour certains calculs comme 0/0.

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

VB.NET peut également faire la différence entre l'infini positif et l'infini négatif :

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

En plus de PositiveInfinity et NegativeInfinity, VB.NET fournit également Epsilon, la plus petite valeur Double positive supérieure à zéro.

Gardez à l'esprit que toutes ces nouvelles fonctionnalités de VB.NET ne sont disponibles qu'avec les types de données à virgule flottante (double ou simple). Et cette flexibilité peut conduire à une certaine confusion Try-Catch-Finally (gestion structurée des erreurs). Par exemple, le code .NET ci-dessus s'exécute sans lever aucune exception, donc le coder dans un bloc Try-Catch-Finally n'aidera pas. Pour tester une division par zéro, vous devez coder un test comme :

|__+_||_+_|

Même si vous codez le programme (en utilisant Integer au lieu des types Single ou Double), vous obtenez toujours une exception 'Overflow', pas une exception 'Divide by Zero'. Si vous recherchez une autre aide technique sur le Web, vous remarquerez que les exemples testent tous OverflowException.

.NET a en fait DivideByZeroException comme type légitime. Mais si le code ne déclenche jamais l'exception, quand verrez-vous cette erreur insaisissable ?

Quand vous verrez DivideByZeroException

Comme il s'avère, Microsoft La page MSDN sur les blocs Try-Catch-Finally utilise en fait des exemples de division par zéro pour illustrer comment les coder. Mais il y a un 'hic' subtil qu'ils n'expliquent pas. Leur code ressemble à ceci :

|__+_||_+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|
|__+_|

Ce code Est-ce que déclencher une exception réelle de division par zéro.

Mais pourquoi ce code déclenche-t-il l'exception et rien de ce que nous avons codé auparavant ne le fait ? Et qu'est-ce que Microsoft n'explique pas ?

Notez que l'opération qu'ils utilisent est ne pas diviser ('/'), c'est diviser un entier ('') ! (D'autres exemples Microsoft déclarent en fait les variables comme Integer.) Il s'avère que le calcul d'entier est le seulement cas qui lève réellement cette exception. Cela aurait été bien si Microsoft (et les autres pages qui copient leur code) expliquaient ce petit détail.