Korzystając z interfejsu ASP.NET Web API, w jaki sposób kontroler może zwrócić kolekcję strumieniowych obrazów skompresowanych przy użyciu biblioteki DotNetZip?

Question

W jaki sposób można utworzyć kontroler interfejsu Web API, który generuje i zwraca skompresowany plik ZIP przesyłany strumieniowo z kolekcji plików JPEG w pamięci (obiekty MemoryStream). Próbuję użyć biblioteki DotNetZip. Znalazłem ten przykład: http://www.4guysfromrolla.com/articles/092910-1.aspx#postadlink. Ale Response.OutputStream nie jest dostępny w Web API i dlatego technika ta nie działa. Dlatego próbowałem zapisać plik zip do nowego MemoryStream; ale rzucił. Wreszcie próbowałem używać PushStreamContent. Oto mój kod:

public HttpResponseMessage Get(string imageIDsList) { 
     var imageIDs = imageIDsList.Split(',').Select(_ => int.Parse(_)); 
     var any = _dataContext.DeepZoomImages.Select(_ => _.ImageID).Where(_ => imageIDs.Contains(_)).Any(); 
     if (!any) { 
      throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)); 
     } 
     var dzImages = _dataContext.DeepZoomImages.Where(_ => imageIDs.Contains(_.ImageID)); 
     using (var zipFile = new ZipFile()) { 
      foreach (var dzImage in dzImages) { 
       var bitmap = GetFullSizeBitmap(dzImage); 
       var memoryStream = new MemoryStream(); 
       bitmap.Save(memoryStream, ImageFormat.Jpeg); 
       var fileName = string.Format("{0}.jpg", dzImage.ImageName); 
       zipFile.AddEntry(fileName, memoryStream); 
      } 
      var response = new HttpResponseMessage(HttpStatusCode.OK); 
      var memStream = new MemoryStream(); 
      zipFile.Save(memStream); //Null Reference Exception 
      response.Content = new ByteArrayContent(memStream.ToArray()); 
      response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); 
      response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = string.Format("{0}_images.zip", dzImages.Count()) }; 
      return response; 
     } 
    } 

zipFile.Save (memStream) wyrzuca pustą referencję. Ale ani zipFile, ani memStream nie są puste i nie ma wewnętrznego wyjątku. Więc nie jestem pewien, co powoduje odwołanie zerowe. Mam bardzo małe doświadczenie z Web API, strumieniami pamięci i nigdy wcześniej nie korzystałem z DotNetZipLibrary. Jest to kontynuacja tego pytania: Want an efficient ASP.NET Web API controller that can reliably return 30 to 50 ~3MB JPEGs

Wszelkie pomysły? dzięki!

Answer 1

W tym przypadku można użyć klasy PushStreamContent, aby wyeliminować konieczność użycia strumienia MemoryStream, przynajmniej dla całego pliku zip. Może on być realizowany tak:

public HttpResponseMessage Get(string imageIDsList) 
    { 
     var imageIDs = imageIDsList.Split(',').Select(_ => int.Parse(_)); 
     var any = _dataContext.DeepZoomImages.Select(_ => _.ImageID).Where(_ => imageIDs.Contains(_)).Any(); 
     if (!any) 
     { 
      throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)); 
     } 
     var dzImages = _dataContext.DeepZoomImages.Where(_ => imageIDs.Contains(_.ImageID)); 
     var streamContent = new PushStreamContent((outputStream, httpContext, transportContent) => 
      { 
       try 
       { 
        using (var zipFile = new ZipFile()) 
        { 
         foreach (var dzImage in dzImages) 
         { 
          var bitmap = GetFullSizeBitmap(dzImage); 
          var memoryStream = new MemoryStream(); 
          bitmap.Save(memoryStream, ImageFormat.Jpeg); 
          memoryStream.Position = 0; 
          var fileName = string.Format("{0}.jpg", dzImage.ImageName); 
          zipFile.AddEntry(fileName, memoryStream); 
         } 
         zipFile.Save(outputStream); //Null Reference Exception 
        } 
       } 
       finally 
       { 
        outputStream.Close(); 
       } 
      }); 
     streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); 
     streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") 
     { 
      FileName = string.Format("{0}_images.zip", dzImages.Count()), 
     }; 

     var response = new HttpResponseMessage(HttpStatusCode.OK) 
      { 
       Content = streamContent 
      }; 

     return response; 
    } 

Idealnie byłoby możliwe, aby ten jeszcze bardziej dynamicznie tworzone przy użyciu klasy ZipOutputStream do dynamicznego tworzenia zip zamiast używania zipfile. W takim przypadku MemoryStream dla każdej bitmapy nie byłby potrzebny.

Answer 2

Bardziej ogólne podejście będzie działać tak:

using Ionic.Zip; // from NUGET-Package "DotNetZip" 

public HttpResponseMessage Zipped() 
{ 
    using (var zipFile = new ZipFile()) 
    { 
     // add all files you need from disk, database or memory 
     // zipFile.AddEntry(...); 

     return ZipContentResult(zipFile); 
    } 
} 

protected HttpResponseMessage ZipContentResult(ZipFile zipFile) 
{ 
    // inspired from http://stackoverflow.com/a/16171977/92756 
    var pushStreamContent = new PushStreamContent((stream, content, context) => 
    { 
     zipFile.Save(stream); 
     stream.Close(); // After save we close the stream to signal that we are done writing. 
    }, "application/zip"); 

    return new HttpResponseMessage(HttpStatusCode.OK) {Content = pushStreamContent}; 
} 

Sposób ZipContentResult może również żyć w klasie bazowej i będą używane z jakiegokolwiek innego działania w dowolnym kontrolerze API.

Answer 3

Po prostu miałem ten sam problem co ty.

zipFile.Save(outputStream); //I got Null Reference Exception here. 

Problemem było to, że dodawanie plików ze strumienia pamięci tak:

zip.AddEntry(fileName, ms); 

Wszystko co musisz zrobić, to zmienić go na to:

zip.AddEntry(fileName, ms.ToArray()); 

Wydaje się, że gdy pisarz postanawia faktycznie zapisać plik i próbuje odczytać strumień, strumień jest zbiorem śmieci lub ...

Pozdrawiam!

Answer 4

public HttpResponseMessage GetItemsInZip(int id) 
    {   
      var itemsToWrite = // return array of objects based on id; 

      // create zip file stream 
      MemoryStream archiveStream = new MemoryStream(); 
      using (ZipArchive archiveFile = new ZipArchive(archiveStream, ZipArchiveMode.Create, true)) 
      { 
       foreach (var item in itemsToWrite) 
       { 
        // create file streams 
        // add the stream to zip file 

        var entry = archiveFile.CreateEntry(item.FileName); 
        using (StreamWriter sw = new StreamWriter(entry.Open())) 
        { 
         sw.Write(item.Content); 
        } 
       } 
      } 

      // return the zip file stream to http response content     
      HttpResponseMessage responseMsg = new HttpResponseMessage(HttpStatusCode.OK);     
      responseMsg.Content = new ByteArrayContent(archiveStream.ToArray()); 
      archiveStream.Dispose(); 
      responseMsg.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = "test.zip" }; 
      responseMsg.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); 

      return responseMsg;   
    } 

Używane .NET Framework 4.6.1 z MVC 5