Criando uma matriz de bytes a partir de um fluxo

Qual é o método preferido para criar uma matriz de bytes a partir de um fluxo de entrada?

Aqui está minha solução atual com o .NET 3.5.

Stream s;
byte[] b;

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

Ainda é uma idéia melhor ler e gravar trechos do fluxo?

Realmente depende se você pode ou não confiar s.Length. Para muitos fluxos, você simplesmente não sabe quantos dados haverá. Nesses casos - e antes do .NET 4 - eu usaria código como este:

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

Com o .NET 4 e superior, eu usaria Stream.CopyTo, que é basicamente equivalente ao loop no meu código - crie a MemoryStreamchamada, stream.CopyTo(ms)e depois retorne ms.ToArray(). Tarefa concluída.

Talvez eu devesse explicar por que minha resposta é mais longa que as outras. Stream.Readnão garante que ele leia tudo o que for solicitado. Se você estiver lendo de um fluxo de rede, por exemplo, ele poderá ler o valor de um pacote e retornar, mesmo que em breve haja mais dados. BinaryReader.Readcontinuará até o final do fluxo ou o tamanho especificado, mas você ainda precisa saber o tamanho para começar.

O método acima continuará lendo (e copiando em a MemoryStream) até ficar sem dados. Em seguida, solicita MemoryStreamque você retorne uma cópia dos dados em uma matriz. Se você sabe o tamanho para começar - ou acha que sabe o tamanho, sem ter certeza -, você pode MemoryStreamcriar o tamanho que seja para começar. Da mesma forma, você pode marcar no final e, se o comprimento do fluxo for do mesmo tamanho do buffer (retornado por MemoryStream.GetBuffer), basta retornar o buffer. Portanto, o código acima não é totalmente otimizado, mas pelo menos estará correto. Ele não assume nenhuma responsabilidade por fechar o fluxo - o chamador deve fazer isso.

Consulte este artigo para obter mais informações (e uma implementação alternativa).

Enquanto a resposta de Jon está correta, ele está reescrevendo o código que já existe CopyTo. Portanto, para o .Net 4, use a solução de Sandip, mas para a versão anterior do .Net, use a resposta de Jon. O código de Sandip seria aprimorado pelo uso de "using", pois as exceções CopyTosão, em muitas situações, bastante prováveis ​​e deixariam os MemoryStreamnão descartados.

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

Só quero salientar que, caso você tenha um MemoryStream, já o possui memorystream.ToArray().

Além disso, se você estiver lidando com fluxos de subtipos desconhecidos ou diferentes e puder receber um MemoryStream, poderá retransmitir o referido método para esses casos e ainda usar a resposta aceita para os outros, assim:

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

apenas alguns centavos ... a prática que costumo usar é organizar os métodos como este como um auxiliar personalizado

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

adicione espaço para nome ao arquivo de configuração e use-o em qualquer lugar que desejar

Você pode simplesmente usar o método ToArray () da classe MemoryStream, por exemplo,

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

Você pode até torná-lo mais sofisticado com extensões:

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

E, em seguida, chame-o como um método regular:

byte[] arr = someStream.ToByteArray()

Eu recebo um erro de tempo de compilação com o código de Bob (ou seja, o questionador). Stream.Length é longo, enquanto BinaryReader.ReadBytes usa um parâmetro inteiro. No meu caso, não espero lidar com Streams grandes o suficiente para exigir precisão longa, portanto, uso o seguinte:

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

Caso alguém goste, aqui está uma solução somente .NET 4+ formada como um método de extensão sem a chamada desnecessária Dispose no MemoryStream. Essa é uma otimização irremediavelmente trivial, mas vale a pena notar que falhar em Dispose a MemoryStream não é uma falha real.

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

O que está acima está ok ... mas você encontrará corrupção de dados quando enviar coisas pelo SMTP (se necessário). Alterei para outra coisa que ajudará a enviar corretamente byte por 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;
        }'

Crie uma classe auxiliar e faça referência a ela em qualquer lugar que você deseja usá-la.

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

No espaço de nomes RestSharp.Extensions, existe o método ReadAsBytes. Dentro desse método, é usado o MemoryStream e existe o mesmo código, como em alguns exemplos desta página, mas quando você está usando o RestSharp, é a maneira mais fácil.

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

Você pode usar este método de extensão.

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

Esta é a função que estou usando, testada e funcionou bem. lembre-se de que 'input' não deve ser nulo e 'input.position' deve ser redefinido para '0' antes da leitura, caso contrário, ele interromperá o loop de leitura e nada será lido para converter em 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();
            }
        }            
    }

Consegui fazê-lo funcionar em uma única linha:

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

conforme esclarecido por johnnyRose , o código acima funcionará apenas para o MemoryStream