Comment faire pour convertir un int en little endian tableau d'octets?

J'ai cette fonction en C# pour convertir un little endian tableau d'octets à un nombre entier:

int LE2INT(byte[] data)
{
  return (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];
}

Maintenant, je veux me reconvertir en little endian..
Quelque chose comme

byte[] INT2LE(int data)
{
  //...
}

Une idée?

Grâce.

InformationsquelleAutor drowneath | 2010-02-28

bit-manipulation c#

20

Juste à l'inverse, de l' ~~Notez que ce code (comme les autres) ne fonctionne que sur une little Endian machine.~~ (edit - que c'était faux, puisque ce code renvoie LE par définition)
```
  byte[] INT2LE(int data)
  {
     byte[] b = new byte[4];
     b[0] = (byte)data;
     b[1] = (byte)(((uint)data >> 8) & 0xFF);
     b[2] = (byte)(((uint)data >> 16) & 0xFF);
     b[3] = (byte)(((uint)data >> 24) & 0xFF);
     return b;
  }
```
- Pourquoi votre exemple ne fonctionnent que sur un little-endian machine? Autant que je sache, le décalage de bits de la méthode doit être endian-agnostique.
- Je suis sûr que vous êtes le code fonctionne très bien si le code s'exécute sur un big ou little-endian architecture. Dans les deux cas, b[0] est la plus faible octet de poids, b[1] est la nouvelle la plus faible octet de poids, et ainsi de suite.
- Mon erreur, étant donné que ce code renvoie CHIER plutôt que le naturel de l'ordre des octets du sous-jacent de l'uc, elle fonctionne sur toutes les architectures. Je vais supprimer le texte incorrect.
- Selon l'ECMA-335 standard de la conversion de l'uint d'octets (instruction conv.i1) signifie tout simplement d'une réinitialisation de la plupart des importants octets. Par conséquent, le "& 0xFF" la partie est trop.
InformationsquelleAutor John Knoeller
21

La BitConverter classe peut être utilisée pour le présent, et bien sûr, il peut également être utilisé à la fois peu et big endian systèmes.

Bien sûr, vous aurez à garder une trace de la endianness de vos données. Pour les communications, par exemple, ce serait définie dans le protocole.

Vous pouvez ensuite utiliser la BitConverter classe de convertir un type de données dans un tableau d'octets, et vice-versa, et ensuite utiliser le IsLittleEndian drapeau pour voir si vous avez besoin de convertir il sur votre système ou non.

La IsLittleEndian drapeau vais vous raconter l' endianness du système, de sorte que vous pouvez l'utiliser comme suit:

C'est à partir de la page MSDN sur le BitConverter classe.
```
  int value = 12345678; //your value
  //Your value in bytes... in your system's endianness (let's say: little endian)
  byte[] bytes = BitConverter.GetBytes(value);
  //Then, if we need big endian for our protocol for instance,
  //Just check if you need to convert it or not:
  if (BitConverter.IsLittleEndian)
     Array.Reverse(bytes); //reverse it so we get big endian.
```
Vous pouvez trouver l'article complet ici.

Espère que cela aide quelqu'un de venir ici 🙂

InformationsquelleAutor Wracky

Juste de le faire dans le sens inverse:

result[3]= (data >> 24) & 0xff;
result[2]= (data >> 16) & 0xff;
result[1]= (data >> 8)  & 0xff;
result[0]=  data        & 0xff;

InformationsquelleAutor MSN

Pourriez-vous utiliser le BitConverter classe? Il ne fonctionne que sur little endian matériel je crois, mais il devrait répondre à la plupart de le levage lourd pour vous.

Ce qui suit est un exemple artificiel qui illustre l'utilisation de la classe:

        if(BitConverter.IsLittleEndian)
        {
            int someInteger = 100;
            byte[] bytes = BitConverter.GetBytes(someInteger);
            int convertedFromBytes = BitConverter.ToInt32(bytes, 0);
        }

InformationsquelleAutor Eric

2
```
BitConverter.GetBytes(1000).Reverse<byte>().ToArray();
```
- Pourriez-vous expliquer pourquoi ce serait aider?
- Je suis assez sûr que c'est le cas de la machine Big Endian.
InformationsquelleAutor Serban Lucian
0

En fonction de ce que vous êtes en train de faire, vous pouvez compter sur de laisser le cadre de manipuler les détails de l'endianness pour vous en utilisant IPAddress.HostToNetworkOrder et de la fonction reverse. Alors utilisez simplement la BitConverter classe pour aller vers et à partir des tableaux d'octets.

InformationsquelleAutor MikeP

 public static string decimalToHexLittleEndian(int _iValue, int _iBytes)
    {
        string sBigEndian = String.Format("{0:x" + (2 * _iBytes).ToString() + "}", _iValue);
        string sLittleEndian = "";

        for (int i = _iBytes - 1; i >= 0; i--)
        {
            sLittleEndian += sBigEndian.Substring(i * 2, 2);
        }

        return sLittleEndian;
    }

InformationsquelleAutor Sean Campbell

Vous pouvez l'utiliser si vous ne voulez pas utiliser les nouvelles allocations de tas:

public static void Int32ToFourBytes(Int32 number, out byte b0, out byte b1, out byte b2, out byte b3)
{
    b3 = (byte)number;
    b2 = (byte)(((uint)number >> 8) & 0xFF);
    b1 = (byte)(((uint)number >> 16) & 0xFF);
    b0 = (byte)(((uint)number >> 24) & 0xFF);
}

InformationsquelleAutor Mendi Barel

Vous devez vous connecter pour publier un commentaire.