Tworzenie tablicy bajtów ze strumienia

Jaka jest preferowana metoda tworzenia tablicy bajtów ze strumienia wejściowego?

Oto moje obecne rozwiązanie z .NET 3.5.

Stream s;
byte[] b;

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

Czy nadal lepiej jest czytać i pisać fragmenty strumienia?

To naprawdę zależy od tego, czy możesz zaufać s.Length. W przypadku wielu strumieni po prostu nie wiesz, ile będzie danych. W takich przypadkach - i wcześniej .NET 4 - użyłbym takiego kodu:

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

W .NET 4 i nowszych użyłbym Stream.CopyTo, co w zasadzie jest równoważne pętli w moim kodzie - utwórz MemoryStream, wywołaj, stream.CopyTo(ms)a następnie zwróć ms.ToArray(). Zadanie wykonane.

Być może powinienem wyjaśnić, dlaczego moja odpowiedź jest dłuższa niż inne. Stream.Readnie gwarantuje, że przeczyta wszystko, o co prosi. Jeśli na przykład czytasz ze strumienia sieciowego, może on odczytać wartość jednego pakietu, a następnie powrócić, nawet jeśli wkrótce będzie więcej danych. BinaryReader.Readbędzie działać do końca strumienia lub określonego rozmiaru, ale nadal musisz znać rozmiar, aby zacząć.

Powyższa metoda będzie odczytywać (i kopiować do a MemoryStream), dopóki nie zabraknie danych. Następnie prosi MemoryStreamo zwrócenie kopii danych w tablicy. Jeśli znasz rozmiar na początek - lub uważasz, że znasz rozmiar, bez pewności - możesz skonstruować MemoryStreamtaki rozmiar, aby zacząć. Podobnie możesz umieścić czek na końcu, a jeśli długość strumienia jest tego samego rozmiaru co bufor (zwracany przez MemoryStream.GetBuffer), możesz po prostu zwrócić bufor. Tak więc powyższy kod nie jest do końca zoptymalizowany, ale przynajmniej będzie poprawny. Nie ponosi żadnej odpowiedzialności za zamknięcie strumienia - dzwoniący powinien to zrobić.

Zobacz ten artykuł, aby uzyskać więcej informacji (i alternatywną implementację).

Chociaż odpowiedź Jona jest poprawna, przepisuje on kod, który już istnieje CopyTo. Tak więc dla .Net 4 użyj rozwiązania Sandip, ale dla poprzedniej wersji .Net użyj odpowiedzi Jona. Kod Sandip zostałby ulepszony poprzez użycie „using”, ponieważ w wyjątkowych sytuacjach wyjątki CopyTosą w wielu przypadkach dość prawdopodobne i pozostawiłby MemoryStreamniezbywalne.

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

Chcę tylko zaznaczyć, że w przypadku, gdy masz MemoryStream, już to masz memorystream.ToArray().

Ponadto, jeśli masz do czynienia ze strumieniami nieznanych lub różnych podtypów i możesz otrzymać a MemoryStream, możesz polegać na tej metodzie w tych przypadkach i nadal używać przyjętej odpowiedzi dla innych, takich jak:

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

tylko moja para centów ... praktyką, której często używam jest organizowanie takich metod jako niestandardowego pomocnika

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

dodaj przestrzeń nazw do pliku konfiguracyjnego i używaj go w dowolnym miejscu

Możesz po prostu użyć metody ToArray () klasy MemoryStream, np.

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

Możesz nawet uczynić go bardziej eleganckim dzięki rozszerzeniom:

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

A następnie nazwij to jako zwykłą metodę:

byte[] arr = someStream.ToByteArray()

Dostaję błąd czasu kompilacji z kodem Boba (tj. Pytającego). Stream.Length jest długi, natomiast BinaryReader.ReadBytes przyjmuje parametr w postaci liczby całkowitej. W moim przypadku nie oczekuję, że będę mieć do czynienia ze strumieniami wystarczająco dużymi, aby wymagać długiej precyzji, dlatego używam następujących elementów:

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

Jeśli komuś się spodoba, oto rozwiązanie oparte wyłącznie na .NET 4+ utworzone jako metoda rozszerzenia bez niepotrzebnego wywołania Dispose w MemoryStream. Jest to beznadziejnie trywialna optymalizacja, ale warto zauważyć, że nieusunięcie MemoryStream nie jest prawdziwą porażką.

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

Powyższe jest w porządku ... ale podczas wysyłania danych przez SMTP (jeśli to konieczne) napotkasz uszkodzenie danych. Zmieniłem na coś innego, co pomoże poprawnie przesłać bajt po bajcie: '

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

Utwórz klasę pomocnika i odwołaj się do niej w dowolnym miejscu, w którym chcesz jej użyć.

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

W przestrzeni nazw RestSharp.Extensions znajduje się metoda ReadAsBytes. Wewnątrz tej metody zastosowano MemoryStream i jest taki sam kod jak w niektórych przykładach na tej stronie, ale gdy używasz RestSharp, jest to najłatwiejszy sposób.

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

Możesz użyć tej metody rozszerzenia.

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

Jest to funkcja, której używam, przetestowałem i działałem dobrze. pamiętaj, że „wejście” nie powinno mieć wartości zerowej, a „wejście.pozycjonowanie” powinno zostać zresetowane do „0” przed odczytem, ​​w przeciwnym razie przerwie to pętlę odczytu i nic nie będzie czytać w celu konwersji na tablicę.

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

udało mi się sprawić, że będzie działać na jednej linii:

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

jak wyjaśnił johnnyRose , powyższy kod będzie działał tylko dla MemoryStream