Creazione di una matrice di byte da un flusso

Qual è il metodo preferito per creare un array di byte da un flusso di input?

Ecco la mia attuale soluzione con .NET 3.5.

Stream s;
byte[] b;

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

È ancora un'idea migliore leggere e scrivere blocchi dello stream?

Dipende davvero dalla fiducia s.Length. Per molti stream, semplicemente non sai quanti dati ci saranno. In questi casi - e prima di .NET 4 - utilizzerei il codice in questo modo:

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

Con .NET 4 e versioni successive, utilizzerei Stream.CopyTo, che è sostanzialmente equivalente al ciclo nel mio codice: crea MemoryStream, chiama stream.CopyTo(ms)e poi ritorna ms.ToArray(). Lavoro fatto.

Dovrei forse spiegare perché la mia risposta è più lunga delle altre. Stream.Readnon garantisce che leggerà tutto ciò che viene richiesto. Se stai leggendo da un flusso di rete, ad esempio, potrebbe leggere il valore di un pacchetto e quindi restituirlo, anche se presto ci saranno più dati. BinaryReader.Readcontinuerà fino alla fine dello stream o alla dimensione specificata, ma devi comunque conoscere la dimensione con cui iniziare.

Il metodo sopra continuerà a leggere (e copiare in a MemoryStream) fino a quando non si esauriscono i dati. Quindi chiede MemoryStreamdi restituire una copia dei dati in un array. Se conosci le dimensioni con cui iniziare - o pensi di conoscerne le dimensioni, senza essere sicuro - puoi costruirle MemoryStreamper iniziare con quelle dimensioni. Allo stesso modo puoi mettere un segno di spunta alla fine e se la lunghezza del flusso ha le stesse dimensioni del buffer (restituito da MemoryStream.GetBuffer), puoi semplicemente restituire il buffer. Quindi il codice sopra non è del tutto ottimizzato, ma almeno sarà corretto. Non si assume alcuna responsabilità per la chiusura del flusso - il chiamante dovrebbe farlo.

Vedi questo articolo per maggiori informazioni (e un'implementazione alternativa).

Mentre la risposta di Jon è corretta, sta riscrivendo il codice già esistente in CopyTo. Quindi per .Net 4 usa la soluzione di Sandip, ma per la versione precedente di .Net usa la risposta di Jon. Il codice di Sandip sarebbe migliorato usando l '"utilizzo" poiché le eccezioni CopyTosono, in molte situazioni, abbastanza probabili e lascerebbero il MemoryStreamnon disposto.

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

Voglio solo sottolineare che nel caso in cui possiedi un MemoryStream lo hai già fatto memorystream.ToArray().

Inoltre, se hai a che fare con flussi di sottotipi sconosciuti o diversi e puoi ricevere un MemoryStream, puoi inoltrare questo metodo per quei casi e usare ancora la risposta accettata per gli altri, in questo modo:

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

solo i miei due centesimi ... la pratica che uso spesso è quella di organizzare i metodi come questo come un aiuto personalizzato

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

aggiungi lo spazio dei nomi al file di configurazione e usalo dove vuoi

Puoi semplicemente usare il metodo ToArray () della classe MemoryStream, per esempio

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

Puoi persino renderlo più elaborato con le estensioni:

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

E poi chiamalo come metodo normale:

byte[] arr = someStream.ToByteArray()

Ottengo un errore di tempo di compilazione con il codice di Bob (ovvero il questionatore). Stream.Length è un lungo mentre BinaryReader.ReadBytes accetta un parametro intero. Nel mio caso, non mi aspetto di avere a che fare con stream abbastanza grandi da richiedere una lunga precisione, quindi utilizzo quanto segue:

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

Nel caso in cui piaccia a qualcuno, ecco una soluzione .NET 4+ formata come metodo di estensione senza la inutile chiamata Dispose su MemoryStream. Questa è un'ottimizzazione irrimediabilmente banale, ma vale la pena notare che non riuscire a smaltire un MemoryStream non è un vero fallimento.

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

Quello sopra è ok ... ma riscontrerai un danneggiamento dei dati quando invii materiale tramite SMTP (se necessario). Ho modificato qualcos'altro che aiuterà a inviare correttamente byte per byte: '

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

Crea una classe di supporto e fai riferimento ovunque tu voglia usarla.

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

Nello spazio dei nomi RestSharp.Extensions è presente il metodo ReadAsBytes. All'interno di questo metodo viene utilizzato MemoryStream e c'è lo stesso codice come in alcuni esempi in questa pagina ma quando si utilizza RestSharp questo è il modo più semplice.

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

È possibile utilizzare questo metodo di estensione.

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

Questa è la funzione che sto usando, testato e ha funzionato bene. tenere presente che "input" non deve essere nullo e "input.position" deve reimpostare su "0" prima di leggere, altrimenti si interromperà il ciclo di lettura e nulla verrà letto per convertire in array.

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

sono stato in grado di farlo funzionare su una sola riga:

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

come chiarito da johnnyRose , il codice di cui sopra funzionerà solo per MemoryStream