Erstellen eines Byte-Arrays aus einem Stream

Was ist die bevorzugte Methode zum Erstellen eines Byte-Arrays aus einem Eingabestream?

Hier ist meine aktuelle Lösung mit .NET 3.5.

Stream s;
byte[] b;

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

Ist es immer noch eine bessere Idee, Teile des Streams zu lesen und zu schreiben?

Es hängt wirklich davon ab, ob Sie vertrauen können oder nicht s.Length. Bei vielen Streams wissen Sie einfach nicht, wie viele Daten vorhanden sein werden. In solchen Fällen - und vor .NET 4 - würde ich folgenden Code verwenden:

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

Mit .NET 4 und höher würde ich verwenden Stream.CopyTo, was im Grunde der Schleife in meinem Code entspricht - erstellen Sie den MemoryStream, rufen Sie auf stream.CopyTo(ms)und kehren Sie dann zurück ms.ToArray(). Job erledigt.

Ich sollte vielleicht erklären, warum meine Antwort länger ist als die der anderen. Stream.Readgarantiert nicht, dass es alles liest, wonach es gefragt wird. Wenn Sie beispielsweise aus einem Netzwerk-Stream lesen, liest dieser möglicherweise den Wert eines Pakets und kehrt dann zurück, selbst wenn bald weitere Daten vorliegen. BinaryReader.Readwird bis zum Ende des Streams oder Ihrer angegebenen Größe fortgesetzt, aber Sie müssen zunächst noch die Größe kennen.

Bei der obigen Methode wird so lange gelesen (und in a kopiert MemoryStream), bis keine Daten mehr vorhanden sind. Anschließend wird der Benutzer MemoryStreamaufgefordert, eine Kopie der Daten in einem Array zurückzugeben. Wenn Sie zunächst die Größe kennen - oder glauben , die Größe zu kennen, ohne sich sicher zu sein -, können Sie die Größe zunächst so konstruieren MemoryStream, dass sie diese Größe hat. Ebenso können Sie am Ende ein Häkchen setzen. Wenn die Länge des Streams der Größe des Puffers entspricht (zurückgegeben von MemoryStream.GetBuffer), können Sie den Puffer einfach zurückgeben. Der obige Code ist also nicht ganz optimiert, wird aber zumindest korrekt sein. Es übernimmt keine Verantwortung für das Schließen des Streams - der Anrufer sollte dies tun.

Weitere Informationen (und eine alternative Implementierung) finden Sie in diesem Artikel .

Während Jons Antwort richtig ist, schreibt er Code neu, der bereits in vorhanden ist CopyTo. Verwenden Sie für .Net 4 die Sandip-Lösung, für die vorherige Version von .Net jedoch Jons Antwort. Sandips Code würde durch die Verwendung von "using" verbessert, da Ausnahmen CopyToin vielen Situationen sehr wahrscheinlich sind und das MemoryStreamnicht entsorgt werden würden.

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

Ich möchte nur darauf hinweisen, dass Sie für den Fall, dass Sie einen MemoryStream haben, bereits einen haben memorystream.ToArray().

Wenn Sie es mit Streams unbekannter oder unterschiedlicher Subtypen zu tun haben und eine erhalten können MemoryStream, können Sie diese Methode für diese Fälle weiterleiten und die akzeptierte Antwort für die anderen weiterhin wie folgt verwenden:

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

nur meine paar Cent ... die Praxis, die ich oft benutze, besteht darin, die Methoden wie diese als benutzerdefinierten Helfer zu organisieren

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

Fügen Sie der Konfigurationsdatei einen Namespace hinzu und verwenden Sie ihn an einer beliebigen Stelle

Sie können einfach die ToArray () -Methode der MemoryStream-Klasse verwenden, z.

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

Mit Erweiterungen können Sie es sogar noch schicker machen:

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

Und nennen Sie es dann als reguläre Methode:

byte[] arr = someStream.ToByteArray()

Ich erhalte einen Fehler bei der Kompilierung mit dem Code von Bob (dh dem des Fragestellers). Stream.Length ist lang, während BinaryReader.ReadBytes einen ganzzahligen Parameter verwendet. In meinem Fall erwarte ich nicht, dass es sich um Streams handelt, die groß genug sind, um eine lange Genauigkeit zu erfordern. Daher verwende ich Folgendes:

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

Falls es jemandem gefällt, finden Sie hier eine .NET 4+ -Lösung, die als Erweiterungsmethode ohne den unnötigen Dispose-Aufruf im MemoryStream erstellt wurde. Dies ist eine hoffnungslos triviale Optimierung, aber es ist erwähnenswert, dass das Versäumnis, einen MemoryStream zu entsorgen, kein wirklicher Fehler ist.

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

Das obige ist in Ordnung ... aber Sie werden auf Datenbeschädigung stoßen, wenn Sie Inhalte über SMTP senden (falls erforderlich). Ich habe etwas anderes geändert, das hilft, Byte für Byte korrekt zu senden: '

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

Erstellen Sie eine Hilfsklasse und verweisen Sie darauf, wo immer Sie sie verwenden möchten.

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

Im Namespace RestSharp.Extensions gibt es die Methode ReadAsBytes. In dieser Methode wird MemoryStream verwendet, und es gibt denselben Code wie in einigen Beispielen auf dieser Seite. Wenn Sie jedoch RestSharp verwenden, ist dies der einfachste Weg.

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

Sie können diese Erweiterungsmethode verwenden.

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

Dies ist die Funktion, die ich benutze, getestet und gut funktioniert habe. Bitte beachten Sie, dass 'input' nicht null sein sollte und 'input.position' vor dem Lesen auf '0' zurückgesetzt werden sollte, da sonst die Leseschleife unterbrochen wird und nichts gelesen wird, um in ein Array konvertiert zu werden.

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

Ich konnte es in einer einzigen Zeile zum Laufen bringen:

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

Wie von johnnyRose klargestellt, funktioniert der obige Code nur für MemoryStream