c# - ejemplo - Creación de una matriz de bytes a partir de una secuencia

httppostedfile to byte array c#

Question

¿Cuál es el método preferido para crear una matriz de bytes a partir de un flujo 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?

Answer 1

Cree una clase de ayuda y haga referencia a ella en cualquier lugar que desee utilizar.

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

Answer 2

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

Answer 3

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

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

Answer 4

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 llamarlo como un método regular:

byte[] arr = someStream.ToByteArray()

Answer 5

Pude hacerlo funcionar en una sola línea:

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

como aclaró johnnyRose , el código anterior solo funcionará para MemoryStream

Answer 6

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

Answer 7

Realmente depende de si o no puede confiar en la s.Length . Para muchas transmisiones, simplemente no se sabe 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 de mi código: cree MemoryStream , llame a stream.CopyTo(ms) y luego devuelva ms.ToArray() . Trabajo hecho.

Quizás debería explicar por qué mi respuesta es más larga que las otras. Stream.Read no garantiza que lea todo lo que se le pide. Si está leyendo de un flujo de red, por ejemplo, puede leer el valor de un paquete y luego volver, incluso si pronto habrá más datos. BinaryReader.Read continuará hasta el final de la secuencia o su tamaño especificado, pero aún debe saber el tamaño para comenzar.

El método anterior seguirá leyendo (y copiando en un MemoryStream) hasta que se quede sin datos. Luego le pide al MemoryStream que devuelva una copia de los datos en una matriz. Si sabe el tamaño para comenzar, o si cree que sabe el tamaño, sin estar seguro, puede construir MemoryStream para que tenga ese tamaño. Del mismo modo, puede poner un cheque 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. Así que el código anterior no está del todo optimizado, pero al menos será correcto. No asume ninguna responsabilidad por cerrar la transmisión, la persona que llama debe hacer eso.

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

Answer 8

Recibo un error de tiempo de compilación con el código de Bob (es decir, del que pregunta). Stream.Length es un 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, así que uso 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);
}

Answer 9

Si bien la respuesta de Jon es correcta, está reescribiendo el código que ya existe en 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 con el uso de "usar", ya que las excepciones en CopyTo son, en muchas situaciones, muy probables y dejarán el MemoryStream sin eliminar.

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

Answer 10

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

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

Answer 11

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

Además, si está tratando con flujos de subtipos desconocidos o diferentes y puede recibir un MemoryStream , puede retransmitir dicho método para esos casos y seguir utilizando la respuesta aceptada para los demás, como esto:

public static byte[] StreamToByteArray(Stream stream)
{
    if (stream is MemoryStream)
    {
        return ((MemoryStream)stream).ToArray();                
    }
    else
    {
        // Jon Skeet''s accepted answer 
        return ReadFully(stream);
    }
}

Answer 12

solo mis centavos de pareja ... la práctica que utilizo a menudo es organizar los métodos como este como un ayudante personalizado

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 utilícelo en cualquier lugar que desee

Answer 13

MemoryStream ms = new MemoryStream();
file.PostedFile.InputStream.CopyTo(ms);
var byts = ms.ToArray();
ms.Dispose();

Answer 14

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