Tworzenie tablicy bajtów ze strumienia

Chociaż odpowiedź Jona jest poprawna, przepisuje kod, który już istnieje w CopyTo. Tak więc dla. Net 4 Użyj rozwiązania Sandip, ale dla poprzedniej wersji. Net użyj odpowiedzi Jona. Kod sandipa zostałby ulepszony przez użycie "using", ponieważ wyjątki w CopyTo są, w wielu sytuacjach, całkiem prawdopodobne i pozostawiłyby MemoryStream nie usunięte.

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, masz już memorystream.ToArray() do tego.

Ponadto, jeśli masz do czynienia ze strumieniami nieznanych lub różnych podtypów i możesz otrzymać MemoryStream, możesz przekazać tę metodę dla tych przypadków i nadal używać zaakceptowanej odpowiedzi dla innych, jak to:

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 moje grosze... praktyka, której często używam, polega na organizowaniu 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 jej w dowolnym miejscu

Możesz po prostu użyć metody ToArray () klasy MemoryStream, dla ex-

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

Możesz nawet uczynić go bardziej fantazyjnym z rozszerzeniami:

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 wywołaj ją jako zwykłą metodę:

byte[] arr = someStream.ToByteArray()

Dostaję błąd czasu kompilacji z kodem Boba (tj. pytającego). Strumień.Length is a long while BinaryReader.ReadBytes pobiera parametr integer. W moim przypadku nie spodziewam się, że będę miał do czynienia z strumieniami na tyle dużymi, aby wymagały długiej precyzji, więc używam następującego:

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 jedyne rozwiązanie. NET 4+ utworzone jako metoda rozszerzenia bez niepotrzebnego wywoływania Dispose na MemoryStream. Jest to beznadziejnie trywialna optymalizacja, ale warto zauważyć, że nie pozbycie się 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();
    }
}

Ta powyżej jest ok...ale napotkasz uszkodzenie danych, gdy wysyłasz rzeczy przez SMTP (jeśli zajdzie taka potrzeba). Zmieniłem na coś innego, co pomoże poprawnie wysłać bajt za bajt: '

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

W przestrzeni nazw RestSharp.Rozszerzenia istnieje metoda ReadAsBytes. Wewnątrz tej metody jest używany MemoryStream i tam jest ten sam kod jak w niektórych przykładach na tej stronie, ale gdy używasz RestSharp jest to najprostszy sposób.

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

Utwórz klasę pomocniczą i odwołaj się do niej gdziekolwiek 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();
        }
    }
}

Jest to funkcja, której używam, testowałem i dobrze pracowałem. proszę pamiętać, że 'input' nie powinno być null i ' input.pozycja 'powinna zresetować się do' 0 ' przed odczytaniem, w przeciwnym razie złamie pętlę odczytu i nic nie zostanie odczytane, aby przekonwertować do tablicy.

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

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

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ę to zrobić na jednej linii:

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

Jak wyjaśniono przez johnnyRose , powyższy kod będzie działał tylko dla MemoryStream