Come copiare un flusso in un array di byte con il codice C# più piccolo?

Question

Fino ad ora sto contando 12 LoC. Potresti renderlo più piccolo?

using (Stream fileStream = File.OpenRead(fileName)) 
{ 
    using (BinaryReader binaryReader = new BinaryReader(fileStream)) 
    { 
     using (MemoryStream memoryStream = new MemoryStream()) 
     { 
      byte[] buffer = new byte[256]; 
      int count; 
      int totalBytes = 0; 
      while ((count = binaryReader.Read(buffer, 0, 256)) > 0) 
      { 
       memoryStream.Write(buffer, 0, count); 
       totalBytes += count; 
      } 
      memoryStream.Position = 0; 
      byte[] transparentPng = new byte[totalBytes]; 
      memoryStream.Read(transparentPng, 0, totalBytes); 
     } 
    } 
} 

Answer 1

C'è un metodo statico che può fare questo per voi in una sola chiamata.

var data = File.ReadAllBytes(fileName); 

alternativa, un metodo che funziona per qualsiasi Stream (che restituisce la sua lunghezza) sarebbe:

byte[] data; 
using (var br = new BinaryReader(stream)) 
    data = br.ReadBytes((int)stream.Length); 

Per gli stream che non hanno una lunghezza ben definita (es NetworkStream), e quindi sollevare un'eccezione chiamando il stream.Length, questo naturalmente non funziona. La soluzione leggermente più complicata presentata nella risposta di Jon Skeet è quindi ciò che probabilmente vorrai.

Answer 2

Come 'bout uno:

byte[] result = File.ReadAllBytes(fileName); 

Answer 3

Anche se non riducendo la LOC (non avevo mai usare questo come motivazione primaria), è possibile comprimere i usings come questo:

using (Stream fileStream = File.OpenRead(fileName)) 
using (BinaryReader binaryReader = new BinaryReader(fileStream)) 
using (MemoryStream memoryStream = new MemoryStream()) 
{ 
    byte[] buffer = new byte[256]; 
    int count; 
    int totalBytes = 0; 
    while ((count = binaryReader.Read(buffer, 0, 256)) > 0) 
    { 
     memoryStream.Write(buffer, 0, count); 
     totalBytes += count; 
    } 
    memoryStream.Position = 0; 
    byte[] transparentPng = new byte[totalBytes]; 
    memoryStream.Read(transparentPng, 0, totalBytes);  
} 

Answer 4

Ridurre le linee di codice è piuttosto semplice qui (mentre si lavora con i flussi arbitrarie, piuttosto che file):

using (Stream fileStream = File.OpenRead(fileName)) 
using (MemoryStream memoryStream = new MemoryStream()) 
{ 
    int byteRead; 
    while ((byteRead = fileStream.ReadByte()) != -1) 
    { 
     memoryStream.WriteByte(byteRead); 
    } 
    return memoryStream.ToArray(); 
} 

Ovviamente è molto più efficiente per leggere in un buffer che per leggere un byte alla volta, ma questo riduce il numero di dichiarazioni (come si don Devo dichiarare sia un buffer e una variabile per contenere il valore di ritorno da Stream). Chiamare MemoryStream.ToArray() è più semplice della lettura in un array di nuova costruzione.

L'utilizzo di un buffer è tuttavia più piacevole. Si noti che abbiamo davvero non abbiamo bisogno BinaryReader:

using (Stream fileStream = File.OpenRead(fileName)) 
using (MemoryStream memoryStream = new MemoryStream()) 
{ 
    byte[] buffer = new byte[8192]; 
    int bytesRead; 
    while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0) 
    { 
     memoryStream.Write(buffer, 0, bytesRead); 
    } 
    return memoryStream.ToArray(); 
} 

Se vuoi essere davvero brutale, potremmo ridurre il numero di using dichiarazioni (con entrambe le soluzioni):

using (Stream fileStream = File.OpenRead(fileName), 
       memoryStream = new MemoryStream()) 
{ 
    byte[] buffer = new byte[8192]; 
    int bytesRead; 
    while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0) 
    { 
     memoryStream.Write(buffer, 0, bytesRead); 
    } 
    return ((MemoryStream)memoryStream).ToArray(); 
} 

ma questo è semplicemente brutto :)

Un'altra opzione, naturalmente, è utilizzare una libreria come MiscUtil che ha un metodo per leggere completamente da un flusso :) Il metodo di utilità può essere semplice come questo:

public static byte[] ReadFully(this Stream stream) 
{ 
    using (MemoryStream memoryStream = new MemoryStream()) 
    { 
     byte[] buffer = new byte[8192]; 
     int bytesRead; 
     while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0) 
     { 
      memoryStream.Write(buffer, 0, bytesRead); 
     } 
     return memoryStream.ToArray(); 
    } 
} 

Si noti che questo mai chiude il flusso - il chiamante deve farlo.

Answer 5

Basta utilizzare il metodo del StreamCopyTo per copiare ad un MemoryStream, e ottenere la matrice:

using (var fileStream = File.OpenRead(fileName)) 
{ 
    using (var memoryStream = new MemoryStream()) 
    { 
     fileStream.CopyTo(memoryStream); 
     memoryStream.Seek(0, SeekOrigin.Begin); 

     byte[] transparentPng = memoryStream.ToArray(); 
    } 
}