Crear una matriz de bytes a partir de una secuencia

¿Cuál es el método preferido para crear una matriz de bytes a partir de una secuencia de entrada?

Aquí está mi solución actual con .NET 3.5.

Stream s;
byte[] b;

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

¿Sigue siendo una mejor idea leer y escribir fragmentos de la secuencia?

Realmente depende de si puedes confiar o no s.Length. Para muchas transmisiones, simplemente no sabes cuántos datos habrá. En tales casos, y antes de .NET 4, usaría un 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();
    }
}

Con .NET 4 y superior, usaría Stream.CopyTo, que es básicamente equivalente al bucle en mi código: crear MemoryStream, llamar stream.CopyTo(ms)y luego regresar ms.ToArray(). Trabajo hecho.

Quizás debería explicar por qué mi respuesta es más larga que las otras. Stream.Readno garantiza que leerá todo lo que se le solicite. Si está leyendo desde una transmisión de red, por ejemplo, puede leer el valor de un paquete y luego regresar, incluso si habrá más datos pronto. BinaryReader.Readcontinuará hasta el final de la transmisión o el tamaño especificado, pero aún debe saber el tamaño para comenzar.

El método anterior seguirá leyendo (y copiando en a MemoryStream) hasta que se quede sin datos. Luego le pide MemoryStreamque devuelva una copia de los datos en una matriz. Si conoce el tamaño para comenzar, o cree que conoce el tamaño, sin estar seguro, puede construir el MemoryStreamtamaño para comenzar. Del mismo modo, puede marcar al final, y si la longitud de la secuencia es del mismo tamaño que el búfer (devuelto por MemoryStream.GetBuffer), puede devolver el búfer. Entonces, el código anterior no está optimizado, pero al menos será correcto. No asume ninguna responsabilidad por cerrar la transmisión; la persona que llama debe hacerlo.

Consulte este artículo para obtener más información (y una implementación alternativa).

Si bien la respuesta de Jon es correcta, está reescribiendo el código que ya existe CopyTo. Entonces, para .Net 4 use la solución de Sandip, pero para la versión anterior de .Net use la respuesta de Jon. El código de Sandip se mejoraría mediante el uso de "usar", ya que las excepciones CopyToson, en muchas situaciones, bastante probables y dejarían lo MemoryStreamno dispuesto.

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

Solo quiero señalar que en caso de que tenga un MemoryStream que ya tiene memorystream.ToArray()para eso.

Además, si se trata de secuencias de subtipos desconocidos o diferentes y puede recibir un MemoryStream, puede transmitir dicho método para esos casos y aún usar la respuesta aceptada para los demás, como esta:

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

solo mi par de centavos ... la práctica que uso a menudo es organizar métodos como este como ayuda personalizada

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

agregue espacio de nombres al archivo de configuración y úselo donde desee

Simplemente puede usar el método ToArray () de la clase MemoryStream, por ejemplo

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

Incluso puedes hacerlo más elegante con extensiones:

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

Y luego llámalo como un método regular:

byte[] arr = someStream.ToByteArray()

Recibo un error de tiempo de compilación con el código de Bob (es decir, el interrogador). Stream.Length es largo mientras que BinaryReader.ReadBytes toma un parámetro entero. En mi caso, no espero tratar con Streams lo suficientemente grandes como para requerir una precisión larga, por lo que utilizo lo siguiente:

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

En caso de que a alguien le guste, aquí hay una solución única .NET 4+ formada como un método de extensión sin la innecesaria llamada Dispose en MemoryStream. Esta es una optimización irremediablemente trivial, pero vale la pena señalar que no eliminar un MemoryStream no es una falla real.

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

El anterior está bien ... pero encontrará daños en los datos cuando envíe cosas a través de SMTP (si es necesario). He cambiado a otra cosa que ayudará a enviar correctamente 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;
        }'

Cree una clase auxiliar y haga referencia a ella en cualquier lugar donde desee usarla.

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

En el espacio de nombres RestSharp.Extensions hay un método ReadAsBytes. Dentro de este método se usa MemoryStream y hay el mismo código que en algunos ejemplos de esta página, pero cuando usa RestSharp, esta es la forma más fácil.

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

Puedes usar este método de extensión.

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 es la función que estoy usando, probé y funcionó bien. tenga en cuenta que 'input' no debe ser nulo y 'input.position' debe restablecerse a '0' antes de leer, de lo contrario se romperá el ciclo de lectura y nada se leerá para convertirlo en matriz.

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

pude hacerlo funcionar en una sola línea:

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

según lo aclarado por johnnyRose , el código anterior solo funcionará para MemoryStream