BitConverter Classe
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.
Convertit les types de données de base en un tableau d’octets et un tableau d’octets en types de données de base.
public ref class BitConverter abstract sealedpublic ref class BitConverter sealedpublic static class BitConverterpublic sealed class BitConvertertype BitConverter = classPublic Class BitConverterPublic NotInheritable Class BitConverter- Héritage
-
BitConverter
Exemples
L’exemple de code suivant illustre l’utilisation de plusieurs méthodes de classe BitConverter.
// Example of BitConverter class methods.
using namespace System;
int main()
{
String^ formatter = "{0,25}{1,30}";
double aDoubl = 0.1111111111111111111;
float aSingl = 0.1111111111111111111F;
__int64 aLong = 1111111111111111111;
int anInt = 1111111111;
short aShort = 11111;
__wchar_t aChar = L'*';
bool aBool = true;
Console::WriteLine( "This example of methods of the BitConverter class"
"\ngenerates the following output.\n" );
Console::WriteLine( formatter, "argument", "byte array" );
Console::WriteLine( formatter, "--------", "----------" );
// Convert values to Byte arrays and display them.
Console::WriteLine( formatter, aDoubl, BitConverter::ToString( BitConverter::GetBytes( aDoubl ) ) );
Console::WriteLine( formatter, aSingl, BitConverter::ToString( BitConverter::GetBytes( aSingl ) ) );
Console::WriteLine( formatter, aLong, BitConverter::ToString( BitConverter::GetBytes( aLong ) ) );
Console::WriteLine( formatter, anInt, BitConverter::ToString( BitConverter::GetBytes( anInt ) ) );
Console::WriteLine( formatter, aShort, BitConverter::ToString( BitConverter::GetBytes( aShort ) ) );
Console::WriteLine( formatter, aChar, BitConverter::ToString( BitConverter::GetBytes( aChar ) ) );
Console::WriteLine( formatter, aBool, BitConverter::ToString( BitConverter::GetBytes( aBool ) ) );
}
/*
This example of methods of the BitConverter class
generates the following output.
argument byte array
-------- ----------
0.111111111111111 1C-C7-71-1C-C7-71-BC-3F
0.1111111 39-8E-E3-3D
1111111111111111111 C7-71-C4-2B-AB-75-6B-0F
1111111111 C7-35-3A-42
11111 67-2B
* 2A-00
True 01
*/
// Example of BitConverter class methods.
using System;
class BitConverterDemo
{
public static void Main( )
{
const string formatter = "{0,25}{1,30}";
double aDoubl = 0.1111111111111111111;
float aSingl = 0.1111111111111111111F;
long aLong = 1111111111111111111;
int anInt = 1111111111;
short aShort = 11111;
char aChar = '*';
bool aBool = true;
Console.WriteLine(
"This example of methods of the BitConverter class" +
"\ngenerates the following output.\n" );
Console.WriteLine( formatter, "argument", "byte array" );
Console.WriteLine( formatter, "--------", "----------" );
// Convert values to Byte arrays and display them.
Console.WriteLine( formatter, aDoubl,
BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) );
Console.WriteLine( formatter, aSingl,
BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) );
Console.WriteLine( formatter, aLong,
BitConverter.ToString( BitConverter.GetBytes( aLong ) ) );
Console.WriteLine( formatter, anInt,
BitConverter.ToString( BitConverter.GetBytes( anInt ) ) );
Console.WriteLine( formatter, aShort,
BitConverter.ToString( BitConverter.GetBytes( aShort ) ) );
Console.WriteLine( formatter, aChar,
BitConverter.ToString( BitConverter.GetBytes( aChar ) ) );
Console.WriteLine( formatter, aBool,
BitConverter.ToString( BitConverter.GetBytes( aBool ) ) );
}
}
/*
This example of methods of the BitConverter class
generates the following output.
argument byte array
-------- ----------
0.111111111111111 1C-C7-71-1C-C7-71-BC-3F
0.1111111 39-8E-E3-3D
1111111111111111111 C7-71-C4-2B-AB-75-6B-0F
1111111111 C7-35-3A-42
11111 67-2B
* 2A-00
True 01
*/
open System
let print: obj -> obj -> unit = printfn "%25O%30O"
let aDoubl = 0.1111111111111111111
let aSingl = 0.1111111111111111111f
let aLong = 1111111111111111111L
let anInt = 1111111111
let aShort = 11111s
let aChar = '*'
let aBool = true
printfn "This example of methods of the BitConverter class\ngenerates the following output.\n"
print "argument" "byte array"
print "--------" "----------"
// Convert values to Byte arrays and display them.
print aDoubl (BitConverter.ToString(BitConverter.GetBytes aDoubl))
print aSingl (BitConverter.ToString(BitConverter.GetBytes aSingl))
print aLong (BitConverter.ToString(BitConverter.GetBytes aLong))
print anInt (BitConverter.ToString(BitConverter.GetBytes anInt))
print aShort (BitConverter.ToString(BitConverter.GetBytes aShort))
print aChar (BitConverter.ToString(BitConverter.GetBytes aChar))
print aBool (BitConverter.ToString(BitConverter.GetBytes aBool))
// This example of methods of the BitConverter class
// generates the following output.
//
// argument byte array
// -------- ----------
// 0.111111111111111 1C-C7-71-1C-C7-71-BC-3F
// 0.1111111 39-8E-E3-3D
// 1111111111111111111 C7-71-C4-2B-AB-75-6B-0F
// 1111111111 C7-35-3A-42
// 11111 67-2B
// * 2A-00
// True 01
' Example of BitConverter class methods.
Module BitConverterDemo
Sub Main( )
Const formatter As String = "{0,25}{1,30}"
Dim aDoubl As Double = 0.1111111111111111111
Dim aSingl As Single = 0.1111111111111111111
Dim aLong As Long = 1111111111111111111
Dim anInt As Integer = 1111111111
Dim aShort As Short = 11111
Dim aChar As Char = "*"c
Dim aBool As Boolean = True
Console.WriteLine( _
"This example of methods of the BitConverter class" & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( formatter, "argument", "Byte array" )
Console.WriteLine( formatter, "--------", "----------" )
' Convert values to Byte arrays and display them.
Console.WriteLine( formatter, aDoubl, _
BitConverter.ToString( BitConverter.GetBytes( aDoubl ) ) )
Console.WriteLine( formatter, aSingl, _
BitConverter.ToString( BitConverter.GetBytes( aSingl ) ) )
Console.WriteLine( formatter, aLong, _
BitConverter.ToString( BitConverter.GetBytes( aLong ) ) )
Console.WriteLine( formatter, anInt, _
BitConverter.ToString( BitConverter.GetBytes( anInt ) ) )
Console.WriteLine( formatter, aShort, _
BitConverter.ToString( BitConverter.GetBytes( aShort ) ) )
Console.WriteLine( formatter, aChar, _
BitConverter.ToString( BitConverter.GetBytes( aChar ) ) )
Console.WriteLine( formatter, aBool, _
BitConverter.ToString( BitConverter.GetBytes( aBool ) ) )
End Sub
End Module
' This example of methods of the BitConverter class
' generates the following output.
'
' argument Byte array
' -------- ----------
' 0.111111111111111 1C-C7-71-1C-C7-71-BC-3F
' 0.1111111 39-8E-E3-3D
' 1111111111111111111 C7-71-C4-2B-AB-75-6B-0F
' 1111111111 C7-35-3A-42
' 11111 67-2B
' * 2A-00
' True 01
Remarques
La classe BitConverter permet de manipuler des types valeur sous leur forme fondamentale, sous la forme d’une série d’octets. Un octet est défini comme un entier non signé 8 bits. La classe BitConverter inclut des méthodes statiques pour convertir chacun des types primitifs en un tableau d’octets, comme le montre le tableau suivant.
Si vous utilisez BitConverter méthodes pour aller-retour des données, assurez-vous que la surcharge GetBytes et la méthode ToType spécifiez le même type. Comme l’illustre l’exemple suivant, la restauration d’un tableau qui représente un entier signé en appelant la méthode ToUInt32 peut entraîner une valeur différente de l’original. Pour plus d’informations, consultez Utilisation des valeurs non décimales et binaires signées.
using System;
public class Example
{
public static void Main()
{
int value = -16;
Byte[] bytes = BitConverter.GetBytes(value);
// Convert bytes back to int.
int intValue = BitConverter.ToInt32(bytes, 0);
Console.WriteLine("{0} = {1}: {2}",
value, intValue,
value.Equals(intValue) ? "Round-trips" : "Does not round-trip");
// Convert bytes to UInt32.
uint uintValue = BitConverter.ToUInt32(bytes, 0);
Console.WriteLine("{0} = {1}: {2}", value, uintValue,
value.Equals(uintValue) ? "Round-trips" : "Does not round-trip");
}
}
// The example displays the following output:
// -16 = -16: Round-trips
// -16 = 4294967280: Does not round-trip
open System
let value = -16
let bytes = BitConverter.GetBytes value
// Convert bytes back to int.
let intValue = BitConverter.ToInt32(bytes, 0)
printfn $"""{value} = {intValue}: {if value.Equals intValue then "Round-trips" else "Does not round-trip"}"""
// Convert bytes to UInt32.
let uintValue = BitConverter.ToUInt32(bytes, 0)
printfn $"""{value} = {uintValue}: {if value.Equals uintValue then "Round-trips" else "Does not round-trip"}"""
// The example displays the following output:
// -16 = -16: Round-trips
// -16 = 4294967280: Does not round-trip
Module Example
Public Sub Main()
Dim value As Integer = -16
Dim bytes() As Byte = BitConverter.GetBytes(value)
' Convert bytes back to Int32.
Dim intValue As Integer = BitConverter.ToInt32(bytes, 0)
Console.WriteLine("{0} = {1}: {2}",
value, intValue,
If(value.Equals(intValue), "Round-trips", "Does not round-trip"))
' Convert bytes to UInt32.
Dim uintValue As UInteger = BitConverter.ToUInt32(bytes, 0)
Console.WriteLine("{0} = {1}: {2}", value, uintValue,
If(value.Equals(uintValue), "Round-trips", "Does not round-trip"))
End Sub
End Module
' The example displays the following output:
' -16 = -16: Round-trips
' -16 = 4294967280: Does not round-trip
L’ordre des octets dans le tableau retourné par les surcharges de méthode GetBytes (ainsi que l’ordre des bits dans l’entier retourné par la méthode DoubleToInt64Bits) varie selon que l’architecture de l’ordinateur est petite-endienne ou big-endian. De même, l’ordre des octets dans le tableau et retourné par les méthodes ToIntegerValue et la méthode ToChar varie selon que l’architecture de l’ordinateur est peu endiane ou big-endian. L’endianité d’une architecture est indiquée par la propriété IsLittleEndian, qui retourne true sur les systèmes peu endiens et les false sur les systèmes big-endian. Sur les systèmes little-endian, les octets de l’ordre inférieur précèdent les octets de l’ordre supérieur. Sur le système big-endian, les octets de l’ordre supérieur précèdent les octets de l’ordre inférieur. Le tableau suivant illustre la différence dans les tableaux d’octets qui résultent du passage de l’entier 1 234 567 890 (0x499602D2) à la méthode GetBytes(Int32). Les octets sont répertoriés dans l’ordre entre l’octet à l’index 0 et l’octet à l’index 3.
| Little-endian | D2-02-96-49 |
| Big-endian | 49-96-02-D2 |
Étant donné que la valeur de retour de certaines méthodes dépend de l’architecture système, veillez à transmettre des données d’octet au-delà des limites de la machine :
Si tous les systèmes qui envoient et reçoivent des données sont assurés d’avoir la même endianité, rien n’est à faire pour les données.
Si les systèmes qui envoient et reçoivent des données peuvent avoir une endianité différente, transmettez toujours des données dans un ordre particulier. Cela signifie que l’ordre des octets du tableau peut être inversé avant de les envoyer ou après leur réception. Une convention commune consiste à transmettre des données dans l’ordre d’octet réseau (ordre big-endian). L’exemple suivant fournit une implémentation pour l’envoi d’une valeur entière dans l’ordre d’octets réseau.
using System; public class Example { public static void Main() { int value = 12345678; byte[] bytes = BitConverter.GetBytes(value); Console.WriteLine(BitConverter.ToString(bytes)); if (BitConverter.IsLittleEndian) Array.Reverse(bytes); Console.WriteLine(BitConverter.ToString(bytes)); // Call method to send byte stream across machine boundaries. // Receive byte stream from beyond machine boundaries. Console.WriteLine(BitConverter.ToString(bytes)); if (BitConverter.IsLittleEndian) Array.Reverse(bytes); Console.WriteLine(BitConverter.ToString(bytes)); int result = BitConverter.ToInt32(bytes, 0); Console.WriteLine("Original value: {0}", value); Console.WriteLine("Returned value: {0}", result); } } // The example displays the following output on a little-endian system: // 4E-61-BC-00 // 00-BC-61-4E // 00-BC-61-4E // 4E-61-BC-00 // Original value: 12345678 // Returned value: 12345678open System let value = 12345678 let bytes = BitConverter.GetBytes value printfn $"{BitConverter.ToString bytes}" if BitConverter.IsLittleEndian then Array.Reverse bytes printfn $"{BitConverter.ToString bytes}" // Call method to send byte stream across machine boundaries. // Receive byte stream from beyond machine boundaries. printfn $"{BitConverter.ToString bytes}" if BitConverter.IsLittleEndian then Array.Reverse bytes printfn $"{BitConverter.ToString bytes}" let result = BitConverter.ToInt32(bytes, 0) printfn $"Original value: {value}" printfn $"Returned value: {result}" // The example displays the following output on a little-endian system: // 4E-61-BC-00 // 00-BC-61-4E // 00-BC-61-4E // 4E-61-BC-00 // Original value: 12345678 // Returned value: 12345678Module Example Public Sub Main() Dim value As Integer = 12345678 Dim bytes() As Byte = BitConverter.GetBytes(value) Console.WriteLine(BitConverter.ToString(bytes)) If BitConverter.IsLittleEndian Then Array.Reverse(bytes) End If Console.WriteLine(BitConverter.ToString(bytes)) ' Call method to send byte stream across machine boundaries. ' Receive byte stream from beyond machine boundaries. Console.WriteLine(BitConverter.ToString(bytes)) If BitConverter.IsLittleEndian Then Array.Reverse(bytes) End If Console.WriteLine(BitConverter.ToString(bytes)) Dim result As Integer = BitConverter.ToInt32(bytes, 0) Console.WriteLine("Original value: {0}", value) Console.WriteLine("Returned value: {0}", result) End Sub End Module ' The example displays the following output on a little-endian system: ' 4E-61-BC-00 ' 00-BC-61-4E ' 00-BC-61-4E ' 4E-61-BC-00 ' Original value: 12345678 ' Returned value: 12345678Si les systèmes qui envoient et reçoivent des données peuvent avoir différentes endianités et que les données à transmettre sont constituées d’entiers signés, appelez la méthode IPAddress.HostToNetworkOrder pour convertir les données en ordre d’octet réseau et la méthode IPAddress.NetworkToHostOrder pour la convertir en ordre requis par le destinataire.
Champs
| IsLittleEndian |
Indique l’ordre d’octet (« endianness ») dans lequel les données sont stockées dans cette architecture d’ordinateur. |
Méthodes
| DoubleToInt64Bits(Double) |
Convertit le nombre à virgule flottante double précision spécifié en entier signé 64 bits. |
| DoubleToUInt64Bits(Double) |
Convertit le nombre à virgule flottante double précision spécifié en entier non signé 64 bits. |
| GetBytes(Boolean) |
Retourne la valeur booléenne spécifiée en tant que tableau d’octets. |
| GetBytes(Char) |
Retourne la valeur de caractère Unicode spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Double) |
Retourne la valeur à virgule flottante double précision spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Half) |
Retourne la valeur à virgule flottante demi-précision spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Int128) |
Retourne la valeur entière signée 128 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Int16) |
Retourne la valeur entière signée 16 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Int32) |
Retourne la valeur entière signée 32 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Int64) |
Retourne la valeur entière signée 64 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(Single) |
Retourne la valeur à virgule flottante simple précision spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(UInt128) |
Retourne la valeur entière non signée 128 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(UInt16) |
Retourne la valeur entière non signée 16 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(UInt32) |
Retourne la valeur entière non signée 32 bits spécifiée sous la forme d’un tableau d’octets. |
| GetBytes(UInt64) |
Retourne la valeur entière non signée 64 bits spécifiée sous la forme d’un tableau d’octets. |
| HalfToInt16Bits(Half) |
Convertit une valeur à virgule flottante demi-précision en entier 16 bits. |
| HalfToUInt16Bits(Half) |
Convertit le nombre à virgule flottante demi-précision spécifié en entier non signé 16 bits. |
| Int16BitsToHalf(Int16) |
Réinterprète la valeur entière signée 16 bits spécifiée sous la forme d’une valeur à virgule flottante demi-précision. |
| Int32BitsToSingle(Int32) |
Réinterprète l’entier 32 bits spécifié sous la forme d’une valeur à virgule flottante simple précision. |
| Int64BitsToDouble(Int64) |
Réinterpret l’entier signé 64 bits spécifié en nombre à virgule flottante double précision. |
| SingleToInt32Bits(Single) |
Convertit une valeur à virgule flottante simple précision en entier. |
| SingleToUInt32Bits(Single) |
Convertit le nombre à virgule flottante simple précision spécifié en entier non signé 32 bits. |
| ToBoolean(Byte[], Int32) |
Retourne une valeur booléenne convertie à partir de l’octet à une position spécifiée dans un tableau d’octets. |
| ToBoolean(ReadOnlySpan<Byte>) |
Convertit une étendue d’octet en lecture seule en valeur booléenne. |
| ToChar(Byte[], Int32) |
Retourne un caractère Unicode converti de deux octets à une position spécifiée dans un tableau d’octets. |
| ToChar(ReadOnlySpan<Byte>) |
Convertit une étendue d’octet en lecture seule en un caractère. |
| ToDouble(Byte[], Int32) |
Retourne un nombre à virgule flottante double précision converti de huit octets à une position spécifiée dans un tableau d’octets. |
| ToDouble(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en une valeur à virgule flottante double précision. |
| ToHalf(Byte[], Int32) |
Retourne un nombre à virgule flottante demi-précision converti de deux octets à une position spécifiée dans un tableau d’octets. |
| ToHalf(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en une valeur à virgule flottante demi-précision. |
| ToInt128(Byte[], Int32) |
Retourne un entier signé 128 bits converti de seize octets à une position spécifiée dans un tableau d’octets. |
| ToInt128(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier signé 128 bits. |
| ToInt16(Byte[], Int32) |
Retourne un entier signé 16 bits converti à partir de deux octets à une position spécifiée dans un tableau d’octets. |
| ToInt16(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier signé 16 bits. |
| ToInt32(Byte[], Int32) |
Retourne un entier signé 32 bits converti de quatre octets à une position spécifiée dans un tableau d’octets. |
| ToInt32(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier signé 32 bits. |
| ToInt64(Byte[], Int32) |
Retourne un entier signé 64 bits converti à partir de huit octets à une position spécifiée dans un tableau d’octets. |
| ToInt64(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier signé 64 bits. |
| ToSingle(Byte[], Int32) |
Retourne un nombre à virgule flottante simple précision converti de quatre octets à une position spécifiée dans un tableau d’octets. |
| ToSingle(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en une valeur à virgule flottante simple précision. |
| ToString(Byte[]) |
Convertit la valeur numérique de chaque élément d’un tableau d’octets spécifié en sa représentation sous forme de chaîne hexadécimale équivalente. |
| ToString(Byte[], Int32) |
Convertit la valeur numérique de chaque élément d’un sous-tableau d’octets spécifié en sa représentation de chaîne hexadécimale équivalente. |
| ToString(Byte[], Int32, Int32) |
Convertit la valeur numérique de chaque élément d’un sous-tableau d’octets spécifié en sa représentation de chaîne hexadécimale équivalente. |
| ToUInt128(Byte[], Int32) |
Retourne un entier non signé 128 bits converti de quatre octets à une position spécifiée dans un tableau d’octets. |
| ToUInt128(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier non signé 128 bits. |
| ToUInt16(Byte[], Int32) |
Retourne un entier non signé 16 bits converti à partir de deux octets à une position spécifiée dans un tableau d’octets. |
| ToUInt16(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier non signé 16 bits. |
| ToUInt32(Byte[], Int32) |
Retourne un entier non signé 32 bits converti de quatre octets à une position spécifiée dans un tableau d’octets. |
| ToUInt32(ReadOnlySpan<Byte>) |
Convertit une étendue d’octets en lecture seule en entier non signé 32 bits. |
| ToUInt64(Byte[], Int32) |
Retourne un entier non signé 64 bits converti à partir de huit octets à une position spécifiée dans un tableau d’octets. |
| ToUInt64(ReadOnlySpan<Byte>) |
Convertit les octets en un long non signé. |
| TryWriteBytes(Span<Byte>, Boolean) |
Convertit un booléen en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, Char) |
Convertit un caractère en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, Double) |
Convertit une valeur à virgule flottante double précision en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, Half) |
Convertit une valeur à virgule flottante demi-précision en une plage d’octets. |
| TryWriteBytes(Span<Byte>, Int128) |
Convertit un entier signé 128 bits en étendue d’octets. |
| TryWriteBytes(Span<Byte>, Int16) |
Convertit un entier signé 16 bits en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, Int32) |
Convertit un entier signé 32 bits en étendue d’octets. |
| TryWriteBytes(Span<Byte>, Int64) |
Convertit un entier signé 64 bits en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, Single) |
Convertit une valeur à virgule flottante simple précision en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, UInt128) |
Convertit un entier non signé 128 bits en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, UInt16) |
Convertit un entier 16 bits non signé en étendue d’octets. |
| TryWriteBytes(Span<Byte>, UInt32) |
Convertit un entier non signé 32 bits en une étendue d’octets. |
| TryWriteBytes(Span<Byte>, UInt64) |
Convertit un entier 64 bits non signé en une étendue d’octets. |
| UInt16BitsToHalf(UInt16) |
Convertit l’entier non signé 16 bits spécifié en nombre à virgule flottante demi-précision. |
| UInt32BitsToSingle(UInt32) |
Convertit l’entier non signé 32 bits spécifié en nombre à virgule flottante simple précision. |
| UInt64BitsToDouble(UInt64) |
Convertit l’entier non signé 64 bits spécifié en nombre à virgule flottante double précision. |
