使用SharpZipLib压缩文件的代码

答：使用SharpZipLib压缩文件的代码是：using (var fs = File.OpenRead(filename))
using (var zipStream = new ZipOutputStream(File.Create(zipFilename)))
{
var entry = new ZipEntry(Path.GetFileName(filename));
zipStream.PutNextEntry(entry);
fs.CopyTo(zipStream);
zipStream.CloseEntry();
}

相关问题

使用ICSharpCode.SharpZipLib快速压缩大型文件代码

以下是一个使用 ICSharpCode.SharpZipLib 快速压缩大型文件的示例代码，其中使用了分块压缩和多线程并发压缩的技术：

using System;
using System.IO;
using System.Threading.Tasks;
using ICSharpCode.SharpZipLib.Zip;

class Program
{
    static void Main(string[] args)
    {
        string sourceFilePath = "sourceFile.txt";
        string compressedFilePath = "compressedFile.zip";
        int blockSize = 1024 * 1024; // 每个块的大小为 1MB
        int threadCount = Environment.ProcessorCount; // 线程数为 CPU 核心数

        CompressFile(sourceFilePath, compressedFilePath, blockSize, threadCount);

        Console.WriteLine("Compression completed.");
        Console.ReadLine();
    }

    static void CompressFile(string sourceFilePath, string compressedFilePath, int blockSize, int threadCount)
    {
        // 计算文件大小和块数
        long fileSize = new FileInfo(sourceFilePath).Length;
        int blockCount = Convert.ToInt32(Math.Ceiling((double)fileSize / blockSize));

        // 创建压缩文件流
        using (var compressedFileStream = new FileStream(compressedFilePath, FileMode.Create))
        {
            // 创建 ZipOutputStream
            using (var zipOutputStream = new ZipOutputStream(compressedFileStream))
            {
                zipOutputStream.SetLevel(5); // 设置压缩级别

                // 分块压缩
                Parallel.For(0, blockCount, new ParallelOptions { MaxDegreeOfParallelism = threadCount }, i =>
                {
                    byte[] buffer = new byte[blockSize];
                    int bytesRead;
                    long offset = i * blockSize;

                    // 创建 ZipEntry
                    var zipEntry = new ZipEntry(Path.GetFileName(sourceFilePath));
                    zipEntry.DateTime = DateTime.Now;
                    zipEntry.Size = fileSize;
                    zipEntry.Offset = offset;

                    // 添加 ZipEntry
                    lock (zipOutputStream)
                    {
                        zipOutputStream.PutNextEntry(zipEntry);
                    }

                    // 读取块数据并压缩
                    using (var sourceFileStream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                    {
                        sourceFileStream.Seek(offset, SeekOrigin.Begin);
                        while ((bytesRead = sourceFileStream.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            lock (zipOutputStream)
                            {
                                zipOutputStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                });
            }
        }
    }
}

在上述示例代码中，使用 Parallel.For 方法进行多线程并发压缩，其中 MaxDegreeOfParallelism 属性指定了最大并发线程数，这里使用了 CPU 核心数作为线程数。

注意：在实际应用中，你需要根据实际需求进行调整和优化代码，例如选择合适的块大小和压缩级别，处理异常情况等。

使用ICSharpCode.SharpZipLib快速压缩大型文件夹代码

使用ICSharpCode.SharpZipLib库可以快速压缩大型文件夹，以下是示例代码：

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Zip;

public static void CompressFolder(string folderPath, string zipFilePath)
{
    //创建ZipOutputStream对象，用于压缩数据并写入到压缩文件中
    using (ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipFilePath)))
    {
        //设置压缩等级，0-9，0表示不压缩，9表示压缩率最高
        zipStream.SetLevel(9);

        //获取文件夹中所有文件和子文件夹
        string[] files = Directory.GetFiles(folderPath, "*", SearchOption.AllDirectories);

        //循环压缩每个文件
        foreach (string file in files)
        {
            //创建ZipEntry对象，表示压缩文件中的一个条目
            ZipEntry entry = new ZipEntry(Path.GetFileName(file));

            //设置压缩文件的时间戳
            entry.DateTime = DateTime.Now;

            //将条目添加到压缩流中
            zipStream.PutNextEntry(entry);

            //读取文件内容并写入到压缩流中
            using (FileStream fileStream = File.OpenRead(file))
            {
                int bufferSize = 4096;
                byte[] buffer = new byte[bufferSize];
                int bytesRead = 0;
                do
                {
                    bytesRead = fileStream.Read(buffer, 0, bufferSize);
                    zipStream.Write(buffer, 0, bytesRead);
                } while (bytesRead > 0);
            }
        }

        //关闭压缩流
        zipStream.Finish();
        zipStream.Close();
    }
}

你可以将上述代码封装成一个静态方法，然后在需要压缩文件夹的地方调用它即可。