BitConverter Classe

Définition

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.Converts base data types to an array of bytes, and an array of bytes to base data types.

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
BitConverter

Exemples

L’exemple de code suivant illustre l’utilisation de plusieurs BitConverter méthodes de classe.The following code example illustrates the use of several BitConverter class methods.

// 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
*/
' 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 valeur sous leur forme fondamentale, sous la forme d’une série d’octets.The BitConverter class helps manipulate value types in their fundamental form, as a series of bytes. Un octet est défini en tant qu’entier 8 bits non signé.A byte is defined as an 8-bit unsigned integer. La BitConverter classe comprend des méthodes statiques pour convertir chacun des types primitifs vers et à partir d’un tableau d’octets, comme l’illustre le tableau suivant.The BitConverter class includes static methods to convert each of the primitive types to and from an array of bytes, as the following table illustrates.

TypeType Conversion en octetsTo byte conversion À partir de la conversion d’octetsFrom byte conversion
Boolean GetBytes(Boolean) ToBoolean
Char GetBytes(Char) ToChar
Double GetBytes(Double)

- ou --or-

DoubleToInt64Bits(Double)
ToDouble

- ou --or-

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 BitConverter des méthodes pour effectuer un aller-retour de données, assurez-vous que la GetBytes surcharge et la méthode de To type spécifient le même type.If you use BitConverter methods to round-trip data, make sure that the GetBytes overload and the ToType method specify the same 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 celle de l’original.As the following example illustrates, restoring an array that represents a signed integer by calling the ToUInt32 method can result in a value that is different from the original. Pour plus d’informations, consultez l’entrée utilisation de valeurs non décimales et de valeurs de bits signées dans le blog de l’équipe BCL.For more information, see the entry Working with Signed Non-Decimal and Bitwise Values in the BCL Team Blog.

using System;

public class Example
{
   public static void Main()
   {
      int value = -16;
      Byte[] bytes = BitConverter.GetBytes(value);

      // Convert bytes back to Int32.
      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
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 GetBytes surcharges de méthode (ainsi que l’ordre des bits dans l’entier retourné par la DoubleToInt64Bits méthode et l’ordre des chaînes hexadécimales retournées par la ToString(Byte[]) méthode) varie selon que l’architecture de l’ordinateur est Little-endian ou Big-endian.The order of bytes in the array returned by the GetBytes method overloads (as well as the order of bits in the integer returned by the DoubleToInt64Bits method and the order of hexadecimal strings returned by the ToString(Byte[]) method) depends on whether the computer architecture is little-endian or 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 varie selon que l’architecture de l’ordinateur est Little-endian ou Big-endian.Similarly, the order of bytes in the array and returned by the ToIntegerValue methods and the ToChar method depends on whether the computer architecture is little-endian or big-endian. La endianness 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.The endianness of an architecture is indicated by the IsLittleEndian property, which returns true on little-endian systems and false on big-endian systems. Sur les systèmes Little endian, les octets de poids faible précèdent les octets d’ordre supérieur.On little-endian systems, lower-order bytes precede higher-order bytes. Sur le système Big endian, les octets d’ordre supérieur précèdent les octets de poids faible.On big-endian system, higher-order bytes precede lower-order bytes. Le tableau suivant illustre la différence entre les tableaux d’octets qui résultent du passage de l’entier 1 234 567 890 (0x499602D2) à la GetBytes(Int32) méthode.The following table illustrates the difference in the byte arrays that result from passing the integer 1,234,567,890 (0x499602D2) to the GetBytes(Int32) method. Les octets sont répertoriés dans l’ordre de l’octet à l’index 0 jusqu’à l’octet à l’index 3.The bytes are listed in order from the byte at index 0 to the byte at index 3.

Little endianLittle-endian D2-02-96-49D2-02-96-49
Big endianBig-endian 49-96-02-D249-96-02-D2

Étant donné que la valeur de retour de certaines méthodes dépend de l’architecture du système, soyez prudent lors de la transmission de données d’octets au-delà des limites de l’ordinateur :Because the return value of some methods depends on system architecture, be careful when transmitting byte data beyond machine boundaries:

  • Si tous les systèmes qui envoient et reçoivent des données sont assurés d’avoir le même endianness, rien n’est fait pour les données.If all systems sending and receiving data are guaranteed to have the same endianness, nothing has be done to the data.

  • Si les systèmes qui envoient et reçoivent des données peuvent avoir des endianness différents, transmettez toujours des données dans un ordre particulier.If systems sending and receiving data can have different endianness, always transmit data in a particular order. Cela signifie que l’ordre des octets dans le tableau devra peut-être être inversé avant de les envoyer ou après les avoir reçus.This means that the order of bytes in the array may have to be reversed either before sending them or after receiving them. Une convention courante consiste à transmettre des données dans l’ordre des octets du réseau (Big-endian).A common convention is to transmit data in network byte order (big-endian order). L’exemple suivant fournit une implémentation pour l’envoi d’une valeur entière dans l’ordre des octets du réseau.The following example provides an implementation for sending an integer value in network byte order.

    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
    
    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 qui envoient et reçoivent des données peuvent avoir différents endianness et que les données à transmettre consistent en des entiers signés, appelez la IPAddress.HostToNetworkOrder méthode pour convertir les données en ordre d’octet réseau et la IPAddress.NetworkToHostOrder méthode pour les convertir dans l’ordre requis par le destinataire.If systems sending and receiving data can have different endianness and the data to be transmitted consists of signed integers, call the IPAddress.HostToNetworkOrder method to convert the data to network byte order and the IPAddress.NetworkToHostOrder method to convert it to the order required by the recipient.

Champs

IsLittleEndian

Indique l’ordre d’octet (« endianness ») dans lequel les données sont stockées dans cette architecture d’ordinateur.Indicates the byte order ("endianness") in which data is stored in this computer architecture.

Méthodes

DoubleToInt64Bits(Double)

Convertit le nombre à virgule flottante double précision spécifié en entier 64 bits signé.Converts the specified double-precision floating point number to a 64-bit signed integer.

GetBytes(Boolean)

Retourne la valeur booléenne spécifiée sous la forme d’un tableau d’octets.Returns the specified Boolean value as a byte array.

GetBytes(Char)

Retourne la valeur du caractère Unicode spécifié sous la forme d'un tableau d'octets.Returns the specified Unicode character value as an array of bytes.

GetBytes(Double)

Retourne la valeur à virgule flottante double précision spécifiée sous la forme d'un tableau d'octets.Returns the specified double-precision floating point value as an array of bytes.

GetBytes(Int16)

Retourne la valeur de l'entier 16 bits signé spécifié sous la forme d'un tableau d'octets.Returns the specified 16-bit signed integer value as an array of bytes.

GetBytes(Int32)

Retourne la valeur de l’entier 32 bits signé spécifié sous la forme d’un tableau d’octets.Returns the specified 32-bit signed integer value as an array of bytes.

GetBytes(Int64)

Retourne la valeur de l’entier signé 64 bits spécifié en tant que tableau d’octets.Returns the specified 64-bit signed integer value as an array of bytes.

GetBytes(Single)

Retourne la valeur à virgule flottante simple précision spécifiée sous la forme d'un tableau d'octets.Returns the specified single-precision floating point value as an array of bytes.

GetBytes(UInt16)

Retourne la valeur de l'entier 16 bits non signé spécifié sous la forme d'un tableau d'octets.Returns the specified 16-bit unsigned integer value as an array of bytes.

GetBytes(UInt32)

Retourne la valeur de l’entier 32 bits non signé spécifié sous la forme d’un tableau d’octets.Returns the specified 32-bit unsigned integer value as an array of bytes.

GetBytes(UInt64)

Retourne la valeur de l’entier 64 bits non signé spécifié sous la forme d’un tableau d’octets.Returns the specified 64-bit unsigned integer value as an array of bytes.

Int32BitsToSingle(Int32)

Réinterprète l’entier 32 bits spécifié en valeur à virgule flottante simple précision.Reinterprets the specified 32-bit integer as a single-precision floating-point value.

Int64BitsToDouble(Int64)

Réinterprète l’entier 64 bits signé spécifié en nombre à virgule flottante double précision.Reinterprets the specified 64-bit signed integer to a double-precision floating point number.

SingleToInt32Bits(Single)

Convertit une valeur à virgule flottante simple précision en entier.Converts a single-precision floating-point value into an integer.

ToBoolean(Byte[], Int32)

Retourne une valeur booléenne convertie à partir de l’octet, à une position spécifiée d’un tableau d’octets.Returns a Boolean value converted from the byte at a specified position in a byte array.

ToBoolean(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en valeur booléenne.Converts a read-only byte span to a Boolean value.

ToChar(Byte[], Int32)

Retourne un caractère Unicode converti à partir de deux octets à une position spécifiée dans un tableau d'octets.Returns a Unicode character converted from two bytes at a specified position in a byte array.

ToChar(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en caractère.Converts a read-only byte span into a character.

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.Returns a double-precision floating point number converted from eight bytes at a specified position in a byte array.

ToDouble(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en valeur à virgule flottante double précision.Converts a read-only byte span into a double-precision floating-point value.

ToInt16(Byte[], Int32)

Retourne un entier 16 bits signé converti à partir de deux octets à une position spécifiée dans un tableau d'octets.Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.

ToInt16(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en entier signé 16 bits.Converts a read-only byte span into a 16-bit signed integer.

ToInt32(Byte[], Int32)

Retourne un entier 32 bits signé converti à partir de quatre octets à une position spécifiée dans un tableau d'octets.Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.

ToInt32(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en entier signé 32 bits.Converts a read-only byte span into a 32-bit signed integer.

ToInt64(Byte[], Int32)

Retourne un entier 64 bits signé converti à partir de huit octets à une position spécifiée dans un tableau d'octets.Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.

ToInt64(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en entier signé 64 bits.Converts a read-only byte span into a 64-bit signed integer.

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.Returns a single-precision floating point number converted from four bytes at a specified position in a byte array.

ToSingle(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en valeur à virgule flottante double précision.Converts a read-only byte span into a double-precision floating-point value.

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.Converts the numeric value of each element of a specified array of bytes to its equivalent hexadecimal string representation.

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.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

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.Converts the numeric value of each element of a specified subarray of bytes to its equivalent hexadecimal string representation.

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.Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.

ToUInt16(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en entier non signé 16 bits.Converts a read-only byte-span into a 16-bit unsigned integer.

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.Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.

ToUInt32(ReadOnlySpan<Byte>)

Convertit une étendue d’octets en lecture seule en entier non signé 32 bits.Converts a read-only byte span into a 32-bit unsigned integer.

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.Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.

ToUInt64(ReadOnlySpan<Byte>)

Convertit les octets en long non signé.Converts bytes into an unsigned long.

TryWriteBytes(Span<Byte>, Boolean)

Convertit une valeur booléenne en étendue d’octets.Converts a Boolean into a span of bytes.

TryWriteBytes(Span<Byte>, Char)

Convertit un caractère en étendue d’octets.Converts a character into a span of bytes.

TryWriteBytes(Span<Byte>, Double)

Convertit une valeur à virgule flottante double précision en une étendue d’octets.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, Int16)

Convertit un entier signé 16 bits en une étendue d’octets.Converts a 16-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int32)

Convertit un entier signé 32 bits en une étendue d’octets.Converts a 32-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Int64)

Convertit un entier signé 64 bits en une étendue d’octets.Converts a 64-bit signed integer into a span of bytes.

TryWriteBytes(Span<Byte>, Single)

Convertit une valeur à virgule flottante double précision en une étendue d’octets.Converts a double-precision floating-point value into a span of bytes.

TryWriteBytes(Span<Byte>, UInt16)

Convertit un entier non signé 16 bits en une étendue d’octets.Converts an unsigned 16-bit integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt32)

Convertit un entier non signé 32 bits en une étendue d’octets.Converts a 32-bit unsigned integer into a span of bytes.

TryWriteBytes(Span<Byte>, UInt64)

Convertit un entier non signé 64 bits en une étendue d’octets.Converts an unsigned 64-bit integer into a span of bytes.

S’applique à

Voir aussi