Dela via

Typkonverteringsfunktioner (Visual Basic)

  • Artikel

Dessa funktioner kompileras infogat, vilket innebär att konverteringskoden är en del av koden som utvärderar uttrycket. Ibland finns det inget anrop till en procedur för att utföra konverteringen, vilket förbättrar prestandan. Varje funktion tvingar ett uttryck till en specifik datatyp.

Syntax

CBool(expression)
CByte(expression)
CChar(expression)
CDate(expression)
CDbl(expression)
CDec(expression)
CInt(expression)
CLng(expression)
CObj(expression)
CSByte(expression)
CShort(expression)
CSng(expression)
CStr(expression)
CUInt(expression)
CULng(expression)
CUShort(expression)

Delvis

expression
Obligatoriska. Alla uttryck för källdatatypen.

Returnera värdedatatyp

Funktionsnamnet avgör datatypen för det värde som returneras, enligt följande tabell.

Funktionsnamn Returnera datatyp Intervall för expression argument
CBool Boolesk datatyp Char Giltiga eller String numeriska uttryck.
CByte Bytedatatyp Byte.MinValue (0) till och med Byte.MaxValue (255) (osignerade); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för konvertering av flyttal till byte med CByte funktionen. Mer information finns i avsnittet Kommentarer . Se avsnittet CInt-exempel för ett exempel.
CChar Teckendatatyp Valfritt giltigt Char eller String uttryck; endast första tecknet i ett String konverteras. Värdet kan vara 0 till 65535 (osignerat).
CDate Datumdatatyp En giltig representation av ett datum och en tid.
CDbl Dubbel datatyp -1.79769313486231570E+308 till -4.94065645841246544E-324 för negativa värden; 4.94065645841246544E-324 till 1.79769313486231570E+308 för positiva värden.
CDec Decimaldatatyp +/-79 228 162 514 264 337 593 543 950 335 för nollskalade tal, dvs. tal utan decimaler. För tal med 28 decimaler är intervallet +/-7,9228162514264337593543950335. Det minsta möjliga talet som inte är noll är 0,0000000000000000000000000000001 (+/-1E-28).
CInt Heltalsdatatyp Int32.MinValue (-2 147 483 648) till och med Int32.MaxValue (2 147 483 647); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för konvertering av flyttal till heltal med CInt funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CLng Lång datatyp Int64.MinValue (-9 223 372 036 854 775 808) till Int64.MaxValue och med (9 223 372 036 854 775 807); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för konvertering av flyttal till 64-bitars heltal med CLng funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CObj Objektdatatyp Valfritt giltigt uttryck.
CSByte Datatyp för SByte SByte.MinValue (-128) till och med SByte.MaxValue (127); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för flyttal till signerad bytekonvertering med CSByte funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CShort Kort datatyp Int16.MinValue (-32 768) till och med Int16.MaxValue (32 767); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för konvertering av flyttal till 16-bitars heltal med CShort funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CSng Enskild datatyp -3.402823E+38 till -1.401298E-45 för negativa värden; 1.401298E-45 till 3.402823E+38 för positiva värden.
CStr Strängdatatyp Returnerar för CStr beror på expression argumentet. Se Returnera värden för CStr-funktionen.
CUInt UInteger-datatyp UInt32.MinValue (0) till och med UInt32.MaxValue (4 294 967 295) (osignerade); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för flyttalskonvertering till osignerad heltalskonvertering med CUInt funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CULng ULong-datatyp UInt64.MinValue (0) till och med UInt64.MaxValue (18 446 744 073 709 551 615) (osignerade); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för flyttal till osignerad lång heltalskonvertering med CULng funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.
CUShort UShort-datatyp UInt16.MinValue (0) till och med UInt16.MaxValue (65 535) (osignerade); bråkdelar avrundas.1

Från och med Visual Basic 15.8 optimerar Visual Basic prestanda för flyttal till osignerad 16-bitars heltalskonvertering med CUShort funktionen. Mer information finns i avsnittet Anmärkningar . Se avsnittet CInt-exempel för ett exempel.

1 Bråkdelar kan omfattas av en särskild typ av avrundning som kallas bankirs avrundning. Mer information finns i "Kommentarer".

Kommentarer

Som regel bör du använda visual basic-typkonverteringsfunktionerna i stället för .NET Framework-metoderna, till exempel ToString(), antingen i Convert klassen eller på en enskild typstruktur eller klass. Visual Basic-funktionerna är utformade för optimal interaktion med Visual Basic-kod, och de gör även källkoden kortare och enklare att läsa. Dessutom ger .NET Framework-konverteringsmetoderna inte alltid samma resultat som Visual Basic-funktionerna, till exempel vid konvertering Boolean till Integer. Mer information finns i Felsöka datatyper.

Från och med Visual Basic 15.8 optimeras prestanda för konvertering från flyttal till heltal när du skickar SingleDouble eller-värdet som returneras med följande metoder till någon av heltalskonverteringsfunktionerna (CByte, , CIntCShort, CLngCSByte, CUShort, , CUInt, ): CULng

Den här optimeringen gör att kod som utför ett stort antal heltalskonverteringar kan köras upp till dubbelt så snabbt. I följande exempel visas dessa optimerade konverteringar från flyttalspunkt till heltal:

Dim s As Single = 173.7619
Dim d As Double = s

Dim i1 As Integer = CInt(Fix(s))               ' Result: 173
Dim b1 As Byte = CByte(Int(d))                 ' Result: 173
Dim s1 AS Short = CShort(Math.Truncate(s))     ' Result: 173
Dim i2 As Integer = CInt(Math.Ceiling(d))      ' Result: 174
Dim i3 As Integer = CInt(Math.Round(s))        ' Result: 174

Funktionssätt

  • Tvång. I allmänhet kan du använda datatypkonverteringsfunktionerna för att tvinga resultatet av en åtgärd till en viss datatyp i stället för standarddatatypen. Använd till exempel CDec för att framtvinga decimalaritmetik i fall där enprecision, dubbel precision eller heltalsaritmetik normalt skulle ske.

  • Misslyckade konverteringar. Om den expression som skickas till funktionen ligger utanför intervallet för den datatyp som den ska konverteras till, inträffar en OverflowException .

  • Bråkdelar. När du konverterar ett icke-integralt värde till en integraltyp tar heltalskonverteringsfunktionerna (CByte, , CIntCSByteCLng, CShort, CUInt, CULngoch CUShort) bort bråkdelen och avrundar värdet till närmaste heltal.

    Om bråkdelen är exakt 0,5 kan heltalskonverteringsfunktionerna avrunda den till närmaste jämna heltal. Till exempel avrundar 0,5 till 0 och 1,5 och 2,5 båda avrundar till 2. Detta kallas ibland bankirens avrundning, och dess syfte är att kompensera för en bias som kan ackumuleras när man lägger till många sådana siffror tillsammans.

    CInt och CLng skiljer sig från Int funktionerna och Fix , som trunkerar, snarare än runda, bråkdelen av ett tal. FixInt Och returnerar alltid ett värde av samma datatyp som du skickar in.

  • Datum-/tidskonverteringar. IsDate Använd funktionen för att avgöra om ett värde kan konverteras till ett datum och en tid. CDate identifierar datumliteraler och tidsliteraler men inte numeriska värden. Om du vill konvertera ett Visual Basic 6.0-värde Date till ett Date värde i Visual Basic 2005 eller senare versioner kan du använda DateTime.FromOADate metoden.

  • Neutrala datum-/tidsvärden. Datumdatatypen innehåller alltid både datum- och tidsinformation. För typkonvertering anser Visual Basic att 1/1/0001 (1 januari år 1) är ett neutralt värde för datumet och 00:00:00 (midnatt) som ett neutralt värde för tiden. Om du konverterar ett Date värde till en sträng CStr innehåller inte neutrala värden i den resulterande strängen. Om du till exempel konverterar #January 1, 0001 9:30:00# till en sträng blir resultatet "9:30:00 AM". Datuminformationen ignoreras. Datuminformationen finns dock fortfarande i det ursprungliga Date värdet och kan återställas med funktioner som DatePart funktion.

  • Kulturkänslighet. Typkonverteringsfunktionerna som involverar strängar utför konverteringar baserat på de aktuella kulturinställningarna för programmet. Till exempel CDate identifierar datumformat enligt inställningen för nationella inställningar i systemet. Du måste ange dag, månad och år i rätt ordning för dina nationella inställningar, annars kanske datumet inte tolkas korrekt. Ett långt datumformat identifieras inte om det innehåller en veckodagsträng, till exempel "Onsdag".

    Om du behöver konvertera till eller från en strängrepresentation av ett värde i ett annat format än det som anges av språkvarianten kan du inte använda konverteringsfunktionerna för Visual Basic-typen. Det gör du genom att använda ToString(IFormatProvider) metoderna och Parse(String, IFormatProvider) för värdets typ. Du kan till exempel använda Double.Parse när du konverterar en sträng till en Doubleoch använder Double.ToString när du konverterar ett värde av typen Double till en sträng.

CType-funktion

CType-funktionen tar ett andra argument, typename, och tvingar expression till typename, där typename kan vara vilken datatyp, struktur, klass eller gränssnitt som det finns en giltig konvertering till.

En jämförelse av CType med andra typkonverteringsnyckelord finns i DirectCast-operatorn och TryCast-operatorn.

CBool-exempel

I följande exempel används CBool funktionen för att konvertera uttryck till Boolean värden. Om ett uttryck utvärderas till ett värde som inte är noll CBool returnerar True. Annars returneras False.

Dim a, b, c As Integer
Dim check As Boolean
a = 5
b = 5
' The following line of code sets check to True.
check = CBool(a = b)
c = 0
' The following line of code sets check to False.
check = CBool(c)

Exempel på CByte

I följande exempel används CByte funktionen för att konvertera ett uttryck till en Byte.

Dim aDouble As Double
Dim aByte As Byte
aDouble = 125.5678
' The following line of code sets aByte to 126.
aByte = CByte(aDouble)

CChar-exempel

I följande exempel används CChar funktionen för att konvertera det första tecknet i ett String uttryck till en Char typ.

Dim aString As String
Dim aChar As Char
' CChar converts only the first character of the string.
aString = "BCD"
' The following line of code sets aChar to "B".
aChar = CChar(aString)

Indataargumentet måste CChar vara av datatyp Char eller String. Du kan inte använda CChar för att konvertera ett tal till ett tecken eftersom CChar det inte går att acceptera en numerisk datatyp. I följande exempel hämtas ett tal som representerar en kodpunkt (teckenkod) och konverterar den till motsvarande tecken. Den använder InputBox funktionen för att hämta strängen med siffror, CInt konvertera strängen till att skriva Integeroch ChrW konvertera talet till att skriva Char.

Dim someDigits As String
Dim codePoint As Integer
Dim thisChar As Char
someDigits = InputBox("Enter code point of character:")
codePoint = CInt(someDigits)
' The following line of code sets thisChar to the Char value of codePoint.
thisChar = ChrW(codePoint)

CDate-exempel

I följande exempel används CDate funktionen för att konvertera strängar till Date värden. I allmänhet rekommenderas inte hårdkodning av datum och tider som strängar (som visas i det här exemplet). Använd datumliteraler och tidsliteraler, till exempel #Feb 12, 1969# och #4:45:23 PM#, i stället.

Dim aDateString, aTimeString As String
Dim aDate, aTime As Date
aDateString = "February 12, 1969"
aTimeString = "4:35:47 PM"
' The following line of code sets aDate to a Date value.
aDate = CDate(aDateString)
' The following line of code sets aTime to Date value.
aTime = CDate(aTimeString)

CDbl-exempel

Dim aDec As Decimal
Dim aDbl As Double
' The following line of code uses the literal type character D to make aDec a Decimal.
aDec = 234.456784D
' The following line of code sets aDbl to 1.9225456288E+1.
aDbl = CDbl(aDec * 8.2D * 0.01D)

CDec-exempel

I följande exempel används CDec funktionen för att konvertera ett numeriskt värde till Decimal.

Dim aDouble As Double
Dim aDecimal As Decimal
aDouble = 10000000.0587
' The following line of code sets aDecimal to 10000000.0587.
aDecimal = CDec(aDouble)

CInt-exempel

I följande exempel används CInt funktionen för att konvertera ett värde till Integer.

Dim aDbl As Double
Dim anInt As Integer
aDbl = 2345.5678
' The following line of code sets anInt to 2346.
anInt = CInt(aDbl)

CLng-exempel

I följande exempel används CLng funktionen för att konvertera värden till Long.

Dim aDbl1, aDbl2 As Double
Dim aLng1, aLng2 As Long
aDbl1 = 25427.45
aDbl2 = 25427.55
' The following line of code sets aLng1 to 25427.
aLng1 = CLng(aDbl1)
' The following line of code sets aLng2 to 25428.
aLng2 = CLng(aDbl2)

CObj-exempel

I följande exempel används CObj funktionen för att konvertera ett numeriskt värde till Object. Själva Object variabeln innehåller bara en pekare på fyra byte som pekar på det Double tilldelade värdet.

Dim aDouble As Double
Dim anObject As Object
aDouble = 2.7182818284
' The following line of code sets anObject to a pointer to aDouble.
anObject = CObj(aDouble)

CSByte-exempel

I följande exempel används CSByte funktionen för att konvertera ett numeriskt värde till SByte.

Dim aDouble As Double
Dim anSByte As SByte
aDouble = 39.501
' The following line of code sets anSByte to 40.
anSByte = CSByte(aDouble)

CShort-exempel

I följande exempel används CShort funktionen för att konvertera ett numeriskt värde till Short.

Dim aByte As Byte
Dim aShort As Short
aByte = 100
' The following line of code sets aShort to 100.
aShort = CShort(aByte)

CSng-exempel

I följande exempel används CSng funktionen för att konvertera värden till Single.

Dim aDouble1, aDouble2 As Double
Dim aSingle1, aSingle2 As Single
aDouble1 = 75.3421105
aDouble2 = 75.3421567
' The following line of code sets aSingle1 to 75.34211.
aSingle1 = CSng(aDouble1)
' The following line of code sets aSingle2 to 75.34216.
aSingle2 = CSng(aDouble2)

CStr-exempel

I följande exempel används CStr funktionen för att konvertera ett numeriskt värde till String.

Dim aDouble As Double
Dim aString As String
aDouble = 437.324
' The following line of code sets aString to "437.324".
aString = CStr(aDouble)

I följande exempel används CStr funktionen för att konvertera Date värden till String värden.

Dim aDate As Date
Dim aString As String
' The following line of code generates a COMPILER ERROR because of invalid format.
' aDate = #February 12, 1969 00:00:00#
' Date literals must be in the format #m/d/yyyy# or they are invalid.
' The following line of code sets the time component of aDate to midnight.
aDate = #2/12/1969#
' The following conversion suppresses the neutral time value of 00:00:00.
' The following line of code sets aString to "2/12/1969".
aString = CStr(aDate)
' The following line of code sets the time component of aDate to one second past midnight.
aDate = #2/12/1969 12:00:01 AM#
' The time component becomes part of the converted value.
' The following line of code sets aString to "2/12/1969 12:00:01 AM".
aString = CStr(aDate)

CStr renderar alltid ett Date värde i standardformatet för det aktuella språket, till exempel "2003-06-15 16:35:47". Undertrycker dock CStr de neutrala värdena 1/1/0001 för datumet och 00:00:00 för tiden.

Mer information om de värden som returneras av CStrfinns i Returnera värden för CStr-funktionen.

CUInt-exempel

I följande exempel används CUInt funktionen för att konvertera ett numeriskt värde till UInteger.

Dim aDouble As Double
Dim aUInteger As UInteger
aDouble = 39.501
' The following line of code sets aUInteger to 40.
aUInteger = CUInt(aDouble)

CULng-exempel

I följande exempel används CULng funktionen för att konvertera ett numeriskt värde till ULong.

Dim aDouble As Double
Dim aULong As ULong
aDouble = 39.501
' The following line of code sets aULong to 40.
aULong = CULng(aDouble)

CUShort-exempel

I följande exempel används CUShort funktionen för att konvertera ett numeriskt värde till UShort.

Dim aDouble As Double
Dim aUShort As UShort
aDouble = 39.501
' The following line of code sets aUShort to 40.
aUShort = CUShort(aDouble)

Se även