Tạo một mảng byte từ một luồng

Phương thức ưa thích để tạo một mảng byte từ luồng đầu vào là gì?

Đây là giải pháp hiện tại của tôi với .NET 3.5.

Stream s;
byte[] b;

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

Nó vẫn là một ý tưởng tốt hơn để đọc và viết các đoạn của luồng?

Nó thực sự phụ thuộc vào việc bạn có thể tin tưởng hay không s.Length. Đối với nhiều luồng, bạn không biết sẽ có bao nhiêu dữ liệu. Trong những trường hợp như vậy - và trước .NET 4 - Tôi sẽ sử dụng mã như thế này:

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

Với .NET 4 trở lên, tôi sẽ sử dụng Stream.CopyTo, về cơ bản tương đương với vòng lặp trong mã của tôi - tạo MemoryStream, gọi stream.CopyTo(ms)và sau đó trả về ms.ToArray(). Công việc hoàn thành.

Tôi có lẽ nên giải thích tại sao câu trả lời của tôi dài hơn những người khác. Stream.Readkhông đảm bảo rằng nó sẽ đọc mọi thứ nó yêu cầu. Ví dụ: nếu bạn đang đọc từ một luồng mạng, nó có thể đọc giá trị của một gói và sau đó quay lại, ngay cả khi sẽ có nhiều dữ liệu sớm hơn. BinaryReader.Readsẽ tiếp tục cho đến khi kết thúc luồng hoặc kích thước được chỉ định của bạn, nhưng bạn vẫn phải biết kích thước để bắt đầu.

Phương pháp trên sẽ tiếp tục đọc (và sao chép vào a MemoryStream) cho đến khi hết dữ liệu. Sau đó nó yêu cầu MemoryStreamtrả về một bản sao của dữ liệu trong một mảng. Nếu bạn biết kích thước để bắt đầu - hoặc nghĩ rằng bạn biết kích thước, mà không chắc chắn - bạn có thể xây dựng MemoryStreamkích thước đó để bắt đầu. Tương tự như vậy, bạn có thể đặt một kiểm tra ở cuối và nếu độ dài của luồng có cùng kích thước với bộ đệm (được trả về bởi MemoryStream.GetBuffer) thì bạn có thể trả về bộ đệm. Vì vậy, đoạn mã trên không được tối ưu hóa hoàn toàn, nhưng ít nhất sẽ đúng. Nó không chịu bất kỳ trách nhiệm nào trong việc đóng luồng - người gọi nên làm điều đó.

Xem bài viết này để biết thêm thông tin (và thực hiện thay thế).

Trong khi câu trả lời của Jon là chính xác, anh ta đang viết lại mã đã tồn tại CopyTo. Vì vậy, đối với .Net 4 sử dụng giải pháp của Sandip, nhưng đối với phiên bản trước của .Net, hãy sử dụng câu trả lời của Jon. Mã của Sandip sẽ được cải thiện bằng cách sử dụng "sử dụng" như các trường hợp ngoại lệ CopyTo, trong nhiều tình huống, rất có thể và sẽ MemoryStreamkhông được xử lý.

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

Chỉ muốn chỉ ra rằng trong trường hợp bạn có MemoryStream, bạn đã có sẵn memorystream.ToArray()cho điều đó.

Ngoài ra, nếu bạn đang xử lý các luồng không xác định hoặc các kiểu con khác nhau và bạn có thể nhận được một MemoryStream, bạn có thể chuyển tiếp phương thức đã nói cho các trường hợp đó và vẫn sử dụng câu trả lời được chấp nhận cho các trường hợp khác, như sau:

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

chỉ vài xu của tôi ... thực tế mà tôi thường sử dụng là tổ chức các phương thức như thế này như một người trợ giúp tùy chỉnh

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

thêm không gian tên vào tập tin cấu hình và sử dụng nó ở bất cứ đâu bạn muốn

Bạn chỉ có thể sử dụng phương thức ToArray () của lớp MemoryStream, ví dụ như

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

Bạn thậm chí có thể làm cho nó dễ dàng hơn với các tiện ích mở rộng:

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

Và sau đó gọi nó như một phương pháp thông thường:

byte[] arr = someStream.ToByteArray()

Tôi nhận được một lỗi thời gian biên dịch với mã của Bob (tức là người hỏi). Stream.Lipse dài trong khi BinaryReader.ReadBytes lấy tham số nguyên. Trong trường hợp của tôi, tôi không mong muốn xử lý Luồng đủ lớn để yêu cầu độ chính xác dài, vì vậy tôi sử dụng như sau:

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

Trong trường hợp bất cứ ai thích nó, đây là một giải pháp .NET 4+ duy nhất được hình thành như một phương thức mở rộng mà không cần cuộc gọi Vứt bỏ không cần thiết trên MemoryStream. Đây là một tối ưu hóa vô vọng tầm thường, nhưng đáng chú ý là việc không loại bỏ MemoryStream không phải là một thất bại thực sự.

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

Một ở trên là ok ... nhưng bạn sẽ gặp phải hỏng dữ liệu khi bạn gửi công cụ qua SMTP (nếu bạn cần). Tôi đã thay đổi thành thứ khác sẽ giúp gửi chính xác byte cho 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;
        }'

Tạo một lớp trợ giúp và tham chiếu nó bất cứ nơi nào bạn muốn sử dụng nó.

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

Trong không gian tên RestSharp.Extensions có phương thức ReadAsBytes. Bên trong phương thức này được sử dụng MemoryStream và có cùng mã như trong một số ví dụ trên trang này nhưng khi bạn đang sử dụng RestSharp thì đây là cách dễ nhất.

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

Bạn có thể sử dụng phương pháp mở rộng này.

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

Đây là chức năng mà tôi đang sử dụng, đã thử nghiệm và hoạt động tốt. xin lưu ý rằng 'đầu vào' không nên rỗng và 'input.poseition' nên đặt lại thành '0' trước khi đọc nếu không nó sẽ phá vỡ vòng đọc và không có gì sẽ đọc để chuyển thành mảng.

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

tôi đã có thể làm cho nó hoạt động trên một dòng duy nhất:

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

như được làm rõ bởi johnnyRose , mã trên sẽ chỉ hoạt động cho MemoryStream