Början av programmeringsböcker inkluderar vanligtvis denna varning: "Dela inte med noll! Du får ett runtime-fel! "
Saker har förändrats i VB.NET. Även om det finns fler programmering alternativ och beräkningen är mer exakt, det är inte alltid lätt att se varför saker händer som de gör.
Här lär vi oss att hantera division med noll med hjälp av VB.NETs strukturerade felhantering. Och på vägen täcker vi också de nya VB.NET-konstanterna: NaN, Infinity och Epsilon.
Vad händer om du kör 'Divide By Zero' i VB.NET
Om du kör ett "dividera med noll" -scenario i VB.NET får du detta resultat:
Dim a, b, c Som dubbel
a = 1: b = 0
c = a / b
Trösta. Skrivlinje( _
"Har matematikregler" _
& vbCrLf & _
"upphävts?" _
& vbCrLf & _
"Dividera med noll " _
& vbCrLf & _
"måste vara möjligt!")
Så vad händer här? Svaret är att VB.NET faktiskt ger dig det matematiskt korrekta svaret. Matematiskt, du kan dela med noll, men vad du får är "oändlighet".
Dim a, b, c Som dubbel
a = 1: b = 0
c = a / b
Trösta. Skrivlinje( _
"Svaret är: " _
& c)
'Visningar:
Svaret är: oändlighet
Värdet "oändlighet" är inte för användbart för de flesta affärsapplikationer. (Såvida inte VD undrar vad den övre gränsen för hans aktiebonus är.) Men det hindrar dina applikationer från att krascha på ett runtime-undantag som mindre kraftfulla språk gör.
VB.NET ger dig ännu mer flexibilitet genom att till och med låta dig göra beräkningar. Kolla in det här:
Dim a, b, c Som dubbel
a = 1: b = 0
c = a / b
c = c + 1
"Infinity plus 1 är
"fortfarande oändlighet
För att förbli matematiskt korrekt ger VB.NET dig svaret NaN (Inte ett tal) för vissa beräkningar som 0/0.
Dim a, b, c Som dubbel
a = 0: b = 0
c = a / b
Trösta. Skrivlinje( _
"Svaret är: " _
& c)
'Visningar:
Svaret är: NaN
VB.NET kan också berätta skillnaden mellan positiv oändlighet och negativ oändlighet:
Dim a1, a2, b, c Som dubbel
a1 = 1: a2 = -1: b = 0
Om (a1 / b)> (a2 / b) Sedan _
Trösta. Skrivlinje( _
"Postiv oändlighet är" _
& vbCrLf & _
"större än" _
& vbCrLf & _
"negativ oändlighet.")
Förutom PositiveInfinity och NegativeInfinity ger VB.NET också Epsilon, det minsta positiva dubbelvärdet större än noll.
Tänk på att alla dessa nya funktioner i VB.NET endast är tillgängliga med flytande punkt (dubbel eller singel) datatyper. Och denna flexibilitet kan leda till viss Try-Catch-slutlig (strukturerad felhantering) förvirring. Exempelvis körs .NET-koden ovan utan att kasta något slags undantag, så att kodning av den i ett Try-Catch-Final-block hjälper inte. För att testa för en delning med noll måste du koda ett test något som:
Om c. ToString = "Infinity" Sedan...
Även om du kodar programmet (med heltal istället för enstaka eller dubbla typer) får du fortfarande ett undantag från "Överflöde", inte ett "Divide by Zero" -undantag. Om du söker på nätet efter annan teknisk hjälp, kommer du att märka att exemplen alla testar för OverflowException.
.NET har faktiskt DivideByZeroException som en legitim typ. Men om koden aldrig utlöser undantaget, när kommer du någonsin se detta svårfel?
När du ser DivideByZeroException
Som det visar sig, MicrosoftMSDN-sida om Try-Catch-Final-block använder faktiskt en delning med noll-exempel för att illustrera hur man kodar dem. Men det finns en subtil "fångst" som de inte förklarar. Deras kod ser så här ut:
Dim ett som heltal = 0
Dim b som heltal = 0
Dim c som heltal = 0
Prova
a = b \ c
Fånga exc som undantag
Trösta. WritLine ("Ett körningsfel inträffade")
Till sist
Trösta. Readline ()
Avsluta försök
Den här koden gör utlösa en verklig uppdelning med noll undantag.
Men varför utlöser denna kod undantaget och ingenting vi har kodat tidigare gör? Och vad förklarar Microsoft inte?
Lägg märke till att den operation som de använder är inte divide ("/"), det är heltal divide ("\")! (Andra Microsoft-exempel förklarar faktiskt variablerna som heltal.) Det visar sig att heltalberäkning är endast fall som faktiskt kastar detta undantag. Det hade varit trevligt om Microsoft (och de andra sidorna som kopierar sin kod) förklarade den lilla detaljeringen.