c# bit - Come convertire un int a un array di byte little endian?




or operazioni (8)

Ho questa funzione in C # per convertire un piccolo array di byte endian in un numero intero:

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

Ora voglio convertirlo in little endian .. Qualcosa come

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

Qualche idea?

Grazie.


Answers

La classe BitConverter può essere utilizzata per questo e, naturalmente, può anche essere utilizzata su sistemi sia piccoli che grandi.

Ovviamente, dovrai tenere traccia della endianità dei tuoi dati. Per le comunicazioni, ad esempio, questo sarebbe definito nel tuo protocollo.

È quindi possibile utilizzare la classe BitConverter per convertire un tipo di dati in una matrice di byte e viceversa, quindi utilizzare il flag IsLittleEndian per verificare se è necessario convertirlo nel sistema o meno.

Il flag IsLittleEndian ti dirà il endianness del sistema, quindi puoi usarlo come segue:

Questo è dalla pagina MSDN sulla classe BitConverter .

  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.

Puoi trovare l'articolo completo here .

Spero che questo aiuti chiunque venga qui :)


È possibile utilizzare questo se non si desidera utilizzare nuove allocazioni dell'heap:

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);
}

Basta capovolgerlo, nota che questo codice (come l'altro) funziona solo su una piccola macchina Endian. (modifica - era sbagliato, dal momento che questo codice restituisce LE per definizione)

  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;
  }

Basta farlo al contrario:

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

 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;
    }

Potresti usare la classe here ? Credo che funzionerà solo su hardware little endian, ma dovrebbe gestire la maggior parte del lavoro pesante per te.

Il seguente è un esempio forzato che illustra l'uso della classe:

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

BitConverter.GetBytes(1000).Reverse<byte>().ToArray();

Puoi ora utilizzare i metodi di estensione :

public static T ToEnum<T>(this string value, bool ignoreCase = true)
{
    return (T) Enum.Parse(typeof (T), value, ignoreCase);
}

E puoi chiamarli con il codice seguente (qui, FilterType è un tipo enum):

FilterType filterType = type.ToEnum<FilterType>();




c# bit-manipulation