BitConverter Classe

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: BitConverter.cs

Source:: BitConverter.cs

Source:: BitConverter.cs

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 des 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 sealed

public ref class BitConverter sealed

public static class BitConverter

public sealed class BitConverter

type BitConverter = class

Public Class BitConverter

Public NotInheritable Class BitConverter

Héritage: Object
BitConverter

Exemples

L’exemple de code suivant illustre l’utilisation de plusieurs BitConverter méthodes de classe.

// 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 BitConverter classe permet de manipuler les types de valeurs dans 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 BitConverter classe inclut des méthodes statiques pour convertir chacun des types primitifs vers et à partir d’un tableau d’octets, comme l’illustre le tableau suivant.

Type	Conversion d’octets	À partir de la conversion d’octets
Boolean	GetBytes(Boolean)	ToBoolean
Char	GetBytes(Char)	ToChar
Double	GetBytes(Double) - ou - DoubleToInt64Bits(Double)	ToDouble - ou - Int64BitsToDouble
Int16	GetBytes(Int16)	ToInt16
Int32	GetBytes(Int32)	ToInt32
Int64	GetBytes(Int64)	ToInt64
Single	GetBytes(Single)	ToSingle
UInt16	GetBytes(UInt16)	ToUInt16
UInt32	GetBytes(UInt32)	ToUInt32
UInt64	GetBytes(UInt64)	ToUInt64

Si vous utilisez des BitConverter méthodes pour les données d’aller-retour, assurez-vous que la GetBytes surcharge et la To méthode Type spécifient le même type. Comme l’illustre l’exemple suivant, la restauration d’un tableau qui représente un entier signé en appelant la ToUInt32 méthode peut entraîner une valeur différente de l’original. Pour plus d’informations, consultez Utilisation de valeurs non décimales signées et au niveau du bit.

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 DoubleToInt64Bits méthode) dépend si l’architecture de l’ordinateur est little endian ou big-endian. De même, l’ordre des octets dans le tableau et retournés par les To méthodes IntegerValue et la ToChar méthode dépend si l’architecture de l’ordinateur est little endian ou big-endian. L’endianité d’une architecture est indiquée par la IsLittleEndian propriété, qui retourne true sur les systèmes little endian et false sur les systèmes big-endian. Sur les systèmes little endian, les octets d’ordre inférieur précèdent les octets d’ordre supérieur. Sur le système big-endian, les octets d’ordre supérieur précèdent les octets d’ordre inférieur. Le tableau suivant illustre la différence entre les tableaux d’octets résultant du passage de l’entier 1 234 567 890 (0x499602D2) à la GetBytes(Int32) méthode. Les octets sont répertoriés dans l’ordre entre l’octet à l’index 0 et l’octet à l’index 3.


Petit-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, soyez prudent lors de la transmission de données d’octets au-delà des limites de la machine :

Si tous les systèmes qui envoient et reçoivent des données ont la même endianité, rien ne doit être fait pour les données.

Si les systèmes d’envoi et de réception de données peuvent avoir des endianités différentes, transmettez toujours des données dans un ordre particulier. Cela signifie que l’ordre des octets du tableau peut devoir être inversé avant de les envoyer ou après les avoir reçus. Une convention courante consiste à transmettre des données dans l’ordre d’octet réseau (ordre big-endien). L’exemple suivant fournit une implémentation pour l’envoi d’une valeur entière dans l’ordre d’octet 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: 12345678

open 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: 12345678

Module 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: 12345678

Si les systèmes d’envoi et de réception de données peuvent avoir des endianités différentes et que les données à transmettre se composent d’entiers signés, appelez la IPAddress.HostToNetworkOrder méthode pour convertir les données en ordre d’octet réseau et la méthode pour les IPAddress.NetworkToHostOrder convertir dans l’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 64 bits signé.
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 sous la forme d’un tableau d’octets.
GetBytes(Char)	Retourne la valeur du caractère Unicode spécifié 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)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
GetBytes(Int16)	Retourne la valeur de l'entier 16 bits signé spécifié sous la forme d'un tableau d'octets.
GetBytes(Int32)	Retourne la valeur de l’entier 32 bits signé spécifié sous la forme d’un tableau d’octets.
GetBytes(Int64)	Retourne la valeur de l’entier signé 64 bits spécifié en tant que 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)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
GetBytes(UInt16)	Retourne la valeur de l'entier 16 bits non signé spécifié sous la forme d'un tableau d'octets.
GetBytes(UInt32)	Retourne la valeur de l’entier 32 bits non signé spécifié sous la forme d’un tableau d’octets.
GetBytes(UInt64)	Retourne la valeur de l’entier 64 bits non signé spécifié sous la forme d’un tableau d’octets.
HalfToInt16Bits(Half)	Convertit une valeur à virgule flottante de demi-précision en entier de 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 en tant que valeur à virgule flottante demi-précision.
Int32BitsToSingle(Int32)	Réinterprète l’entier 32 bits spécifié en valeur à virgule flottante simple précision.
Int64BitsToDouble(Int64)	Réinterprète l’entier 64 bits signé 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 d’un tableau d’octets.
ToBoolean(ReadOnlySpan<Byte>)	Convertit une étendue d’octets en lecture seule en valeur booléenne.
ToChar(Byte[], Int32)	Retourne un caractère Unicode converti à partir de deux octets à une position spécifiée dans un tableau d'octets.
ToChar(ReadOnlySpan<Byte>)	Convertit une étendue d’octets en lecture seule en caractère.
ToDouble(Byte[], Int32)	Retourne un nombre à virgule flottante double précision converti à partir 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 valeur à virgule flottante double précision.
ToHalf(Byte[], Int32)	Retourne un nombre à virgule flottante demi-précision converti à partir 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 de demi-précision.
ToInt128(Byte[], Int32)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
ToInt128(ReadOnlySpan<Byte>)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
ToInt16(Byte[], Int32)	Retourne un entier 16 bits signé 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 32 bits signé converti à partir 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 64 bits signé 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 à partir 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 contenu dans 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 contenu dans un sous-tableau d'octets spécifié en sa représentation sous forme de chaîne hexadécimale équivalente.
ToString(Byte[], Int32, Int32)	Convertit la valeur numérique de chaque élément contenu dans un sous-tableau d'octets spécifié en sa représentation sous forme de chaîne hexadécimale équivalente.
ToUInt128(Byte[], Int32)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
ToUInt128(ReadOnlySpan<Byte>)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
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>)	Convertit une étendue d’octets en lecture seule en entier non signé 16 bits.
ToUInt32(Byte[], Int32)	Retourne un entier 32 bits non signé converti à partir 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 64 bits non signé converti à partir de huit octets à une position spécifiée dans un tableau d'octets.
ToUInt64(ReadOnlySpan<Byte>)	Convertit les octets en long non signé.
TryWriteBytes(Span<Byte>, Boolean)	Convertit une valeur booléenne en étendue d’octets.
TryWriteBytes(Span<Byte>, Char)	Convertit un caractère en é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 de demi-précision en une plage d’octets.
TryWriteBytes(Span<Byte>, Int128)	Convertit des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
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 une é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 des types de données de base en un tableau d'octets, et un tableau d'octets en types de données de base.
TryWriteBytes(Span<Byte>, UInt16)	Convertit un entier non signé 16 bits en une é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 non signé 64 bits en une étendue d’octets.
UInt16BitsToHalf(UInt16)	Convertit l’entier non signé 16 bits spécifié en nombre à virgule flottante de 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.

S’applique à

Voir aussi

Byte