Int to byte array

Je pensais que .net avait une sorte de méthode de conversion facile à utiliser pour convertir un int en un tableau d’octets? J’ai fait une recherche rapide et toutes les solutions masquent / décalent un octet à la fois, comme “le bon vieux temps”. N’y a-t-il pas une méthode ToByteArray () quelque part?

byte[] bytes = BitConverter.GetBytes(i); 

Notez cependant que vous pourriez vouloir vérifier BitConverter.IsLittleEndian pour voir de quelle manière cela va apparaître!

Notez que si vous le faites à plusieurs resockets, vous pouvez éviter toutes les allocations de tableau de courte durée en les écrivant vous-même via les opérations de décalage ( >> / << ) ou en utilisant un code unsafe . Les opérations de quarts ont également l'avantage de ne pas être affectées par la nature de votre plate-forme. vous obtenez toujours les octets dans l'ordre que vous attendez.

La réponse de Marc est bien sûr la bonne réponse. Mais puisqu’il a mentionné les opérateurs postés et le code dangereux comme alternative. Je voudrais partager une alternative moins commune. Utiliser une structure avec une mise en page Explicit . Ceci est similaire en principe à une union C / C ++.

Voici un exemple de structure qui peut être utilisé pour accéder aux octets de composant du type de données Int32. Ce qui est intéressant, c’est que vous pouvez manipuler les valeurs des octets et voir l’effet sur l’Int.

  using System.Runtime.InteropServices; [StructLayout(LayoutKind.Explicit)] struct Int32Converter { [FieldOffset(0)] public int Value; [FieldOffset(0)] public byte Byte1; [FieldOffset(1)] public byte Byte2; [FieldOffset(2)] public byte Byte3; [FieldOffset(3)] public byte Byte4; public Int32Converter(int value) { Byte1 = Byte2 = Byte3 = Byte4 = 0; Value = value; } public static implicit operator Int32(Int32Converter value) { return value.Value; } public static implicit operator Int32Converter(int value) { return new Int32Converter(value); } } 

Ce qui précède peut maintenant être utilisé comme suit

  Int32Converter i32 = 256; Console.WriteLine(i32.Byte1); Console.WriteLine(i32.Byte2); Console.WriteLine(i32.Byte3); Console.WriteLine(i32.Byte4); i32.Byte2 = 2; Console.WriteLine(i32.Value); 

Bien sûr, la police de l’immuabilité peut ne pas être enthousiasmée par la dernière possibilité 🙂

Cela peut être OT, mais si vous sérialisez beaucoup de types primitifs ou de structures POD, Google Protocol Buffers pour .Net pourrait vous être utile. Cela résout le problème d’endianisme @Marc soulevé ci-dessus, parmi d’autres fonctionnalités utiles.

Si vous êtes venu ici de Google

La réponse alternative à une question plus ancienne se réfère à la bibliothèque de John Skeet qui dispose d’outils pour vous permettre d’écrire des types de données primitifs directement dans un octet [] avec un offset d’index. Bien mieux que BitConverter si vous avez besoin de performances.

Fil plus ancien traitant de cette question ici

Les bibliothèques de John Skeet sont ici

Il suffit de télécharger le source et de regarder l’espace de noms MiscUtil.Conversion . EndianBitConverter.cs gère tout pour vous.

Je suppose que Microsoft ne l’a pas implémenté car le framework .NET est du code DeFacto Safe. Mais il semble ridicule que des milliers de personnes aient à se déplacer ou à se rendre dans une bibliothèque tierce pour répondre à un besoin aussi fondamental.

La plupart des réponses sont “UnSafe” ou non LittleEndian safe. BitConverter n’est pas un coffre-fort LittleEndian. En prenant l’exemple d’un exemple (voir l’article de PZahra), j’ai créé une version sécurisée de LittleEndian BitConverter.IsLittleEndian == true

 void Main(){ Console.WriteLine(BitConverter.IsLittleEndian); byte[] bytes = BitConverter.GetBytes(0xdcbaabcdfffe1608); //Console.WriteLine(bytes); ssortingng hexStr = ByteArrayToHex(bytes); Console.WriteLine(hexStr); } public static ssortingng ByteArrayToHex(byte[] data) { char[] c = new char[data.Length * 2]; byte b; if(BitConverter.IsLittleEndian) { //read the byte array in reverse for (int y = data.Length -1, x = 0; y >= 0; --y, ++x) { b = ((byte)(data[y] >> 4)); c[x] = (char)(b > 9 ? b + 0x37 : b + 0x30); b = ((byte)(data[y] & 0xF)); c[++x] = (char)(b > 9 ? b + 0x37 : b + 0x30); } } else { for (int y = 0, x = 0; y < data.Length; ++y, ++x) { b = ((byte)(data[y] >> 4)); c[x] = (char)(b > 9 ? b + 0x37 : b + 0x30); b = ((byte)(data[y] & 0xF)); c[++x] = (char)(b > 9 ? b + 0x37 : b + 0x30); } } return Ssortingng.Concat("0x",new ssortingng(c)); } 

Il renvoie ceci:

 True 0xDCBAABCDFFFE1608 

qui est l’hexagone exact qui est entré dans le tableau d’octets.