Створення масиву байтів із потоку

Що є кращим методом створення байтового масиву з вхідного потоку?

Ось моє поточне рішення з .NET 3.5.

Stream s;
byte[] b;

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

Чи все-таки краща ідея читати та писати шматки потоку?

Це дійсно залежить від того, можна довіряти чи ні s.Length. У багатьох потоках ви просто не знаєте, скільки буде даних. У таких випадках - і раніше .NET 4 - я використовував би такий код:

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

За допомогою .NET 4 і вище я б використав Stream.CopyTo, що в основному еквівалентно циклу в моєму коді - створити MemoryStream, викликати stream.CopyTo(ms)та повернутись ms.ToArray(). Робота виконана.

Можливо, я повинен пояснити, чому моя відповідь довша за інші. Stream.Readне гарантує, що він прочитає все, про що потрібно. Наприклад, якщо ви читаєте з мережевого потоку, він може прочитати вартість одного пакета, а потім повернутися, навіть якщо незабаром буде більше даних. BinaryReader.Readбуде продовжуватись до кінця потоку чи вказаного Вами розміру, але Ви все ще повинні знати розмір, з якого слід почати.

Вищеописаний метод буде постійно читати (і копіювати в a MemoryStream), поки у нього не закінчиться даних. Потім він просить MemoryStreamповернути копію даних у масив. Якщо ви знаєте розмір, з якого слід почати - або вважаєте, що знаєте розмір, не маючи впевненості - ви можете сконструювати MemoryStreamцей розмір для початку. Так само ви можете поставити чек у кінці, і якщо довжина потоку того ж розміру, що і буфер (повертається MemoryStream.GetBuffer), ви можете просто повернути буфер. Отже, наведений вище код не зовсім оптимізований, але принаймні буде правильним. Він не несе відповідальності за закриття потоку - абонент повинен це зробити.

Дивіться цю статтю для отримання додаткової інформації (та альтернативної реалізації).

Хоча відповідь Джона правильна, він переписує код, який вже існує в CopyTo. Тож для .Net 4 використовуйте рішення Сандіпа, але для попередньої версії .Net використовуйте відповідь Йона. Код Сандіпа буде вдосконалено шляхом використання "використання", оскільки винятки CopyToв багатьох ситуаціях є досить ймовірними і залишать MemoryStreamне видалені.

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

Просто хочу зазначити, що у випадку, якщо у вас є MemoryStream, у вас вже є memorystream.ToArray().

Крім того, якщо ви маєте справу з потоками невідомих або різних підтипів, і ви можете отримати а MemoryStream, ви можете передати цей метод для цих випадків і все-таки використовувати прийнятий відповідь для інших, як це:

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

тільки мої пари копійок ... практика, яку я часто використовую, - це організувати такі методи як користувальницький помічник

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

додайте простір імен у конфігураційний файл і використовуйте його в будь-якому місці

Ви можете просто використовувати метод ToArray () класу MemoryStream, наприклад,

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

Ви навіть можете зробити його більш привабливим із розширеннями:

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

А потім назвіть це як звичайний метод:

byte[] arr = someStream.ToByteArray()

Я отримую помилку часу компіляції з кодом Боба (тобто запитувачем). Stream.Length - довгий, тоді як BinaryReader.ReadBytes приймає цілий параметр. У моєму випадку я не очікую, що мати справу з потоками досить великими, щоб вимагати тривалої точності, тому я використовую наступне:

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

Якщо комусь це подобається, ось єдине рішення .NET 4+, сформоване як метод розширення без зайвого виклику Dispose на MemoryStream. Це безнадійно тривіальна оптимізація, але варто зауважити, що неможливість розпорядження пам'яттю MemoryStream не є справжньою невдачею.

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

Наведене вище нормально ... але ви зіткнетесь із пошкодженням даних, коли надсилатимете інформацію через SMTP (якщо вам потрібно). Я змінив щось інше, що допоможе правильно відправити байт для байта: '

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

Створіть клас помічників і посилайтеся на нього будь-де, де ви хочете його використовувати.

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

У просторі імен RestSharp.Extensions існує метод ReadAsBytes. Всередині цього методу використовується MemoryStream, і там є той самий код, що і в деяких прикладах на цій сторінці, але коли ви використовуєте RestSharp, це найпростіший спосіб.

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

Ви можете використовувати цей метод розширення.

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

Це функція, яку я використовую, перевіряю і добре працюю. будь ласка, майте на увазі, що "input" не повинен бути нульовим, а "input.position" слід скинути на "0" перед читанням, інакше це порушить цикл читання і нічого не буде прочитано для перетворення в масив.

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

мені вдалося змусити його працювати в одному рядку:

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

Як уточнив johnnyRose , вищевказаний код буде працювати лише для MemoryStream