并行读取和 Zip 个条目文件

Question

I am trying to create a Zip from a list of files in parallel and stream it to client.

I have a working code where I iterate over files sequentially, but I want it instead to be zipped in parallel (multiple files with >100mb each).

using ZipArchive zipArchive = new(Response.BodyWriter.AsStream(), ZipArchiveMode.Create, leaveOpen: false);

for (int i = 0; i < arrLocalFilesPath.Length; i++) // iterate over files
{
    string strFilePath = arrLocalFilesPath[i]; // list of files path
    string strFileName = Path.GetFileName(strFilePath);

    ZipArchiveEntry zipEntry = zipArchive.CreateEntry(strFileName, CompressionLevel.Optimal);
    using Stream zipStream = zipEntry.Open();

    using FileStream fileStream = System.IO.File.Open(strFilePath, FileMode.Open, FileAccess.Read);
    fileStream.CopyTo(zipStream);
}

return new EmptyResult();

Parallel.For and Parallel.ForEach do not work with ZipArchive

Since ZipArchive is not thread safe, I am trying to use DotNetZip to accomplish this task.

I looked at the docs and here's what I have so far using DotNetZip

using Stream streamResponseBody = Response.BodyWriter.AsStream();

Parallel.For(0, arrLocalFilesPath.Length, i =>
{
    string strFilePath = arrLocalFilesPath[i]; // list of files path
    string strFileName = Path.GetFileName(strFilePath);

    string strCompressedOutputFile = strFilePath + ".compressed";

    byte[] arrBuffer = new byte[8192]; //[4096];
    int n = -1;

    using FileStream input = System.IO.File.OpenRead(strFilePath);
    using FileStream raw = new(strCompressedOutputFile, FileMode.Create, FileAccess.ReadWrite);

    using Stream compressor = new ParallelDeflateOutputStream(raw);
    while ((n = input.Read(arrBuffer, 0, arrBuffer.Length)) != 0)
    {
        compressor.Write(arrBuffer, 0, n);
    }

    input.CopyTo(streamResponseBody);
});

return new EmptyResult();

However, this doesn't zip files and send to client (it only creates local zip files on the server).

Using MemoryStream or creating a local zip file is out of the question and not what I am looking for.

The server should seamlessly stream read bytes of a file, zip it on the fly and send it to client as chunks (like in my ZipArchive ), but with the added benefits of reading those files in parallel and creating a zip of them.

I know that parallelism is usually not optimal for I/O (sometimes a bit worse), but parallel zipping multiple big files should be faster for this case.

I also tried to use SharpZipLib without success.

Usage of any other libraries is fine as long as it read and stream files to client seamlessly without impacting memory.

Any help is appreciated.

Answer 1

If these files are on the same drive there won't be any speed up. The parallelization is used to compress/decompress data, but the disk IO operation cannot be done in parallel.

Assuming that files are not on the same drive and there is a chance to speed up this process...

Are you sure the Stream.CopyTo() is thread safe? Either check the docs or use single thread or set lock on it.

EDIT:

I've checked my old codes, where I was packing huge amount of data into a zip file using ZipArchive . I did it in parallel, but there was no IO read there.

You can use ZipArchive with Parallel.For but you need to use lock :

//create zip into stream
using (ZipArchive zipArchive = new ZipArchive(zipFS, ZipArchiveMode.Update, false))
{    
    //use parallel foreach instead of parallel, but not for IO read operation!
    Parallel.ForEach(listOfFiles, filename =>
    {
        //create a file entry
        ZipArchiveEntry zipFileEntry = zipArchive.CreateEntry(filename);

        //prepare memory for the entry
        MemoryStream ms = new MemoryStream();

        /*fill the memory stream here - I did another packing with BZip2OutputStream, because the zip was packed without compression to speed up random decompression */

        //only one thread can write to zip!
        lock (zipFileEntry)
        {
            //open stream for writing 
            using (Stream zipEntryStream = zipFileEntry.Open())
            {
                ms.Position = 0; // rewind the stream
                StreamUtils.Copy(ms, zipEntryStream, new byte[4096]); //from  ICSharpCode.SharpZipLib.Core, copy memory stream data into zip entry with packing.            
            }
        }
    }
}

Anyway, if you need to read the files first, it's your performance bottleneck. You won't gain a lot (if anything) from parallel approach here.