vb System.Convert.ToByte类(方法)实例源码

Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, "", "0xC9", "C9", "101", 
                                 "16.3", "$12", "$12.01", "-4", 
                                 "1,032", "255", "   16  " }
      For Each value In values
         Try 
            Dim number As Byte = Convert.ToByte(value)
            Console.WriteLine("'{0}' --> {1}", 
                              If(value Is Nothing, "<null>", value), number)
         Catch e As FormatException
            Console.WriteLine("Bad Format: '{0}'", 
                              If(value Is Nothing, "<null>", value))
         Catch e As OverflowException
            Console.WriteLine("OverflowException: '{0}'", value)
         End Try
      Next
   End Sub
End Module

Dim numbers() As UShort = { UInt16.MinValue, 121, 340, UInt16.MaxValue }
Dim result As Byte
For Each number As UShort In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim numbers() As UInteger = { UInt32.MinValue, 121, 340, UInt32.MaxValue }
Dim result As Byte
For Each number As UInteger In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Module Example
   Public Sub Main()
      Dim bases() As Integer = { 2, 8, 10, 16 }
      Dim values() As String = { "-1", "1", "08", "0F", "11" , "12", "30", _                
                                  "101", "255", "FF", "10000000", "80" }
      Dim number As Byte
      For Each base As Integer In bases
         Console.WriteLine("Base {0}:", base)
         For Each value As String In values
            Try
               number = Convert.ToByte(value, base)
               Console.WriteLine("   Converted '{0}' to {1}.", value, number)
            Catch e As FormatException
               Console.WriteLine("   '{0}' is not in the correct format for a base {1} conversion.", _
                                 value, base)
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is outside the range of the Byte type.", value)
            Catch e As ArgumentException
               Console.WriteLine("   '{0}' is invalid in base {1}.", value, base)
            End Try   
         Next                                 
      Next 
   End Sub
End Module

' Create a hexadecimal value out of range of the Byte type.
Dim value As String = SByte.MinValue.ToString("X")
' Convert it back to a number.
Try
   Dim number As Byte = Convert.ToByte(value, 16)
   Console.WriteLine("0x{0} converts to {1}.", value, number)
Catch e As OverflowException
   Console.WriteLine("Unable to convert '0x{0}' to a byte.", value)
End Try

' Create a negative hexadecimal value out of range of the Byte type.
Dim sourceNumber As SByte = SByte.MinValue
Dim isSigned As Boolean = Math.Sign(sourceNumber.MinValue) = -1
Dim value As String = sourceNumber.ToString("X")
Dim targetNumber As Byte
Try
   targetNumber = Convert.ToByte(value, 16)
   If isSigned And ((targetNumber And &H80) <> 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 byte.", value)
End Try 
' Displays the following to the console:
'    Unable to convert '0x80' to an unsigned byte.

' 导入命名空间
Imports System.Globalization

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

Public Structure ByteString : Implements IConvertible
   Private signBit As SignBit
   Private byteString 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 > 2 Then
            Throw New ArgumentException("The string representation of a byte cannot have more than two characters.")
         Else
            byteString = value
         End If   
      End Set
      Get
         Return byteString
      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
      If signBit = SignBit.Zero Then
         Return False
      Else
         Return True
      End If
   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.ToSByte(byteString, 16))) 
      Else
         Return Byte.Parse(byteString, NumberStyles.HexNumber)
      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.ToSByte(byteString, 16)))
      Else
         Dim byteValue As Byte = Byte.Parse(Me.byteString, NumberStyles.HexNumber)
         Return Convert.ToChar(byteValue)
      End If                
   End Function 
   
   Public Function ToDateTime(provider As IFormatProvider) As Date _
                   Implements IConvertible.ToDateTime
      Throw New InvalidCastException("ByteString 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 byteValue As SByte = SByte.Parse(byteString, NumberStyles.HexNumber)
         Return Convert.ToDecimal(byteValue)
      Else
         Dim byteValue As Byte = Byte.Parse(byteString, NumberStyles.HexNumber)
         Return Convert.ToDecimal(byteValue)
      End If
   End Function
   
   Public Function ToDouble(provider As IFormatProvider) As Double _
                   Implements IConvertible.ToDouble
      If signBit = signBit.Negative Then
         Return Convert.ToDouble(SByte.Parse(byteString, NumberStyles.HexNumber))
      Else
         Return Convert.ToDouble(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function   
   
   Public Function ToInt16(provider As IFormatProvider) As Int16 _
                   Implements IConvertible.ToInt16
      If signBit = signBit.Negative Then
         Return Convert.ToInt16(SByte.Parse(byteString, NumberStyles.HexNumber))
      Else
         Return Convert.ToInt16(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function
   
   Public Function ToInt32(provider As IFormatProvider) As Int32 _
                   Implements IConvertible.ToInt32
      If signBit = signBit.Negative Then
         Return Convert.ToInt32(SByte.Parse(byteString, NumberStyles.HexNumber))
      Else
         Return Convert.ToInt32(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function
   
   Public Function ToInt64(provider As IFormatProvider) As Int64 _
                   Implements IConvertible.ToInt64
      If signBit = signBit.Negative Then
         Return Convert.ToInt64(SByte.Parse(byteString, NumberStyles.HexNumber))
      Else
         Return Convert.ToInt64(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function
   
   Public Function ToSByte(provider As IFormatProvider) As SByte _
                   Implements IConvertible.ToSByte
      If signBit = SignBit.Positive Then
         Try
            Return Convert.ToSByte(Byte.Parse(byteString, NumberStyles.HexNumber))
         Catch e As OverflowException
            Throw New OverflowException(String.Format("{0} is outside the range of the SByte type.", _
                                                   Byte.Parse(byteString, NumberStyles.HexNumber)), e)   
         End Try
      Else
         Return SByte.Parse(byteString, NumberStyles.HexNumber)
      End If
   End Function

   Public Function ToSingle(provider As IFormatProvider) As Single _
                   Implements IConvertible.ToSingle
      If signBit = signBit.Negative Then
         Return Convert.ToSingle(SByte.Parse(byteString, NumberStyles.HexNumber))
      Else
         Return Convert.ToSingle(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function

   Public Overloads Function ToString(provider As IFormatProvider) As String _
                   Implements IConvertible.ToString
      Return Me.byteString
   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(ByteString).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.", _
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)))
      Else
         Return Convert.ToUInt16(Byte.Parse(byteString, NumberStyles.HexNumber))
      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.", _
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)))
      Else
         Return Convert.ToUInt32(Byte.Parse(byteString, NumberStyles.HexNumber))
      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.", _
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)))
      Else
         Return Convert.ToUInt64(Byte.Parse(byteString, NumberStyles.HexNumber))
      End If   
   End Function
   
End Structure

Module modMain
   Public Sub Main()
      Dim positiveByte As Byte = 216
      Dim negativeByte As SByte = -101
      
      
      Dim positiveString As New ByteString()
      positiveString.Sign = CType(Math.Sign(positiveByte), SignBit)
      positiveString.Value = positiveByte.ToString("X2")
      
      Dim negativeString As New ByteString()
      negativeString.Sign = CType(Math.Sign(negativeByte), SignBit)
      negativeString.Value = negativeByte.ToString("X2")
      
      Try
         Console.WriteLine("'{0}' converts to {1}.", positiveString.Value, Convert.ToByte(positiveString))
      Catch e As OverflowException
         Console.WriteLine("0x{0} is outside the range of the Byte type.", positiveString.Value)
      End Try

      Try
         Console.WriteLine("'{0}' converts to {1}.", negativeString.Value, Convert.ToByte(negativeString))
      Catch e As OverflowException
         Console.WriteLine("0x{0} is outside the range of the Byte type.", negativeString.Value)
      End Try   
   End Sub
End Module

' 导入命名空间
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Create a NumberFormatInfo object and set several of its
      ' properties that apply to unsigned bytes.
      Dim provider As New NumberFormatInfo()
      With provider 
         ' These properties affect the conversion.
         .PositiveSign = "pos "
         .NegativeSign = "neg "

         ' This property does not affect the conversion.
         ' The input string cannot have a decimal separator.
         .NumberDecimalSeparator = "."
      End With
      
      ' Define an array of numeric strings.
      Dim numericStrings() As String = { "234", "+234", "pos 234", "234.", _
                                         "255", "256", "-1" }

      For Each numericString As String In numericStrings
         Console.Write("'{0,-8}' ->   ", numericString)
         Try
            Dim number As Byte = Convert.ToByte(numericString, provider)
            Console.WriteLine(number)
         Catch ex As FormatException
            Console.WriteLine("Incorrect Format")                          
         Catch ex As OverflowException
            Console.WriteLine("Overflows a Byte")
         End Try   
      Next
   End Sub   
End Module

Public Sub ConvertByteSingle(ByVal byteVal As Byte)
    Dim singleVal As Single

    ' Byte to float conversion will not overflow.
    singleVal = System.Convert.ToSingle(byteVal)
    System.Console.WriteLine("The byte as a single is {0}.", _
                              singleVal)

    ' Single to byte conversion can overflow.
    Try
        byteVal = System.Convert.ToByte(singleVal)
        System.Console.WriteLine("The single as a byte is {0}.", _
                                  byteVal)
    Catch exception As System.OverflowException
        System.Console.WriteLine( _
            "Overflow in single-to-byte conversion.")
    End Try
End Sub

Dim numbers() As ULong = { UInt64.MinValue, 121, 340, UInt64.MaxValue }
Dim result As Byte
For Each number As ULong In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim numbers() As SByte = { SByte.MinValue, -1, 0, 10, SByte.MaxValue }
Dim result As Byte
For Each number As SByte In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Public Sub ConvertDoubleByte(ByVal doubleVal As Double)
    Dim byteVal As Byte = 0

    ' Double to Byte conversion can overflow.
    Try
        byteVal = System.Convert.ToByte(doubleVal)
        System.Console.WriteLine("{0} as a Byte is: {1}.", _
            doubleVal, byteVal)
    Catch exception As System.OverflowException
        System.Console.WriteLine( _
            "Overflow in Double-to-Byte conversion.")
    End Try

    ' Byte to Double conversion cannot overflow.
    doubleVal = System.Convert.ToDouble(byteVal)
    System.Console.WriteLine("{0} as a Double is: {1}.", _
                              byteVal, doubleVal)
End Sub

Dim numbers() As Long = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue }
Dim result As Byte
For Each number As Long In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim chars() As Char = { "a"c, "z"c, ChrW(7), ChrW(1023) }
For Each ch As Char in chars
   Try
      Dim result As Byte = Convert.ToByte(ch)
      Console.WriteLine("{0} is converted to {1}.", ch, result)
   Catch e As OverflowException
      Console.WriteLIne("Unable to convert u+{0} to a byte.", _
                        AscW(ch).ToString("X4"))
   End Try
Next

Dim falseFlag As Boolean = False
Dim trueFlag As Boolean = True

Console.WriteLine("{0} converts to {1}.", falseFlag, _
                  Convert.ToByte(falseFlag))
Console.WriteLine("{0} converts to {1}.", trueFlag, _
                  Convert.ToByte(trueFlag))

Dim numbers() As Short = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue }
Dim result As Byte
For Each number As Short In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
Dim result As Byte
For Each number As Integer In numbers
   Try
      result = Convert.ToByte(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 Byte type.", _
                        number.GetType().Name, number)
   End Try
Next

Public Sub ConvertByteDecimal(ByVal byteVal As Byte)
    Dim decimalVal As Decimal

    ' Byte to decimal conversion will not overflow.
    decimalVal = System.Convert.ToDecimal(byteVal)
    System.Console.WriteLine("The byte as a decimal is {0}.", _
                              decimalVal)

    ' Decimal to byte conversion can overflow.
    Try
        byteVal = System.Convert.ToByte(decimalVal)
        System.Console.WriteLine("The Decimal as a byte is {0}.", _
                                  byteVal)
    Catch exception As System.OverflowException
        System.Console.WriteLine( _
            "Overflow in decimal-to-byte conversion.")
    End Try
End Sub

Dim values() As Object = { True, -12, 163, 935, "x"c, "104", "103.0", "-1", _
                           "1.00e2", "One", 1.00e2}
Dim result As Byte
For Each value As Object In values
   Try
      result = Convert.ToByte(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 Byte type.", _
                        value.GetType().Name, value)
   Catch e As FormatException
      Console.WriteLine("The {0} value {1} is not in a recognizable format.", _
                        value.GetType().Name, value)
   Catch e As InvalidCastException
      Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.", _
                        value.GetType().Name, value)
                        
   End Try
Next