BitConverter.ToUInt16 Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Surcharges
| ToUInt16(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier non signé 16 bits. |
| ToUInt16(Byte[], Int32) |
Retourne un entier 16 bits non signé converti à partir de deux octets à une position spécifiée dans un tableau d'octets. |
ToUInt16(ReadOnlySpan<Byte>)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Important
Cette API n’est pas conforme CLS.
Convertit une étendue d’octets en lecture seule en entier non signé 16 bits.
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> -> uint16Public Shared Function ToUInt16 (value As ReadOnlySpan(Of Byte)) As UShortParamètres
- value
- ReadOnlySpan<Byte>
Étendue en lecture seule contenant les octets à convertir.
Retours
Entier non signé 16 bits représentant les octets convertis.
- Attributs
Exceptions
La longueur de value est inférieure à 2.
S’applique à
ToUInt16(Byte[], Int32)
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
- Source:
- BitConverter.cs
Important
Cette API n’est pas conforme CLS.
Retourne un entier 16 bits non signé converti à partir de deux octets à une position spécifiée dans un tableau d'octets.
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 -> uint16Public Shared Function ToUInt16 (value As Byte(), startIndex As Integer) As UShortParamètres
- value
- Byte[]
Tableau d’octets qui comprend les deux octets à convertir.
- startIndex
- Int32
Position de départ dans value.
Retours
Entier 16 bits non signé composé de deux octets, à partir de startIndex.
- Attributs
Exceptions
startIndex est égal à la longueur de value moins 1.
value a la valeur null.
startIndex est inférieur à zéro ou supérieur à la longueur de value moins 1.
Exemples
L’exemple de code suivant convertit des éléments de Byte tableaux en UInt16 valeurs avec la ToUInt16 méthode .
// 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
Remarques
La ToUInt16 méthode convertit les octets de l’index startIndex en startIndex + 1 en valeur UInt16 . L’ordre des octets dans le tableau doit refléter l’endianness de l’architecture du système informatique. Pour plus d’informations, consultez la section Remarques de la rubrique de la BitConverter classe.
Voir aussi
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour