Как преобразовать поток в байт[] в C#? [дубликат]

самое короткое решение, которое я знаю:

using(var memoryStream = new MemoryStream())
{
  sourceStream.CopyTo(memoryStream);
  return memoryStream.ToArray();
}

в .NET Framework 4 и более поздних версиях,Stream класс имеет встроенный CopyTo метод, который можно использовать.

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

public static void CopyStream(Stream input, Stream output)
{
    byte[] b = new byte[32768];
    int r;
    while ((r = input.Read(b, 0, b.Length)) > 0)
        output.Write(b, 0, r);
}

затем используйте один из вышеуказанных методов для копирования в MemoryStream и звонок GetBuffer на:

var file = new FileStream("c:\foo.txt", FileMode.Open);

var mem = new MemoryStream();

// If using .NET 4 or later:
file.CopyTo(mem);

// Otherwise:
CopyStream(file, mem);

// getting the internal buffer (no additional copying)
byte[] buffer = mem.GetBuffer();
long length = mem.Length; // the actual length of the data 
                          // (the array may be longer)

// if you need the array to be exactly as long as the data
byte[] truncated = mem.ToArray(); // makes another copy

Edit: первоначально я предложил использовать ответ Джейсона для Stream обслуживающего Length собственность. Но у него был недостаток, потому что он предположил, что Stream вернет все его содержимое в одном Read, что не обязательно верно (не для Socket, например.) Я не знаю, есть ли пример Stream реализация в BCL, которая поддерживает Length но может вернуть данные в более короткие куски, чем вы просите, но как любой может наследовать Stream это легко может быть так.

вероятно, в большинстве случаев проще использовать приведенное выше общее решение, но предположим, что вы действительно хотите чтение непосредственно в массив, который является bigEnough:

byte[] b = new byte[bigEnough];
int r, offset;
while ((r = input.Read(b, offset, b.Length - offset)) > 0)
    offset += r;

то есть многократно звонить Read и переместите позицию, в которой вы будете хранить данные.

    byte[] buf;  // byte array
    Stream stream=Page.Request.InputStream;  //initialise new stream
    buf = new byte[stream.Length];  //declare arraysize
    stream.Read(buf, 0, buf.Length); // read from stream to byte array

Я использую этот класс расширение:

public static class StreamExtensions
{
    public static byte[] ReadAllBytes(this Stream instream)
    {
        if (instream is MemoryStream)
            return ((MemoryStream) instream).ToArray();

        using (var memoryStream = new MemoryStream())
        {
            instream.CopyTo(memoryStream);
            return memoryStream.ToArray();
        }
    }
}

просто скопируйте класс в свое решение, и вы можете использовать его в каждом потоке:

byte[] bytes = myStream.ReadAllBytes()

отлично работает для всех моих потоков и сохраняет много кода! Конечно, вы можете изменить этот метод, чтобы использовать некоторые другие подходы здесь для повышения производительности, если это необходимо, но мне нравится держать его простым.

Byte[] Content = new BinaryReader(file.InputStream).ReadBytes(file.ContentLength);

хорошо, может быть, я что-то упускаю здесь, но вот как я это делаю:

public static Byte[] ToByteArray(this Stream stream) {
    Int32 length = stream.Length > Int32.MaxValue ? Int32.MaxValue : Convert.ToInt32(stream.Length);
    Byte[] buffer = new Byte[length];
    stream.Read(buffer, 0, length);
    return buffer;
}

быстрая и грязная техника:

    static byte[] StreamToByteArray(Stream inputStream)
    {
        if (!inputStream.CanRead)
        {
            throw new ArgumentException(); 
        }

        // This is optional
        if (inputStream.CanSeek)
        {
            inputStream.Seek(0, SeekOrigin.Begin);
        }

        byte[] output = new byte[inputStream.Length];
        int bytesRead = inputStream.Read(output, 0, output.Length);
        Debug.Assert(bytesRead == output.Length, "Bytes read from stream matches stream length");
        return output;
    }

Если вы публикуете файл с мобильного устройства или другого

    byte[] fileData = null;
    using (var binaryReader = new BinaryReader(Request.Files[0].InputStream))
    {
        fileData = binaryReader.ReadBytes(Request.Files[0].ContentLength);
    }

Stream s;
int len = (int)s.Length;
byte[] b = new byte[len];
int pos = 0;
while((r = s.Read(b, pos, len - pos)) > 0) {
    pos += r;
}

немного более сложное решение необходимо s.Length превышает Int32.MaxValue. Но если вам нужно прочитать такой большой поток в памяти, вы можете подумать о другом подходе к своей проблеме.

Edit: если ваш поток не поддерживает Length свойство, изменить с помощью Earwicker в решение.

public static class StreamExtensions {
    // Credit to Earwicker
    public static void CopyStream(this Stream input, Stream output) {
        byte[] b = new byte[32768];
        int r;
        while ((r = input.Read(b, 0, b.Length)) > 0) {
            output.Write(b, 0, r);
        }
    }
}

[...]

Stream s;
MemoryStream ms = new MemoryStream();
s.CopyStream(ms);
byte[] b = ms.GetBuffer();

вы также можете попробовать просто читать по частям за раз и расширять возвращаемый массив байтов:

public byte[] StreamToByteArray(string fileName)
{
    byte[] total_stream = new byte[0];
    using (Stream input = File.Open(fileName, FileMode.Open, FileAccess.Read))
    {
        byte[] stream_array = new byte[0];
        // Setup whatever read size you want (small here for testing)
        byte[] buffer = new byte[32];// * 1024];
        int read = 0;

        while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
        {
            stream_array = new byte[total_stream.Length + read];
            total_stream.CopyTo(stream_array, 0);
            Array.Copy(buffer, 0, stream_array, total_stream.Length, read);
            total_stream = stream_array;
        }
    }
    return total_stream;
}

массив"bigEnough" - это немного растяжка. Конечно, буфер должен быть "большой головой", но правильное оформление должно включать операции и разделители. В этой конфигурации каждая транзакция будет иметь заданную длину, поэтому Ваш массив будет ожидать определенное количество байтов и вставлять его в буфер правильного размера. Разделители будут обеспечивать целостность транзакций и будут предоставляться в рамках каждой транзакции. Чтобы сделать ваше приложение еще лучше, вы можете использовать 2 канала (2 розетки.) Можно было бы передавать транзакции управляющих сообщений фиксированной длины, которые включали бы информацию о размере и порядковом номере транзакции данных, передаваемой с использованием канала данных. Приемник будет подтверждать создание буфера, и только тогда данные будут отправлены. Если у вас нет контроля над отправителем потока, вам нужен многомерный массив в качестве буфера. Компонентные массивы будут достаточно малы, чтобы быть управляемыми и достаточно большими, чтобы быть практичными на основе вашей оценки ожидаемых данных. Процесс логика будет искать известные начальные разделители, а затем конечный разделитель в последующих массивах элементов. Как только конечный разделитель будет найден, будет создан новый буфер для хранения соответствующих данных между разделителями, а исходный буфер должен быть реструктурирован, чтобы разрешить удаление данных.

насколько код для преобразования потока в массив байтов один ниже.

Stream s = yourStream;
int streamEnd = Convert.ToInt32(s.Length);
byte[] buffer = new byte[streamEnd];
s.Read(buffer, 0, streamEnd);