Membuat array byte dari aliran

Apa metode yang lebih disukai untuk membuat array byte dari aliran input?

Berikut adalah solusi saya saat ini dengan .NET 3.5.

Stream s;
byte[] b;

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

Apakah masih lebih baik untuk membaca dan menulis potongan-potongan aliran?

Itu benar-benar tergantung pada apakah Anda bisa percaya atau tidak s.Length. Untuk banyak aliran, Anda tidak tahu berapa banyak data yang akan ada. Dalam kasus seperti itu - dan sebelum .NET 4 - Saya akan menggunakan kode seperti ini:

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

Dengan .NET 4 dan di atasnya, saya akan menggunakan Stream.CopyTo, yang pada dasarnya setara dengan loop dalam kode saya - buat MemoryStream, panggil stream.CopyTo(ms)dan kembalilah ms.ToArray(). Pekerjaan selesai.

Saya mungkin harus menjelaskan mengapa jawaban saya lebih panjang dari yang lain. Stream.Readtidak menjamin bahwa itu akan membaca semua yang diminta. Jika Anda membaca dari aliran jaringan, misalnya, ia mungkin membaca nilai satu paket dan kemudian kembali, bahkan jika akan ada lebih banyak data segera. BinaryReader.Readakan terus berjalan hingga akhir streaming atau ukuran yang Anda tentukan, tetapi Anda masih harus tahu ukuran untuk memulai.

Metode di atas akan terus membaca (dan menyalin ke a MemoryStream) sampai kehabisan data. Kemudian meminta MemoryStreamuntuk mengembalikan salinan data dalam array. Jika Anda tahu ukuran untuk memulai - atau berpikir Anda tahu ukurannya, tanpa yakin - Anda bisa membuat MemoryStreammenjadi ukuran itu. Demikian juga Anda dapat memberi tanda centang di akhir, dan jika panjang aliran adalah ukuran yang sama dengan buffer (dikembalikan oleh MemoryStream.GetBuffer) maka Anda bisa mengembalikan buffer. Jadi kode di atas tidak cukup dioptimalkan, tetapi setidaknya akan benar. Itu tidak memikul tanggung jawab untuk menutup aliran - penelepon harus melakukan itu.

Lihat artikel ini untuk info lebih lanjut (dan implementasi alternatif).

Sementara jawaban Jon benar, dia menulis ulang kode yang sudah ada di CopyTo. Jadi untuk .Net 4 gunakan solusi Sandip, tetapi untuk versi .Net sebelumnya gunakan jawaban Jon. Kode Sandip akan ditingkatkan dengan menggunakan "menggunakan" sebagai pengecualian dalam CopyTo, dalam banyak situasi, sangat mungkin dan akan meninggalkan yang MemoryStreamtidak dibuang.

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

Hanya ingin menunjukkan bahwa seandainya Anda memiliki MemoryStream yang sudah Anda miliki memorystream.ToArray() untuk itu.

Juga, jika Anda berurusan dengan aliran subtipe yang tidak diketahui atau berbeda dan Anda dapat menerima MemoryStream, Anda dapat menyampaikan pada metode tersebut untuk kasus tersebut dan masih menggunakan jawaban yang diterima untuk yang lain, seperti ini:

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

hanya pasangan saya sen ... praktik yang sering saya gunakan adalah mengatur metode seperti ini sebagai pembantu kustom

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

tambahkan namespace ke file konfigurasi dan gunakan di mana saja Anda inginkan

Anda cukup menggunakan metode ToArray () dari kelas MemoryStream, untuk contoh

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

Anda bahkan dapat membuatnya lebih mewah dengan ekstensi:

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

Dan kemudian menyebutnya sebagai metode biasa:

byte[] arr = someStream.ToByteArray()

Saya mendapatkan kesalahan waktu kompilasi dengan kode Bob (yaitu si penanya). Stream.Length adalah panjang sedangkan BinaryReader.ReadBytes mengambil parameter integer. Dalam kasus saya, saya tidak berharap berurusan dengan Streaming yang cukup besar sehingga membutuhkan ketelitian yang lama, jadi saya menggunakan yang berikut ini:

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

Jika ada yang suka, ini adalah solusi .NET 4+ saja yang dibentuk sebagai metode ekstensi tanpa perlu Buang panggilan di MemoryStream. Ini adalah optimasi sepele yang sia-sia, tetapi perlu dicatat bahwa gagal untuk Membuang MemoryStream bukanlah kegagalan nyata.

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

Yang di atas tidak apa-apa ... tetapi Anda akan menemukan korupsi data ketika Anda mengirim barang melalui SMTP (jika perlu). Saya telah mengubah ke hal lain yang akan membantu mengirimkan byte ke byte dengan benar: '

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

Buat kelas pembantu dan rujuk di mana saja Anda ingin menggunakannya.

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

Di namespace RestSharp.Extensions ada metode ReadAsBytes. Di dalam metode ini digunakan MemoryStream dan ada kode yang sama seperti pada beberapa contoh di halaman ini tetapi ketika Anda menggunakan RestSharp ini adalah cara termudah.

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

Anda dapat menggunakan metode ekstensi ini.

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

Ini adalah fungsi yang saya gunakan, diuji dan bekerja dengan baik. harap diingat bahwa 'input' tidak boleh nol dan 'input.position' harus direset ke '0' sebelum membaca jika tidak maka akan merusak loop baca dan tidak ada yang akan membaca untuk mengkonversi ke 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();
            }
        }            
    }

saya dapat membuatnya bekerja pada satu baris:

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

seperti yang diklarifikasi oleh johnnyRose , kode di atas hanya akan berfungsi untuk MemoryStream