ASP.NET MVC: est-ce une bonne idée de renvoyer un résultat de fichier à partir d'un octet []?

Question

J'ai une action dans un de mes contrôleurs qui crée un fichier zip téléchargeable qui devrait être servi à l'utilisateur. À l'heure actuelle mon code ressemble à ceci:

using(var memoryStream = new MemoryStream()) { 
    // ... use SharpZipLib to write zip file content to the above MemoryStream ... 
    return File(memoryStream.ToArray(), "application/zip", "file.zip"); 
} 

Je me demande si elle est une bonne idée aller convertir MemoryStream à un byte[], je suppose que cela prend plus de mémoire puis en utilisant le flux? Il y a une surcharge à File() qui prend un objet Stream, et j'ai passé dans ma variable memoryStream, mais juste une page blanche est apparue.

Idéalement je ne dois utiliser un FileStream et écrire un fichier sur le disque.

Answer 1

Utilisation du MemoryStream comme un flux au lieu d'obtenir les elliminates de tableau copie tout le contenu à la fois. La lecture du flux implique également la copie, mais c'est en plus petits morceaux.

Régler la position du flux de mémoire au début avant la lecture de celui-ci:

memoryStream.Position = 0; 

Answer 2

Si vous tenez vraiment à la mémoire puis est ici une solution qui directement écrire dans le flux de réponse. Tout d'abord définir votre ActionResult personnalisée:

public class SharpZipLibResult : FileResult 
{ 
    private readonly string _fileDownloadName; 
    private readonly string[] _filesToZip; 
    private const int ChunkSize = 1024; 

    public SharpZipLibResult(string fileDownloadName, params string[] filesToZip) 
     : base("application/octet-stream") 
    { 
     _fileDownloadName = fileDownloadName; 
     _filesToZip = filesToZip; 
    } 

    protected override void WriteFile(HttpResponseBase response) 
    { 
     var cd = new ContentDisposition(); 
     cd.FileName = _fileDownloadName; 
     response.AddHeader("Content-Disposition", cd.ToString()); 
     response.BufferOutput = false; 
     using (var zipStream = new ZipOutputStream(response.OutputStream)) 
     { 
      foreach (var file in _filesToZip) 
      { 
       var entry = new ZipEntry(Path.GetFileName(file)); 
       zipStream.PutNextEntry(entry); 
       using (var reader = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) 
       { 
        byte[] buffer = new byte[ChunkSize]; 
        int bytesRead; 
        while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0) 
        { 
         byte[] actual = new byte[bytesRead]; 
         Buffer.BlockCopy(buffer, 0, actual, 0, bytesRead); 
         zipStream.Write(actual, 0, actual.Length); 
        } 
       } 
      } 
     } 
    } 
} 

Avec cette technique, vous pouvez servir des fichiers zip vraiment énormes sans se soucier de la mémoire ou d'avoir à nettoyer certains fichiers zip temporaires sur vos disques durs du serveur.

Et enfin votre action de contrôleur pourrait ressembler à ceci:

public ActionResult Index() 
{ 
    return new SharpZipLibResult(
     "result.zip", 
     @"c:\work\report1.pdf", 
     @"c:\work\report2.pdf", 
     @"c:\work\report3.pdf" 
    ); 
} 

utilisant cette méthode empreinte mémoire est réduite au minimum parce que le zip est écrit directement au flux de réponse qui, en termes sera représenté par une prise de réseau sous-jacent.

Bien sûr, en fonction de l'endroit où vos fichiers sont stockés le SharpZipLibResult pourrait être modifié. Ici, je suppose que les fichiers sont stockés sur le système de fichiers.