Creating Zip file from stream and downloading it

I have a DataTable that i want to convert it to xml and then zip it, using DotNetZip. finally user can download it via Asp.Net webpage. My code in below

    dt.TableName = "Declaration";

    MemoryStream stream = new MemoryStream();
    dt.WriteXml(stream);

    ZipFile zipFile = new ZipFile();
    zipFile.AddEntry("Report.xml", "", stream);
    Response.ClearContent();
    Response.ClearHeaders();
    Response.AppendHeader("content-disposition", "attachment; filename=Report.zip");
   
    zipFile.Save(Response.OutputStream);
    //Response.Write(zipstream);
    zipFile.Dispose();

the xml file in zip file is empty.

2 things. First, if you keep the code design you have, you need to perform a Seek() on the MemoryStream before writing it into the entry.

dt.TableName = "Declaration"; 

MemoryStream stream = new MemoryStream(); 
dt.WriteXml(stream); 
stream.Seek(0,SeekOrigin.Begin);   // <-- must do this after writing the stream!

using (ZipFile zipFile = new ZipFile())
{
  zipFile.AddEntry("Report.xml", "", stream); 
  Response.ClearContent(); 
  Response.ClearHeaders(); 
  Response.AppendHeader("content-disposition", "attachment; filename=Report.zip"); 

  zipFile.Save(Response.OutputStream); 
}

Even if you keep this design, I would suggest a using() clause, as I have shown, and as described in all the DotNetZip examples, in lieu of calling Dispose(). The using() clause is more reliable in the face of failures.

> Now you may wonder, why is it necessary to seek in the MemoryStream before calling AddEntry()? The reason is, AddEntry() is designed to support those callers who pass a stream where the position is important. In that case, the caller needs the entry data to be read from the stream, using the current position of the stream. AddEntry() supports that. Therefore, set the position in the stream before calling AddEntry().

But, the better option is to modify your code to use the overload of AddEntry() that accepts a WriteDelegate. It was designed specifically for adding datasets into zip files. Your original code writes the dataset into a memory stream, then seeks on the stream, and writes the content of the stream into the zip. It's faster and easier if you write the data once, which is what the WriteDelegate allows you to do. The code looks like this:

dt.TableName = "Declaration"; 
Response.ClearContent(); 
Response.ClearHeaders(); 
Response.ContentType = "application/zip";
Response.AppendHeader("content-disposition", "attachment; filename=Report.zip"); 

using(Ionic.Zip.ZipFile zipFile = new Ionic.Zip.ZipFile())
{
    zipFile.AddEntry("Report.xml", (name,stream) => dt.WriteXml(stream) );
    zipFile.Save(Response.OutputStream); 
}

This writes the dataset directly into the compressed stream in the zipfile. Very efficient! No double-buffering. The anonymous delegate is called at the time of ZipFile.Save(). Only one write (+compress) is performed.

Why did you not close the MemoryStream, I would wrap that in a using clause, the same could be said for zipFile? Also dt I presume is a DataTable...put in error checking to see if there's rows, see the code below...

dt.TableName = "Declaration";

if (dt.Rows != null && dt.Rows.Count >= 1){
  using (MemoryStream stream = new MemoryStream()){
     dt.WriteXml(stream); 

     // Thanks Cheeso/Mikael
     stream.Seek(0, SeekOrigin.Begin);
     //

     using (ZipFile zipFile = new ZipFile()){
         zipFile.AddEntry("Report.xml", "", stream); 
         Response.ClearContent(); 
         Response.ClearHeaders(); 
         Response.AppendHeader("content-disposition", "attachment; filename=Report.zip"); 

         //zipFile.Save(Response.OutputStream); 
         zipFile.Save(stream);

         // Commented this out
         /*
           Response.Write(zipstream); // <----- Where did that come from?
         */
      }
      Response.Write(stream);
   } 
}
// No rows...don't bother...

Edit: Having looked at this again, and realizing that Ionic.Ziplib from Codeplex was used, I changed the code slightly, instead of zipFile.Save(Response.OutputStream); I used zipFile.Save(stream); using the stream instance of the MemoryStream class and write it out using Response.Write(stream);.

Edit#2: Thanks to Cheeso + Mikael for pointing out the obvious flaw - I missed it a mile off and did not understood their comment until I realized that the stream was at the end...

Have you tried to flush the stream before zipping?

dt.WriteXml(stream);
stream.Flush();
ZipFile zipFile = new ZipFile();

Ok. It doesn't seem like we are getting very far here so you need to start debugging this a bit more.

Update you're code to do the following:

dt.WriteXml(stream);
stream.Seek(0, SeekOrigin.Begin);
File.WriteAllBytes("c:\test.xml", stream.GetBuffer());

See if you have a valid XML file out. If you do then move on do the same with your ZipFile. Save it to a local file. See if it's there, has your xml file and your xml file has content in it.

If that works, try sending back just the memory stream as the response, see if that works.

You should then be able to track the problem down further.

Add a ContentType header:

Response.ContentType = "application/zip";

this will allow the browsers to detect what you are sending.

Double check the stream you are returning back too. In your example below

zipFile.Save(Response.OutputStream);
Response.Write(zipstream);
zipFile.Dispose();

You are saving the zipFile to your response stream using the Save method, but then you are also calling Response.Write() with a zipstream variable. What is zipstream? Check that it isn't an empty stream too.

This code will help you in downloading a file from stream.

using (var outStream = new MemoryStream())
{
    using (var archive = new ZipArchive(outStream, ZipArchiveMode.Create, true))
    {
        var fileInArchive = archive.CreateEntry("FileName.pdf", CompressionLevel.Optimal);
        using (var entryStream = fileInArchive.Open())
        using (WebResponse response = req.GetResponse())
        {
            using (var fileToCompressStream = response.GetResponseStream())
            {
                fileToCompressStream.CopyTo(entryStream);
            }
        }                       
    }
    using (var fileStream = new FileStream(@"D:\test.zip", FileMode.Create))
    {
        outStream.Seek(0, SeekOrigin.Begin);
        outStream.CopyTo(fileStream);
    }
}

Namespaces needed:

using System.IO.Compression;
using System.IO.Compression.ZipArchive;

Creating a zip file from stream and downloading it. Below is the code.

FileStream stream=File.OpenRead(@"D:\FileDownLoad\DeskTop\1.txt");
MemoryStream MS=new MemoryStream();

ZipOutputStream zipOutputStream = new ZipOutputStream(MS);
zipOutputStream.SetLevel(9);
ZipEntry entry = new ZipEntry("1.txt");
zipOutputStream.PutNextEntry(entry);

byte[] buffer = new byte[stream.Length];
int byteRead = 0;

while ((byteRead = stream.Read(buffer, 0, buffer.Length)) > 0) 
    zipOutputStream.Write(buffer, 0, byteRead);

    zipOutputStream.IsStreamOwner = false;
    stream.Close();
    zipOutputStream.Close();
    MS.Position = 0;

    Response.ContentType = "application/application/octet-stream";
    Response.AppendHeader("content-disposition", "attachment; filename=\"Download.zip\"");
    Response.BinaryWrite(MS.ToArray());