BitConverter.ToUInt16 Metodo

Definizione

Overload

ToUInt16(ReadOnlySpan<Byte>)

Converte un intervallo di byte di sola lettura in un intero senza segno a 16 bit.

ToUInt16(Byte[], Int32)

Restituisce un intero senza segno a 16 bit convertito da due byte nella posizione specificata in una matrice di byte.

ToUInt16(ReadOnlySpan<Byte>)

Origine:
BitConverter.cs
Origine:
BitConverter.cs
Origine:
BitConverter.cs

Importante

Questa API non è conforme a CLS.

Converte un intervallo di byte di sola lettura in un intero senza segno a 16 bit.

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

Parametri

value
ReadOnlySpan<Byte>

Intervallo di sola lettura contenente i byte da convertire.

Restituisce

Intero senza segno a 16 bit che rappresenta i byte convertiti.

Attributi

Eccezioni

La lunghezza di value è minore di 2.

Si applica a

ToUInt16(Byte[], Int32)

Origine:
BitConverter.cs
Origine:
BitConverter.cs
Origine:
BitConverter.cs

Importante

Questa API non è conforme a CLS.

Restituisce un intero senza segno a 16 bit convertito da due byte nella posizione specificata in una matrice di byte.

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

Parametri

value
Byte[]

Matrice di byte che include i due byte da convertire.

startIndex
Int32

Posizione iniziale all'interno di value.

Restituisce

Un intero senza segno a 16 bit formato da due byte a partire da startIndex.

Attributi

Eccezioni

startIndex è uguale alla lunghezza di value meno 1.

value è null.

startIndexè minore di zero o maggiore della lunghezza di value meno 1.

Esempio

Nell'esempio di codice seguente gli elementi delle Byte matrici vengono convertiti in UInt16 valori con il ToUInt16 metodo .

// 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
*/
open System

let print obj1 obj2 obj3 = printfn $"{obj1,5}{obj2,17}{obj3,10}"

// Convert two byte array elements to a ushort and display it.
let BAToUInt16 bytes index =
    let value = BitConverter.ToUInt16(bytes, index)

    print index (BitConverter.ToString(bytes, index, 2)) value

let byteArray =
    [| 15uy; 0uy; 0uy; 255uy; 3uy; 16uy; 39uy; 255uy; 255uy; 127uy |]

printfn "This example of the BitConverter.ToUInt16(byte [], int) \nmethod generates the following output. It converts elements \nof a byte array to ushort values.\n"
printfn "initial byte array"
printfn "------------------"
printfn $"{BitConverter.ToString byteArray}\n"
print "index" "array elements" "ushort"
print "-----" "--------------" "------"

// 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

Commenti

Il ToUInt16 metodo converte i byte dall'indice startIndex a startIndex + 1 in un UInt16 valore. L'ordine dei byte nella matrice deve riflettere l'estremità dell'architettura del sistema del computer. Per altre informazioni, vedere la sezione Osservazioni dell'argomento della BitConverter classe.

Vedi anche

Si applica a