Comment copier un flux dans un tableau d'octets avec le plus petit code C#?

Question

Jusqu'à maintenant je compte 12 LoCs. Pourriez-vous le rendre plus petit?

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

Il y a une méthode statique qui peut le faire pour vous en un seul appel.

var data = File.ReadAllBytes(fileName); 

Alternativement, une méthode qui fonctionne pour tout Stream (qui renvoie sa longueur) serait:

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

Pour les flux qui n'ont pas une longueur bien définie (par exemple NetworkStream), et donc lever une exception sur l'appel stream.Length, cela ne fonctionne bien sûr pas. La solution légèrement plus compliquée présentée dans la réponse de Jon Skeet est alors ce que vous voulez probablement.

Answer 2

Comment « bout un:

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

Answer 3

Tout en ne réduisant pas le COL (je ne l'avais jamais utiliser comme motivation primaire), vous pouvez réduire les usings comme ceci:

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

Réduire vos lignes de code est assez simple ici (tout en travaillant avec des flux arbitraires, plutôt que des fichiers):

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

de toute évidence, il est beaucoup plus efficace à lire dans un tampon que de lire un octet à la fois, mais cela réduit le nombre de déclarations (comme vous don pas besoin de déclarer à la fois un tampon et une variable pour contenir la valeur de retour de Stream). Appeler MemoryStream.ToArray() est plus simple que de lire dans un tableau nouvellement construit. L'utilisation d'un tampon est cependant plus agréable. Notez que nous ne avons pas vraiment besoin 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(); 
} 

Si vous voulez être vraiment brutale, nous pourrions réduire le nombre de using déclarations (soit avec solution):

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

Mais c'est juste méchant :)

Une autre option est bien sûr d'utiliser une bibliothèque telle que MiscUtil qui a une méthode pour lire entièrement à partir d'un flux :) La méthode utilitaire peut être aussi simple que ceci:

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

Notez que ce ne ferme le flux - l'appelant doit faire.

Answer 5

Il suffit d'utiliser la méthode CopyTo du Stream copier sur un MemoryStream et obtenir le tableau:

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

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