Comment initialiser un tableau d'octets en C#

Un byte[] en C# stocke des valeurs d’octets de 0 à 255. Utilisez new byte[length] pour créer un tableau dont les éléments contiennent initialement zéro, ou utilisez un initialiseur de tableau lorsque les valeurs sont déjà connues. Une boucle, Array.Fill et LINQ peuvent attribuer des valeurs répétées ou calculées ; Buffer.BlockCopy sert à copier des octets déjà stockés dans des tableaux.

Créer un tableau d’octets avec une longueur fixe ou des valeurs explicites

Pour créer un byte[] de taille fixe, transmettez sa longueur à new byte[length]. L’environnement d’exécution initialise chaque élément à zéro. Lorsque vous connaissez les valeurs à l’avance, écrivez-les plutôt dans un initialiseur. Une boucle est utile lorsque chaque valeur dépend de son index ou d’un autre calcul.

Les déclarations ci-dessous montrent deux formes courantes côte à côte. La première réserve quatre positions, et la seconde énumère directement trois valeurs d’octets. La boucle parcourt ensuite chaque position dans l’ordre et stocke une valeur basée sur son index. Length fournit le nombre de positions, de sorte que la même forme de boucle s’adapte lorsque vous modifiez la taille demandée. Les dernières lignes affichent les deux tableaux afin que vous puissiez comparer les valeurs produites par chaque forme.

using System;

class Program
{
    static void Main()
    {
        byte[] values = new byte[4];
        byte[] explicitValues = { 0x10, 0x20, 0x30 };

        for (int i = 0; i < values.Length; i++)
        {
            values[i] = (byte)(i + 1);
        }

        Console.WriteLine(string.Join(", ", values));
        Console.WriteLine(string.Join(", ", explicitValues));
    }
}

1, 2, 3, 4
16, 32, 48

Pour le premier tableau, la boucle stocke 1, 2, 3 et 4. L’initialiseur explicite crée un tableau distinct contenant les valeurs d’octets hexadécimales énumérées.

Définir chaque élément à la même valeur

Utilisez Array.Fill lorsque le framework cible du projet le fournit. Il attribue une valeur d’octet à chaque élément du tableau spécifié. Si cette API n’est pas disponible pour le projet, une boucle for sur la Length du tableau fournit la même attribution.

using System;

class Program
{
    static void Main()
    {
        byte[] buffer = new byte[4];
        Array.Fill(buffer, (byte)255);
        Console.WriteLine(string.Join(", ", buffer));
    }
}

255, 255, 255, 255

La conversion rend le type de la valeur explicite. Un octet peut contenir des valeurs de 0 à 255.

Créer un tableau à partir d’une valeur répétée avec LINQ

Enumerable.Repeat produit une séquence contenant une valeur le nombre de fois demandé. Appelez ToArray pour matérialiser cette séquence sous la forme d’un byte[]. L’exemple importe System.Linq, qui fournit les deux méthodes.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        byte value = 42;
        int length = 5;
        byte[] values = Enumerable.Repeat(value, length).ToArray();
        Console.WriteLine(string.Join(", ", values));
    }
}

42, 42, 42, 42, 42

Cette approche est lisible lorsqu’un nouveau tableau doit contenir la même valeur dans son ensemble. Utilisez Array.Fill lorsque vous avez déjà un tableau à mettre à jour.

Copier des octets bruts avec Buffer.BlockCopy

Buffer.BlockCopy copie des octets bruts entre des tableaux dont les types d’éléments sont des types primitifs, comme byte[] ou int[]. Ses décalages source et destination ainsi que son count sont mesurés en octets, et non en éléments de tableau. Assurez-vous que les plages source et destination disposent d’un espace suffisant pour la copie demandée. Il ne génère ni ne remplit une valeur générale ; pour cette tâche, utilisez une boucle ou Array.Fill.

Cet exemple copie quatre octets d’un tableau d’octets source vers un tableau de destination en commençant au décalage d’octet un.

using System;

class Program
{
    static void Main()
    {
        byte[] source = { 10, 20, 30, 40 };
        byte[] destination = new byte[6];

        Buffer.BlockCopy(source, 0, destination, 1, source.Length);
        Console.WriteLine(string.Join(", ", destination));
    }
}

0, 10, 20, 30, 40, 0

Lors de la copie d’octets depuis un tableau numérique plus grand, le nombre d’octets à copier et les décalages utilisent toujours des octets. Par exemple, ceci copie les quatre premiers octets de deux valeurs int dans une destination de quatre octets :

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 0x01020304, 0x05060708 };
        byte[] bytes = new byte[4];

        Buffer.BlockCopy(numbers, 0, bytes, 0, bytes.Length);
        Console.WriteLine(string.Join(", ", bytes));
    }
}

L’exemple du tableau numérique dépend de la plateforme : l’ordre des octets dans chaque int dépend de la représentation de la plateforme. Dans l’environnement fourni, cet exemple a produit 4, 3, 2, 1 ; cet ordre observé est spécifique à la représentation des octets des entiers de la plateforme et n’est pas universel. Copier depuis un byte[] évite cette interprétation car ses éléments sont déjà des octets.

Choisir une méthode d’initialisation

Utilisez new byte[length] lorsque vous avez besoin d’un tableau de taille fixe initialisé avec des zéros, et un initialiseur pour une courte liste de valeurs connues. Utilisez une boucle pour les valeurs calculées par position, Array.Fill pour attribuer une valeur à un tableau existant, ou Enumerable.Repeat(...).ToArray() pour construire un tableau à valeur répétée avec LINQ. Choisissez Buffer.BlockCopy lorsque les données existent déjà sous forme d’octets bruts dans des tableaux et doivent être copiées.