NaN, Infinity og Divide by Zero i VB.NET

Begynnende programmeringsbøker inkluderer vanligvis denne advarselen: 'Ikke del på null! Du får en kjøretidsfeil!'

Ting har endret seg VB.NET . Selv om det er flere programmering alternativer og beregningen er mer nøyaktig, er det ikke alltid lett å se hvorfor ting skjer som de gjør.

Her lærer vi hvordan vi håndterer nulldeling ved hjelp av VB.NETs strukturerte feilhåndtering. Og underveis dekker vi også de nye VB.NET-konstantene: NaN, Infinity og Epsilon.

Hva skjer hvis du kjører 'Divide By Zero' i VB.NET

Hvis du kjører et «del med null»-scenario i VB.NET, får du dette resultatet:

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

Så hva skjer her? Svaret er at VB.NET faktisk gir deg det matematisk riktige svaret. Matematisk, du kan del på null, men det du får er 'uendelig'.

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

Verdien 'uendelig' er ikke så nyttig for de fleste forretningsapplikasjoner. (Med mindre administrerende direktør lurer på hva den øvre grensen for aksjebonusen hans er.) Men det forhindrer at applikasjonene dine krasjer på et runtime-unntak, slik mindre kraftige språk gjør.

VB.NET gir deg enda mer fleksibilitet ved å la deg utføre beregninger. Sjekk ut dette:

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

For å forbli matematisk korrekt gir VB.NET deg svaret NaN (ikke et tall) for noen beregninger som 0 / 0.

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

VB.NET kan også fortelle forskjellen mellom positiv uendelig og negativ uendelighet:

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

I tillegg til PositiveInfinity og NegativeInfinity, gir VB.NET også Epsilon, den minste positive Double-verdien større enn null.

Husk at alle disse nye funksjonene til VB.NET kun er tilgjengelige med flytende punkt (dobbelt eller enkelt) datatyper. Og denne fleksibiliteten kan føre til litt Try-Catch-Finally (strukturert feilhåndtering) forvirring. For eksempel kjører .NET-koden ovenfor uten å gi noen form for unntak, så det hjelper ikke å kode den i en Try-Catch-Finally-blokk. For å teste for en deling på null, må du kode en test noe sånt som:

|_+_||_+_|

Selv om du koder programmet (ved å bruke heltall i stedet for enkelt- eller dobbeltyper), får du fortsatt et 'Overflow'-unntak, ikke et 'Del med null'-unntak. Hvis du søker på nettet etter annen teknisk hjelp, vil du legge merke til at eksemplene alle tester for OverflowException.

.NET har faktisk DivideByZeroException som en legitim type. Men hvis koden aldri utløser unntaket, når vil du noen gang se denne unnvikende feilen?

Når du ser DivideByZeroException

Som det viser seg, Microsoft MSDN-siden om Try-Catch-Finally-blokker bruker faktisk dele med null-eksempler for å illustrere hvordan de kodes. Men det er en subtil 'fangst' som de ikke forklarer. Koden deres ser slik ut:

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

Denne koden gjør utløse et faktisk dele på null unntak.

Men hvorfor utløser denne koden unntaket og ingenting vi har kodet før gjør det? Og hva er det Microsoft ikke forklarer?

Legg merke til at operasjonen de bruker er ikke divider ('/'), det er heltallsdivisjon ('')! (Andre Microsoft-eksempler erklærer faktisk variablene som heltall.) Som det viser seg, er heltallsberegning bare tilfelle som faktisk kaster det unntaket. Det hadde vært fint om Microsoft (og de andre sidene som kopierer koden deres) forklarte den lille detaljen.