BitConverter.ToUInt16 Método

Definição

Sobrecargas

ToUInt16(ReadOnlySpan<Byte>)

Converte um intervalo de bytes somente leitura em um inteiro sem sinal de 16 bits.Converts a read-only byte-span into a 16-bit unsigned integer.

ToUInt16(Byte[], Int32)

Retorna um inteiro sem sinal de 16 bits convertido de dois bytes em uma posição especificada em uma matriz de bytes.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt16(ReadOnlySpan<Byte>)

Importante

Esta API não está em conformidade com CLS.

Converte um intervalo de bytes somente leitura em um inteiro sem sinal de 16 bits.Converts a read-only byte-span into a 16-bit unsigned integer.

public:
 static System::UInt16 ToUInt16(ReadOnlySpan<System::Byte> value);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (ReadOnlySpan<byte> value);
static member ToUInt16 : ReadOnlySpan<byte> -> uint16
Public Shared Function ToUInt16 (value As ReadOnlySpan(Of Byte)) As UShort

Parâmetros

value
ReadOnlySpan<Byte>

Um intervalo somente leitura que contém os bytes a serem convertidos.A read-only span containing the bytes to convert.

Retornos

Um inteiro sem sinal de 16 bits que representa os bytes convertidos.An 16-bit unsigned integer representing the converted bytes.

Atributos

Exceções

O tamanho de value é menor que 2.The length of value is less than the 2.

ToUInt16(Byte[], Int32)

Importante

Esta API não está em conformidade com CLS.

Retorna um inteiro sem sinal de 16 bits convertido de dois bytes em uma posição especificada em uma matriz de bytes.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

public:
 static System::UInt16 ToUInt16(cli::array <System::Byte> ^ value, int startIndex);
[System.CLSCompliant(false)]
public static ushort ToUInt16 (byte[] value, int startIndex);
static member ToUInt16 : byte[] * int -> uint16
Public Shared Function ToUInt16 (value As Byte(), startIndex As Integer) As UShort

Parâmetros

value
Byte[]

A matriz de bytes.The array of bytes.

startIndex
Int32

A posição inicial dentro de value.The starting position within value.

Retornos

Um inteiro sem sinal de 16 bits formado por dois bytes, começando em startIndex.A 16-bit unsigned integer formed by two bytes beginning at startIndex.

Atributos

Exceções

startIndex é igual ao comprimento de value menos 1.startIndex equals the length of value minus 1.

value é null.value is null.

startIndex é menor que zero ou maior que o tamanho de value menos 1.startIndex is less than zero or greater than the length of value minus 1.

Exemplos

O exemplo de código a seguir converte elementos de matrizes Byte em valores UInt16 com o método ToUInt16.The following code example converts elements of Byte arrays to UInt16 values with the ToUInt16 method.

// Example of the BitConverter::ToUInt16 method.
using namespace System;

// Convert two byte array elements to an unsigned short and display it.
void BAToUInt16( array<unsigned char>^bytes, int index )
{
   unsigned short value = BitConverter::ToUInt16( bytes, index );
   Console::WriteLine( "{0,5}{1,17}{2,16}", index, BitConverter::ToString( bytes, index, 2 ), value );
}

int main()
{
   array<unsigned char>^byteArray = {15,0,0,255,3,16,39,255,255,127};
   Console::WriteLine( "This example of the BitConverter::ToUInt16( unsigned "
   "char[ ], int ) \nmethod generates the following output. It "
   "converts elements of a \nbyte array to unsigned short "
   "values.\n" );
   Console::WriteLine( "initial byte array" );
   Console::WriteLine( "------------------" );
   Console::WriteLine( BitConverter::ToString( byteArray ) );
   Console::WriteLine();
   Console::WriteLine( "{0,5}{1,17}{2,16}", "index", "array elements", "unsigned short" );
   Console::WriteLine( "{0,5}{1,17}{2,16}", "-----", "--------------", "--------------" );
   
   // Convert byte array elements to unsigned short values.
   BAToUInt16( byteArray, 1 );
   BAToUInt16( byteArray, 0 );
   BAToUInt16( byteArray, 3 );
   BAToUInt16( byteArray, 5 );
   BAToUInt16( byteArray, 8 );
   BAToUInt16( byteArray, 7 );
}

/*
This example of the BitConverter::ToUInt16( unsigned char[ ], int )
method generates the following output. It converts elements of a
byte array to unsigned short values.

initial byte array
------------------
0F-00-00-FF-03-10-27-FF-FF-7F

index   array elements  unsigned short
-----   --------------  --------------
    1            00-00               0
    0            0F-00              15
    3            FF-03            1023
    5            10-27           10000
    8            FF-7F           32767
    7            FF-FF           65535
*/
// Example of the BitConverter.ToUInt16 method.
using System;

class BytesToUInt16Demo
{
    const string formatter = "{0,5}{1,17}{2,10}";
 
    // Convert two byte array elements to a ushort and display it.
    public static void BAToUInt16( byte[ ] bytes, int index )
    {
        ushort value = BitConverter.ToUInt16( bytes, index );

        Console.WriteLine( formatter, index, 
            BitConverter.ToString( bytes, index, 2 ), value );
    }
       
    public static void Main( )
    {
        byte[] byteArray = {
            15, 0, 0, 255, 3, 16, 39, 255, 255, 127 };

        Console.WriteLine( 
            "This example of the BitConverter.ToUInt16( byte[ ], " +
            "int ) \nmethod generates the following output. It " +
            "converts elements \nof a byte array to ushort values.\n" );
        Console.WriteLine( "initial byte array" );
        Console.WriteLine( "------------------" );
        Console.WriteLine( BitConverter.ToString( byteArray ) );
        Console.WriteLine( );
        Console.WriteLine( formatter, "index", "array elements", 
            "ushort" );
        Console.WriteLine( formatter, "-----", "--------------", 
            "------" );
          
        // Convert byte array elements to ushort values.
        BAToUInt16( byteArray, 1 );
        BAToUInt16( byteArray, 0 );
        BAToUInt16( byteArray, 3 );
        BAToUInt16( byteArray, 5 );
        BAToUInt16( byteArray, 8 );
        BAToUInt16( byteArray, 7 );
    }
}

/*
This example of the BitConverter.ToUInt16( byte[ ], int )
method generates the following output. It converts elements
of a byte array to ushort values.

initial byte array
------------------
0F-00-00-FF-03-10-27-FF-FF-7F

index   array elements    ushort
-----   --------------    ------
    1            00-00         0
    0            0F-00        15
    3            FF-03      1023
    5            10-27     10000
    8            FF-7F     32767
    7            FF-FF     65535
*/
' Example of the BitConverter.ToUInt16 method.
Module BytesToUInt16Demo

    Const formatter As String = "{0,5}{1,17}{2,10}"
 
    ' Convert two Byte array elements to a UInt16 and display it.
    Sub BAToUInt16( bytes( ) As Byte, index As Integer )

        Dim value As UInt16 = BitConverter.ToUInt16( bytes, index )

        Console.WriteLine( formatter, index, _
            BitConverter.ToString( bytes, index, 2 ), value )
    End Sub 
       
    Sub Main( )

        Dim byteArray as Byte( ) = { _
             15, 0, 0, 255, 3, 16, 39, 255, 255, 127 }

        Console.WriteLine( _
            "This example of the BitConverter.ToUInt16( Byte( ), " & _
            "Integer ) " & vbCrLf & "method generates the " & _
            "following output. It converts elements " & vbCrLf & _
            "of a Byte array to UInt16 values." & vbCrLf )
        Console.WriteLine( "initial Byte array" )
        Console.WriteLine( "------------------" )
        Console.WriteLine( BitConverter.ToString( byteArray ) )
        Console.WriteLine( )
        Console.WriteLine( formatter, "index", "array elements", _
            "UInt16" )
        Console.WriteLine( formatter, "-----", "--------------", _
            "------" )
          
        ' Convert Byte array elements to UInt16 values.
        BAToUInt16( byteArray, 1 )
        BAToUInt16( byteArray, 0 )
        BAToUInt16( byteArray, 3 )
        BAToUInt16( byteArray, 5 )
        BAToUInt16( byteArray, 8 )
        BAToUInt16( byteArray, 7 )
    End Sub 
End Module

' This example of the BitConverter.ToUInt16( Byte( ), Integer )
' method generates the following output. It converts elements
' of a Byte array to UInt16 values.
' 
' initial Byte array
' ------------------
' 0F-00-00-FF-03-10-27-FF-FF-7F
' 
' index   array elements    UInt16
' -----   --------------    ------
'     1            00-00         0
'     0            0F-00        15
'     3            FF-03      1023
'     5            10-27     10000
'     8            FF-7F     32767
'     7            FF-FF     65535

Comentários

O método ToUInt16 converte os bytes do índice startIndex em startIndex + 1 em um valor UInt16.The ToUInt16 method converts the bytes from index startIndex to startIndex + 1 to a UInt16 value. A ordem dos bytes na matriz deve refletir a endian da arquitetura do sistema do computador; para obter mais informações, consulte a seção comentários do tópico da classe BitConverter.The order of bytes in the array must reflect the endianness of the computer system's architecture; for more information, see the Remarks section of the BitConverter class topic.

Veja também

Aplica-se a