BitConverter, classe

La classe BitConverter facilite la manipulation des types valeur sous leur forme de base, comme une série d'octets. Un octet correspond à un entier non signé 8 bits. La classe BitConverter inclut des méthodes statiques pour convertir chacun des types primitifs vers et depuis un tableau d'octets, comme illustré par la table suivante.

Si vous utilisez des méthodes BitConverter pour effectuer un aller-retour des données, vérifiez que la surcharge GetBytes et la méthode ToType spécifient le même type. Comme le montre l'exemple suivant, restaurer un tableau qui représente un entier signé en appelant la méthode ToUInt32 peut avoir pour résultat une valeur différente de l'originale. Pour plus d'informations, consultez l'entrée Utilisation de valeurs signées non décimales et de valeurs au niveau du bit (page éventuellement en anglais) sur le blog de l'équipe BCL.

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

L'ordre des octets dans le tableau retourné par les surcharges de la méthode GetBytes (ainsi que l'ordre des octets dans l'entier retourné par la méthode DoubleToInt64Bits et l'ordre des chaînes hexadécimales retourné par la méthode ToString(Byte[])) dépend de si l'architecture de l'ordinateur est avec primauté des octets de poids faible (Little endian) ou avec primauté des octets de poids fort (Big endian). De la même façon, l'ordre des octets dans le tableau retourné par les méthodes ToValeurEntier et ToChar varie selon que l'architecture de l'ordinateur est avec primauté des octets de poids faible (Little endian) ou avec primauté des octets de poids fort (Big endian). L'ordre de primauté des octets utilisé dans une architecture est indiqué par la propriété IsLittleEndian, qui retourne true dans les systèmes avec primauté des octets de poids faible (little-endian) et false dans les systèmes avec primauté des octets de poids fort (big-endian). Dans les systèmes avec primauté des octets de poids faible (little-endian), les octets d'ordre inférieur précèdent les octets d'ordre supérieur. Dans les systèmes avec primauté des octets de poids fort (big-endian), les octets d'ordre supérieur précèdent les octets d'ordre inférieur. Le tableau suivant illustre les différences entre 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 de l'octet situé à l'index 0 vers l'octet situé à l'index 3.

La valeur de retour de certaines méthodes dépendant de l'architecture du système, soyez attentif lors de la transmission de données d'octets au-delà des limites de l'ordinateur :

• Si tous les systèmes d'envoi et de réception des données ont la garantie d'avoir le même ordre de primauté des octets, les données ne doivent pas être modifiées.

• Si tous les systèmes d'envoi et de réception des données peuvent avoir un ordre différent de primauté des octets, transmettez toujours les données dans un ordre particulier. Ceci signifie que l'ordre des octets dans le tableau peut devoir être inversé avant leur envoi ou après leur réception. Il convient généralement de transmettre les données dans l'ordre d'octet du 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 du réseau.

  C#

  VB

  Copier

  
  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)
           bytes = ReverseBytes(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)
           bytes = ReverseBytes(bytes);
  
        Console.WriteLine(BitConverter.ToString(bytes));
        int result = BitConverter.ToInt32(bytes, 0);
        Console.WriteLine("Original value: {0}", value);
        Console.WriteLine("Returned value: {0}", result);
     }
  
     private static byte[] ReverseBytes(byte[] inArray)
     {
        byte temp;
        int highCtr = inArray.Length - 1;
  
        for (int ctr = 0; ctr < inArray.Length / 2; ctr++)
        {
           temp = inArray[ctr];
           inArray[ctr] = inArray[highCtr];
           inArray[highCtr] = temp;
           highCtr -= 1;
        }
        return inArray;
     }
  }
  // The example displays the following output on a little-endian system:
  //       4E-61-BC-00
  //       00-61-BC-4E
  //       00-61-BC-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 un ordre différent de primauté des octets et si les données à transmettre consistent en des entiers signés, appelez la méthode IPAddress.HostToNetworkOrder pour convertir les données en ordre d'octets du réseau et la méthode IPAddress.NetworkToHostOrder pour le convertir en ordre requis par le destinataire.

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

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

.NET Framework

.NET Framework Client Profile

Bibliothèque de classes portable

.NET pour les applications du Windows Store

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Référence