Int tableau d'octets

Je ne le pensais .net avait une sorte de conversion simple de la méthode à utiliser pour la conversion d'un int dans un tableau d'octets? J'ai fait une rapide recherche et de toutes les solutions sont des bits de masquage/passer un octet à la fois, comme "le bon vieux jours".
Il n'est pas une ToByteArray() la méthode quelque part?

InformationsquelleAutor Brady Moritz | 2010-11-14
  1. 88
    byte[] bytes = BitConverter.GetBytes(i);

    bien que remarque également que vous pourrait voulez vérifier BitConverter.IsLittleEndian de voir dans quel sens autour de qui va apparaître!

    Notez que si vous faites cela à plusieurs reprises vous voudrez peut-être éviter tous ceux à court terme de la matrice de crédits alloués par l'écriture elle-même, soit par des opérations de déplacement (>> /<<), ou en utilisant unsafe code. Des opérations de déplacement de aussi ont l'avantage qu'ils ne sont pas touchés par votre plate-forme de l'endianness; vous toujours obtenir les octets dans l'ordre où vous les attendez.

    • +1: Pour plus de clarté, je voudrais remplacer par "[...] dans l'ordre que vous attendez d'eux" avec "big-endian".
    • Pourquoi ne BitConverter.GetBytes(250) retour [250,0,0,0], et pas [250]? Byte.MaxValue == 255, droit?
    • parce que vous appelez GetBytes(int) - donc: 4 octets, et votre PROCESSEUR est en little-endian. Il n'y aurait pas de but dans un GetBytes (octet) de la méthode.
    • re GetBytes(256): vous n'obtenez pas de 255,1 car il est explicitement la largeur fixe de la représentation - octets. Le little-endian (CPU) d'une largeur fixe de 32 bits représentation, 256, est ce que vous obtiendrez
    • salut Marc, qui approche prestataire de même des performances légèrement meilleures, bitwise ou unsafe?
    • mais il varie en fonction de exactement ce que vous faites - la meilleure chose à faire serait de mettre en place deux fois et un test de 10 millions de fois, le calendrier de leur

    InformationsquelleAutor Marc Gravell
  2. 30

    La réponse de Marc est bien sûr la bonne réponse. Mais depuis, il a mentionné les opérateurs de décalage et le code unsafe comme une alternative. Je voudrais partager une commune de moins de rechange. À l'aide d'un struct avec Explicit mise en page. Ceci est similaire en principe à un C/C++ union.

    Voici un exemple d'une structure qui peut être utilisé pour obtenir le composant octets du type de données Int32 et la bonne chose est qu'il est de deux, vous pouvez manipuler les valeurs d'octets et de 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);
    }
  }

    Ci-dessus peuvent maintenant être utilisés 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, l'immutabilité de la police peut ne pas être excité à propos de la dernière possibilité 🙂

    • +1: C'est une belle approche. Si vous êtes inquiet au sujet de l'immutabilité de la police, vous pourriez faire les champs privés et de les exposer à obtenir uniquement des propriétés.
    • Merci, c'est une bonne idée de faire le byte privée des membres et de créer, uniquement des propriétés.
    • La déclaration(s) Byte1 = Byte2 = Octet 3 = Byte4 = 0; " sont redondants que la mise en Valeur de cession remplace. C'est précisément le type d'aliasing que les lecteurs compilateur optimiseur écrivains noix. L'union est élégante, elle s'effondre multiples de l'écriture d'un seul à travers le canal de mémoire. À l'aide de la structure permet également d'éviter l'allocation de tableau extrêmement fréquents.
    • le compilateur impose que l'initialisation de tous les membres de cette structure et il ne prend pas en compte le fait que les octets sont placées par l'int c'est pourquoi l'initialisation est nécessaire, redondant, mais nécessaire.
    • vrai, précisément l'optimiseur de police combats avec les alias.
    • N'est-ce pas la solution sensibles à la big/little endian difficulté, trop? Si vous êtes sur un big endian système, le contenu du champ "Valeur" sera renversée, droit?
    • absolument, Bitconverter.IsLittleEndian peut vous aider à déterminer le bon ordre pour lire les octets. MAIS, comme je l'ai dit ce n'est pas la bonne réponse, je viens de le partager car à l'époque, la technique n'était pas bien vu.
    • où avez-vous dire que c'est pas la bonne réponse?
    • la première phrase "la réponse de Marc est bien sûr la bonne réponse." et le reste de ce paragraphe explique pourquoi j'ai partagé cette. Maintenant, cela ne veut pas dire que c'est pas la bonne réponse pour un autre problème, mais pour la question d'origine, je pense que la réponse de Marc est correct. J'espère que ça aide.
    • En utilisant cette réponse, vous pouvez supprimer le redondante déclaration "byte1 = byte2 = octet 3 = byte4 = 0" et aussi d'accélérer le code pour une ou deux nanosecondes stackoverflow.com/questions/9174787/... j'ai également mis en œuvre la présente, qui peut être utile pour ceux qui chose cette méthode est une bonne idée: gist.github.com/forestrf/e421166fc32ef707fe3817360d711a61

    InformationsquelleAutor Chris Taylor
  3. 2

    Cela peut être ancien testament, mais si vous êtes à la sérialisation de beaucoup de types primitifs ou POD structures, Google Protocol Buffers pour .Net pourrait être utile pour vous. Cela répond à l'endianness question @Marc soulevées ci-dessus, parmi d'autres fonctionnalités utiles.

    InformationsquelleAutor Steve Townsend
  4. 1

    Si vous êtes venu ici de Google

    Alternative la réponse à une ancienne question fait référence à John Skeet Bibliothèque du qui a les outils pour vous laisser écrire les types de données primitifs directement dans un byte[] avec un Indice de décalage. Beaucoup mieux que BitConverter si vous avez besoin de la performance.

    Âgées fil de la discussion de cette question ici

    Jean Skeet Bibliothèques sont ici

    Il suffit de télécharger la source et de regarder la MiscUtil.Conversion espace de noms. EndianBitConverter.cs s'occupe de tout pour vous.

    Je devine que Microsoft n'a pas mis en œuvre ce à cause de la .NET framework est de Facto Coffre-fort à code. Mais il semble ridicule, que des milliers de gens sont obligés de faire de décalage de bits ou d'aller à une 3ème partie de la bibliothèque pour obtenir de tels besoins de base satisfaits.

    InformationsquelleAutor JamesHoux
  5. 0

    La plupart des réponses ici sont soit "Dangereux" ou pas de coffre-fort little-endian. BitConverter n'est pas little-endian coffre-fort.
    Ainsi, la construction sur un exemple dans ici (voir le post de PZahra) j'ai fait une little-endian version sécurité simplement en lisant le tableau d'octets dans le sens inverse lorsque BitConverter.IsLittleEndian == true

    void Main(){    
Console.WriteLine(BitConverter.IsLittleEndian); 
byte[] bytes = BitConverter.GetBytes(0xdcbaabcdfffe1608);
//Console.WriteLine(bytes); 
string hexStr = ByteArrayToHex(bytes);
Console.WriteLine(hexStr);
}
public static string 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 String.Concat("0x",new string(c));
}

    Il retourne ceci:

    True
0xDCBAABCDFFFE1608

    ce qui est exactement l'hex qu'il est allé dans le tableau d'octets.

    • Il ne veut pas démarrer à partir d'un int, cependant. De ne pas mentionner, il est beaucoup plus logique de faire l'endianness vérifier sur lire de sorte que vous êtes sûr de ce que vos données dans le tableau.
    InformationsquelleAutor GregJF