Création d'un tableau d'octets à partir d'un flux

Quelle est la méthode préférée pour créer un tableau d'octets à partir d'un flux d'entrée?

Voici ma solution actuelle avec .NET 3.5.

Stream s;
byte[] b;

using (BinaryReader br = new BinaryReader(s))
{
    b = br.ReadBytes((int)s.Length);
}

Est-ce toujours une meilleure idée de lire et d'écrire des morceaux du flux?

Cela dépend vraiment de votre confiance s.Length. Pour de nombreux flux, vous ne savez tout simplement pas combien de données il y aura. Dans de tels cas - et avant .NET 4 - j'utiliserais du code comme ceci:

public static byte[] ReadFully(Stream input)
{
    byte[] buffer = new byte[16*1024];
    using (MemoryStream ms = new MemoryStream())
    {
        int read;
        while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
        {
            ms.Write(buffer, 0, read);
        }
        return ms.ToArray();
    }
}

Avec .NET 4 et supérieur, j'utiliserais Stream.CopyTo, ce qui est fondamentalement équivalent à la boucle dans mon code - créez le MemoryStream, appelez stream.CopyTo(ms)puis revenez ms.ToArray(). Travail accompli.

Je devrais peut-être expliquer pourquoi ma réponse est plus longue que les autres. Stream.Readne garantit pas qu'il lira tout ce qu'il a demandé. Si vous lisez un flux réseau, par exemple, il peut lire la valeur d'un paquet puis revenir, même s'il y aura bientôt plus de données. BinaryReader.Readcontinuera jusqu'à la fin du flux ou à votre taille spécifiée, mais vous devez toujours connaître la taille pour commencer.

La méthode ci-dessus continuera à lire (et à copier dans a MemoryStream) jusqu'à ce qu'il n'y ait plus de données. Il demande ensuite à MemoryStreamde renvoyer une copie des données dans un tableau. Si vous connaissez la taille pour commencer - ou pensez que vous connaissez la taille, sans être sûr - vous pouvez construire la MemoryStreamtaille pour commencer. De même, vous pouvez mettre un chèque à la fin, et si la longueur du flux est de la même taille que le tampon (renvoyé par MemoryStream.GetBuffer), vous pouvez simplement retourner le tampon. Le code ci-dessus n'est donc pas tout à fait optimisé, mais sera au moins correct. Il n'assume aucune responsabilité pour la fermeture du flux - l'appelant devrait le faire.

Consultez cet article pour plus d'informations (et une implémentation alternative).

Bien que la réponse de Jon soit correcte, il réécrit du code qui existe déjà dans CopyTo. Donc, pour .Net 4, utilisez la solution de Sandip, mais pour la version précédente de .Net, utilisez la réponse de Jon. Le code de Sandip serait amélioré en utilisant «using», car dans CopyTode nombreuses situations, les exceptions sont très probables et ne le laisseraient MemoryStreampas de côté.

public static byte[] ReadFully(Stream input)
{
    using (MemoryStream ms = new MemoryStream())
    {
        input.CopyTo(ms);
        return ms.ToArray();
    }
}

Je veux juste souligner que si vous avez un MemoryStream, vous en avez déjà memorystream.ToArray().

De plus, si vous avez affaire à des flux de sous-types inconnus ou différents et que vous pouvez en recevoir un MemoryStream, vous pouvez relayer cette méthode pour ces cas et toujours utiliser la réponse acceptée pour les autres, comme ceci:

public static byte[] StreamToByteArray(Stream stream)
{
    if (stream is MemoryStream)
    {
        return ((MemoryStream)stream).ToArray();                
    }
    else
    {
        // Jon Skeet's accepted answer 
        return ReadFully(stream);
    }
}

MemoryStream ms = new MemoryStream();
file.PostedFile.InputStream.CopyTo(ms);
var byts = ms.ToArray();
ms.Dispose();

juste mes quelques cents ... la pratique que j'utilise souvent est d'organiser les méthodes comme celle-ci en tant qu'assistant personnalisé

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            input.CopyTo(ms);
            return ms.ToArray();
        }
    }
}

ajouter un espace de noms au fichier de configuration et l'utiliser où vous le souhaitez

Vous pouvez simplement utiliser la méthode ToArray () de la classe MemoryStream, par exemple

MemoryStream ms = (MemoryStream)dataInStream;
byte[] imageBytes = ms.ToArray();

Vous pouvez même le rendre plus sophistiqué avec des extensions:

namespace Foo
{
    public static class Extensions
    {
        public static byte[] ToByteArray(this Stream stream)
        {
            using (stream)
            {
                using (MemoryStream memStream = new MemoryStream())
                {
                     stream.CopyTo(memStream);
                     return memStream.ToArray();
                }
            }
        }
    }
}

Et puis appelez-le comme une méthode régulière:

byte[] arr = someStream.ToByteArray()

J'obtiens une erreur de compilation avec le code de Bob (c'est-à-dire le questionneur). Stream.Length est long tandis que BinaryReader.ReadBytes prend un paramètre entier. Dans mon cas, je ne m'attends pas à traiter des flux suffisamment grands pour nécessiter une longue précision, j'utilise donc les éléments suivants:

Stream s;
byte[] b;

if (s.Length > int.MaxValue) {
  throw new Exception("This stream is larger than the conversion algorithm can currently handle.");
}

using (var br = new BinaryReader(s)) {
  b = br.ReadBytes((int)s.Length);
}

Si quelqu'un l'aime, voici une seule solution .NET 4+ formée comme une méthode d'extension sans l'appel inutile Dispose sur le MemoryStream. Il s'agit d'une optimisation désespérément triviale, mais il convient de noter que l'échec de l'élimination d'un MemoryStream n'est pas un véritable échec.

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        var ms = new MemoryStream();
        input.CopyTo(ms);
        return ms.ToArray();
    }
}

Celui ci-dessus est correct ... mais vous rencontrerez une corruption de données lorsque vous envoyez des trucs via SMTP (si vous en avez besoin). J'ai changé pour quelque chose d'autre qui aidera à envoyer correctement octet par octet: '

using System;
using System.IO;

        private static byte[] ReadFully(string input)
        {
            FileStream sourceFile = new FileStream(input, FileMode.Open); //Open streamer
            BinaryReader binReader = new BinaryReader(sourceFile);
            byte[] output = new byte[sourceFile.Length]; //create byte array of size file
            for (long i = 0; i < sourceFile.Length; i++)
                output[i] = binReader.ReadByte(); //read until done
            sourceFile.Close(); //dispose streamer
            binReader.Close(); //dispose reader
            return output;
        }'

Créez une classe d'assistance et référencez-la partout où vous souhaitez l'utiliser.

public static class StreamHelpers
{
    public static byte[] ReadFully(this Stream input)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            input.CopyTo(ms);
            return ms.ToArray();
        }
    }
}

Dans l'espace de noms RestSharp.Extensions, il y a la méthode ReadAsBytes. À l'intérieur de cette méthode est utilisé MemoryStream et il y a le même code que dans certains exemples sur cette page, mais lorsque vous utilisez RestSharp, c'est la manière la plus simple.

using RestSharp.Extensions;
var byteArray = inputStream.ReadAsBytes();

Vous pouvez utiliser cette méthode d'extension.

public static class StreamExtensions
{
    public static byte[] ToByteArray(this Stream stream)
    {
        var bytes = new List<byte>();

        int b;
        while ((b = stream.ReadByte()) != -1)
            bytes.Add((byte)b);

        return bytes.ToArray();
    }
}

C'est la fonction que j'utilise, testée et qui a bien fonctionné. veuillez garder à l'esprit que 'input' ne doit pas être nul et 'input.position' doit être réinitialisé à '0' avant de lire sinon cela rompra la boucle de lecture et rien ne lira pour être converti en tableau.

    public static byte[] StreamToByteArray(Stream input)
    {
        if (input == null)
            return null;
        byte[] buffer = new byte[16 * 1024];
        input.Position = 0;
        using (MemoryStream ms = new MemoryStream())
        {
            int read;
            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
            {
                ms.Write(buffer, 0, read);
            }
            byte[] temp = ms.ToArray();

            return temp;
        }
    }

public static byte[] ToByteArray(Stream stream)
    {
        if (stream is MemoryStream)
        {
            return ((MemoryStream)stream).ToArray();
        }
        else
        {
            byte[] buffer = new byte[16 * 1024];
            using (MemoryStream ms = new MemoryStream())
            {
                int read;
                while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    ms.Write(buffer, 0, read);
                }
                return ms.ToArray();
            }
        }            
    }

j'ai pu le faire fonctionner sur une seule ligne:

byte [] byteArr= ((MemoryStream)localStream).ToArray();

comme clarifié par johnnyRose , le code ci-dessus ne fonctionnera que pour MemoryStream