BitConverter.ToUInt16 Methode

Definitie

Naamruimte:
System
Assembly's:
netstandard.dll, System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
netstandard.dll
Assembly's:
mscorlib.dll, System.Runtime.Extensions.dll
Assembly:
mscorlib.dll

Overloads

Name Description
ToUInt16(ReadOnlySpan<Byte>)

Converteert een alleen-lezen bytespanne naar een 16-bits geheel getal zonder teken.
ToUInt16(Byte[], Int32)

Retourneert een niet-ondertekend geheel getal van 16 bits dat is geconverteerd van twee bytes op een opgegeven positie in een bytematrix.

ToUInt16(ReadOnlySpan<Byte>)

Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs

Belangrijk

Deze API is niet CLS-conform.

Converteert een alleen-lezen bytespanne naar een 16-bits geheel getal zonder teken.

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

Parameters

value
ReadOnlySpan<Byte>

Een alleen-lezen periode met de bytes die u wilt converteren.

Retouren

UInt16

Een 16-bits geheel getal zonder teken dat de geconverteerde bytes vertegenwoordigt.

Kenmerken
CLSCompliantAttribute

Uitzonderingen

ArgumentOutOfRangeException

De lengte is value kleiner dan 2.

Van toepassing op

ToUInt16(Byte[], Int32)

Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs
Bron:
BitConverter.cs

Belangrijk

Deze API is niet CLS-conform.

Retourneert een niet-ondertekend geheel getal van 16 bits dat is geconverteerd van twee bytes op een opgegeven positie in een bytematrix.

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

Parameters

value
Byte[]

De matrix van bytes die de twee bytes bevat die moeten worden geconverteerd.

startIndex
Int32

De beginpositie binnen value.

Retouren

UInt16

Een 16-bits geheel getal zonder teken dat wordt gevormd door twee bytes die beginnen bij startIndex.

Kenmerken
CLSCompliantAttribute

Uitzonderingen

ArgumentException

startIndex is gelijk aan de lengte van value min 1.

ArgumentNullException

value is null.

ArgumentOutOfRangeException

startIndex is kleiner dan nul of groter dan de lengte van value min 1.

Voorbeelden

In het volgende codevoorbeeld worden elementen van Byte matrices geconverteerd naar UInt16 waarden met de ToUInt16 methode.

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

Opmerkingen

De ToUInt16 methode converteert de bytes van index startIndex naar startIndex + 1 naar een UInt16 waarde. De volgorde van bytes in de matrix moet de endianiteit van de architectuur van het computersysteem weerspiegelen. Zie de sectie Opmerkingen van het BitConverter klasonderwerp voor meer informatie.

Zie ook

Van toepassing op