VB.NET Convert.ToUInt64方法代码示例

Dim values() As String = { "One", "1.34e28", "-26.87", "-18", "-6.00", _
                           " 0", "137", "1601.9", Int32.MaxValue.ToString() }
Dim result As ULong

For Each value As String In values
   Try
      result = Convert.ToUInt64(value)
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                        value.GetType().Name, value, result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("{0} is outside the range of the UInt64 type.", value)
   Catch e As FormatException
      Console.WriteLine("The {0} value '{1}' is not in a recognizable format.", _
                        value.GetType().Name, value)
   End Try   
Next

Dim numbers() As UShort = { UInt16.MinValue, 121, 340, UInt16.MaxValue }
Dim result As ULong

For Each number As UShort In numbers
   result = Convert.ToUInt64(number)
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                     number.GetType().Name, number, _
                     result.GetType().Name, result)
Next

Dim numbers() As UInteger = { UInt32.MinValue, 121, 340, UInt32.MaxValue }
Dim result As ULong

For Each number As UInteger In numbers
   result = Convert.ToUInt64(number)
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                     number.GetType().Name, number, _
                     result.GetType().Name, result)
Next

Module Example
   Public Sub Main()
      Dim hexStrings() As String = { "8000000000000000", "0FFFFFFFFFFFFFFF", _
                                     "F000000000000000", "00A3000000000000", _
                                     "D", "-13", "9AC61", "GAD", _
                                     "FFFFFFFFFFFFFFFFF" }
      For Each hexString As String In hexStrings
         Console.Write("{0,-18}  -->  ", hexString)
         Try
            Dim number As ULong = Convert.ToUInt64(hexString, 16)
            Console.WriteLine("{0,26:N0}", number)
         Catch e As FormatException
            Console.WriteLine("{0,26}", "Bad Format")
         Catch e As OverflowException
            Console.WriteLine("{0,26}", "Numeric Overflow")
         Catch e As ArgumentException
            Console.WriteLine("{0,26}", "Invalid in Base 16")
         End Try
      Next                                            
   End Sub
End Module

' Create a hexadecimal value out of range of the UInt64 type.
Dim value As String = Convert.ToString(Long.MinValue, 16)
' Convert it back to a number.
Try
   Dim number As UInt64 = Convert.ToUInt64(value, 16)
   Console.WriteLine("0x{0} converts to {1}.", value, number)
Catch e As OverflowException
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned long integer.", _
                     value)
End Try

' Create a negative hexadecimal value out of range of the UInt64 type.
Dim sourceNumber As Long = Long.MinValue
Dim isSigned As Boolean = Math.Sign(sourceNumber.MinValue) = -1
Dim value As String = Convert.ToString(sourceNumber, 16)
Dim targetNumber As UInt64
Try
   targetNumber = Convert.ToUInt64(value, 16)
   If isSigned And ((targetNumber And &H8000000000000000ul) <> 0) Then
      Throw New OverflowException()
   Else 
      Console.WriteLine("0x{0} converts to {1}.", value, targetNumber)
   End If    
Catch e As OverflowException
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned long integer.", _
                     value)
End Try 
' Displays the following to the console:
'    Unable to convert '0x8000' to an unsigned long integer.

' 导入命名空间
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Enum SignBit As Integer
   Positive = 1
   Zero = 0
   Negative = -1
End Enum

Public Structure HexString : Implements IConvertible
   Private signBit As SignBit
   Private hexString As String
   
   Public Property Sign As SignBit
      Set
         signBit = value
      End Set
      Get
         Return signBit
      End Get
   End Property
   
   Public Property Value As String
      Set
         If value.Trim().Length > 16 Then
            Throw New ArgumentException("The hexadecimal representation of a 64-bit integer cannot have more than 16 characters.")
         ElseIf Not Regex.IsMatch(value, "([0-9,A-F]){1,8}", RegexOptions.IgnoreCase) Then
            Throw New ArgumentException("The hexadecimal representation of a 64-bit integer contains invalid characters.")             
         Else
            hexString = value
         End If   
      End Set
      Get
         Return hexString
      End Get
   End Property
   
   ' IConvertible implementations.
   Public Function GetTypeCode() As TypeCode _
                   Implements IConvertible.GetTypeCode
      Return TypeCode.Object
   End Function
   
   Public Function ToBoolean(provider As IFormatProvider) As Boolean _
                   Implements IConvertible.ToBoolean
      Return signBit <> SignBit.Zero
   End Function 
   
   Public Function ToByte(provider As IFormatProvider) As Byte _
                   Implements IConvertible.ToByte
      If signBit = SignBit.Negative Then
         Throw New OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToInt64(hexString, 16))) 
      Else
         Try
            Return Byte.Parse(hexString, NumberStyles.HexNumber)
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToUInt64(hexString, 16)), e)
         End Try   
      End If       
   End Function
   
   Public Function ToChar(provider As IFormatProvider) As Char _
                   Implements IConvertible.ToChar
      If signBit = SignBit.Negative Then 
         Throw New OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToInt64(hexString, 16)))
      End If
      
      Try
         Dim codePoint As UInt16 = UInt16.Parse(Me.hexString, NumberStyles.HexNumber)
         Return Convert.ToChar(codePoint)
      Catch e As OverflowException
         Throw New OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToUInt64(hexString, 16)))
      End Try      
   End Function 
   
   Public Function ToDateTime(provider As IFormatProvider) As Date _
                   Implements IConvertible.ToDateTime
      Throw New InvalidCastException("Hexadecimal to DateTime conversion is not supported.")
   End Function
   
   Public Function ToDecimal(provider As IFormatProvider) As Decimal _
                   Implements IConvertible.ToDecimal
      If signBit = SignBit.Negative Then
         Dim hexValue As Long = Int64.Parse(hexString, NumberStyles.HexNumber)
         Return Convert.ToDecimal(hexValue)
      Else
         Dim hexValue As ULong = UInt64.Parse(hexString, NumberStyles.HexNumber)
         Return Convert.ToDecimal(hexValue)
      End If
   End Function
   
   Public Function ToDouble(provider As IFormatProvider) As Double _
                   Implements IConvertible.ToDouble
      If signBit = SignBit.Negative Then
         Return Convert.ToDouble(Int64.Parse(hexString, NumberStyles.HexNumber))
      Else
         Return Convert.ToDouble(UInt64.Parse(hexString, NumberStyles.HexNumber))
      End If   
   End Function   
   
   Public Function ToInt16(provider As IFormatProvider) As Int16 _
                   Implements IConvertible.ToInt16
      If signBit = SignBit.Negative Then
         Try
            Return Convert.ToInt16(Int64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Int16 type.", Convert.ToInt64(hexString, 16)), e)
         End Try
      Else
         Try
            Return Convert.ToInt16(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Int16 type.", Convert.ToUInt64(hexString, 16)), e)
         End Try
      End If   
   End Function
   
   Public Function ToInt32(provider As IFormatProvider) As Int32 _
                   Implements IConvertible.ToInt32
      If signBit = SignBit.Negative Then
         Try
            Return Convert.ToInt32(Int64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Int32 type.", Convert.ToUInt64(hexString, 16)), e)
         End Try
      Else
         Try
            Return Convert.ToInt32(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Int32 type.", Convert.ToUInt64(hexString, 16)), e)
         End Try   
      End If   
   End Function
   
   Public Function ToInt64(provider As IFormatProvider) As Int64 _
                   Implements IConvertible.ToInt64
      If signBit = SignBit.Negative Then
         Return Int64.Parse(hexString, NumberStyles.HexNumber)
      Else
         Try
            Return Convert.ToInt64(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the Int64 type.", Convert.ToUInt64(hexString, 16)), e)
         End Try
      End If   
   End Function
   
   Public Function ToSByte(provider As IFormatProvider) As SByte _
                   Implements IConvertible.ToSByte
      If signBit = SignBit.Negative Then
         Try
            Return Convert.ToSByte(Int64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is outside the range of the SByte type.", _
                                                      Int64.Parse(hexString, NumberStyles.HexNumber), e))
         End Try
      Else
         Try
            Return Convert.ToSByte(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is outside the range of the SByte type.", _
                                                    UInt64.Parse(hexString, NumberStyles.HexNumber)), e)
         End Try   
      End If
   End Function

   Public Function ToSingle(provider As IFormatProvider) As Single _
                   Implements IConvertible.ToSingle
      If signBit = SignBit.Negative Then
         Return Convert.ToSingle(Int64.Parse(hexString, NumberStyles.HexNumber))
      Else
         Return Convert.ToSingle(UInt64.Parse(hexString, NumberStyles.HexNumber))
      End If   
   End Function

   Public Overloads Function ToString(provider As IFormatProvider) As String _
                   Implements IConvertible.ToString
      Return "0x" & Me.hexString
   End Function
   
   Public Function ToType(conversionType As Type, provider As IFormatProvider) As Object _
                   Implements IConvertible.ToType
      Select Case Type.GetTypeCode(conversionType)
         Case TypeCode.Boolean 
            Return Me.ToBoolean(Nothing)
         Case TypeCode.Byte
            Return Me.ToByte(Nothing)
         Case TypeCode.Char
            Return Me.ToChar(Nothing)
         Case TypeCode.DateTime
            Return Me.ToDateTime(Nothing)
         Case TypeCode.Decimal
            Return Me.ToDecimal(Nothing)
         Case TypeCode.Double
            Return Me.ToDouble(Nothing)
         Case TypeCode.Int16
            Return Me.ToInt16(Nothing)
         Case TypeCode.Int32
            Return Me.ToInt32(Nothing)
         Case TypeCode.Int64
            Return Me.ToInt64(Nothing)
         Case TypeCode.Object
            If GetType(HexString).Equals(conversionType) Then
               Return Me
            Else
               Throw New InvalidCastException(String.Format("Conversion to a {0} is not supported.", conversionType.Name))
            End If 
         Case TypeCode.SByte
            Return Me.ToSByte(Nothing)
         Case TypeCode.Single
            Return Me.ToSingle(Nothing)
         Case TypeCode.String
            Return Me.ToString(Nothing)
         Case TypeCode.UInt16
            Return Me.ToUInt16(Nothing)
         Case TypeCode.UInt32
            Return Me.ToUInt32(Nothing)
         Case TypeCode.UInt64
            Return Me.ToUInt64(Nothing)   
         Case Else
            Throw New InvalidCastException(String.Format("Conversion to {0} is not supported.", conversionType.Name))   
      End Select
   End Function
   
   Public Function ToUInt16(provider As IFormatProvider) As UInt16 _
                   Implements IConvertible.ToUInt16
      If signBit = SignBit.Negative Then
         Throw New OverflowException(String.Format("{0} is outside the range of the UInt16 type.", _
                                                   Int64.Parse(hexString, NumberStyles.HexNumber)))
      Else
         Try
            Return Convert.ToUInt16(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is out of range of the UInt16 type.", Convert.ToUInt64(hexString, 16)), e)
         End Try            
      End If   
   End Function

   Public Function ToUInt32(provider As IFormatProvider) As UInt32 _
                   Implements IConvertible.ToUInt32
      If signBit = SignBit.Negative Then
         Throw New OverflowException(String.Format("{0} is outside the range of the UInt32 type.", _
                                                   Int64.Parse(hexString, NumberStyles.HexNumber)))
      Else
         Try
            Return Convert.ToUInt32(UInt64.Parse(hexString, NumberStyles.HexNumber))
         Catch e As OverflowException
         Throw New OverflowException(String.Format("{0} is outside the range of the UInt32 type.", _
                                                   UInt64.Parse(hexString, NumberStyles.HexNumber)))
         End Try   
      End If   
   End Function
   
   Public Function ToUInt64(provider As IFormatProvider) As UInt64 _
                   Implements IConvertible.ToUInt64
      If signBit = SignBit.Negative Then
         Throw New OverflowException(String.Format("{0} is outside the range of the UInt64 type.", _
                                                   Int64.Parse(hexString, NumberStyles.HexNumber)))
      Else
         Return Convert.ToUInt64(hexString, 16)
      End If   
   End Function
End Structure

Module Example
   Public Sub Main()
      Dim positiveValue As UInt64 = CULng(UInt64.MaxValue - 100000)
      Dim negativeValue As Int64 = -1
      
      
      Dim positiveString As New HexString()
      positiveString.Sign = CType(Math.Sign(positiveValue), SignBit)
      positiveString.Value = positiveValue.ToString("X")
      
      Dim negativeString As New HexString()
      negativeString.Sign = CType(Math.Sign(negativeValue), SignBit)
      negativeString.Value = negativeValue.ToString("X")
      
      Try
         Console.WriteLine("0x{0} converts to {1}.", positiveString.Value, Convert.ToUInt64(positiveString))
      Catch e As OverflowException
         Console.WriteLine("{0} is outside the range of the UInt64 type.", _
                           Int64.Parse(positiveString.Value, NumberStyles.HexNumber))
      End Try

      Try
         Console.WriteLine("0x{0} converts to {1}.", negativeString.Value, Convert.ToUInt64(negativeString))
      Catch e As OverflowException
         Console.WriteLine("{0} is outside the range of the UInt64 type.", _
                           Int64.Parse(negativeString.Value, NumberStyles.HexNumber))
      End Try   
   End Sub
End Module

' 导入命名空间
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Create a NumberFormatInfo object and set several properties.
      Dim provider As New NumberFormatInfo()
      provider.PositiveSign = "pos "
      provider.NegativeSign = "neg "

      ' Define an array of numeric strings.
      Dim values() As String = { "123456789012", "+123456789012", _
                                 "pos 123456789012", "123456789012.", _
                                 "123,456,789,012", "18446744073709551615", _
                                 "18446744073709551616", "neg 1", "-1" }
      '  Convert the strings using the format provider.
      For Each value As String In values
         Console.Write("{0,-20}  -->  ", value)
         Try
            Console.WriteLine("{0,20}", Convert.ToUInt64(value, provider))
         Catch e As FormatException
            Console.WriteLine("{0,20}", "Invalid Format")
         Catch e As OverflowException
            Console.WriteLine("{0,20}", "Numeric Overflow")
         End Try               
      Next
    End Sub 
End Module

Dim values() As Single = { Single.MinValue, -1.38e10, -1023.299, -12.98, _
                              0, 9.113e-16, 103.919, 17834.191, Single.MaxValue }
   Dim result As ULong
   
   For Each value As Single In values
      Try
         result = Convert.ToUInt64(value)
         Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                           value.GetType().Name, value, result.GetType().Name, result)
      Catch e As OverflowException
         Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                           value.GetType().Name, value)
      End Try   
   Next                                 
   ' The example displays the following output:
'    The Single value -3.402823E+38 is outside the range of the UInt64 type.
'    The Single value -1.38E+10 is outside the range of the UInt64 type.
'    The Single value -1023.299 is outside the range of the UInt64 type.
'    The Single value -12.98 is outside the range of the UInt64 type.
'    Converted the Single value 0 to the UInt64 value 0.
'    Converted the Single value 9.113E-16 to the UInt64 value 0.
'    Converted the Single value 103.919 to the UInt64 value 104.
'    Converted the Single value 17834.19 to the UInt64 value 17834.
'    The Single value 3.402823E+38 is outside the range of the UInt64 type.

Dim numbers() As SByte = { SByte.MinValue, -1, 0, 10, SByte.MaxValue }
Dim result As ULong

For Each number As SByte In numbers
   Try
      result = Convert.ToUInt64(number)
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                        number.GetType().Name, number, _
                        result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim numbers() As Short = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue }
Dim result As ULong

For Each number As Short In numbers
   Try
      result = Convert.ToUInt64(number)
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                           number.GetType().Name, number, _
                           result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                        number.GetType().Name, number)
   End Try   
Next

Dim numbers() As Long = { Int64.MinValue, -19432, -18, 0, 121, 340, Int64.MaxValue }
Dim result As ULong

For Each number As Long In numbers
   Try
      result = Convert.ToUInt64(number)
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                        number.GetType().Name, number, _
                        result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
Dim result As ULong

For Each number As Integer In numbers
   Try
      result = Convert.ToUInt64(number)
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                        number.GetType().Name, number, _
                        result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                        number.GetType().Name, number)
   End Try   
Next

Dim values() As Double = { Double.MinValue, -1.38e10, -1023.299, -12.98, _
                           0, 9.113e-16, 103.919, 17834.191, Double.MaxValue }
Dim result As ULong

For Each value As Double In values
   Try
      result = Convert.ToUInt64(value)
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                        value.GetType().Name, value, _
                        result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("The {0} value {1} is outside the range of the UInt64 type.", _
                        value.GetType().Name, value)
   End Try   
Next