C#中使用System.IO.Compression实现高效ZIP压缩与解压

1. 项目概述

在C#开发中，经常需要处理文件压缩和解压缩的场景。Windows操作系统原生提供了强大的ZIP文件处理功能，通过.NET Framework中的System.IO.Compression命名空间，我们可以轻松实现文件夹打包为ZIP文件的操作。这种方式相比第三方库有几个显著优势：无需额外依赖、性能稳定、与Windows系统深度集成。

我在多个实际项目中都使用过这种原生压缩方案，特别是在需要保证部署环境纯净的场合。比如在开发自动更新模块时，就采用了这种方案来打包和分发更新文件包。下面我将详细介绍具体实现方法和注意事项。

2. 环境准备与基础配置

2.1 引用必要的命名空间

要使用Windows自带的ZIP功能，首先需要在项目中添加对System.IO.Compression和System.IO.Compression.FileSystem的引用。对于.NET Core/.NET 5+项目，只需要通过NuGet添加System.IO.Compression.ZipFile包即可。

csharp复制// 对于.NET Framework项目
using System.IO;
using System.IO.Compression;

// 对于.NET Core/.NET 5+项目
// 需要通过NuGet安装System.IO.Compression.ZipFile

2.2 基础压缩方法

最简单的文件夹压缩只需要一行代码：

csharp复制ZipFile.CreateFromDirectory(@"C:\sourceFolder", @"C:\archive.zip");

这个方法会将sourceFolder目录下的所有文件和子目录递归地打包到archive.zip文件中。但实际项目中，我们通常需要更多控制和错误处理。

3. 高级压缩功能实现

3.1 带压缩级别的打包

Windows自带的ZIP功能支持不同的压缩级别，我们可以通过ZipFileExtensions类来实现：

csharp复制public static void CreateZipWithLevel(string sourceDir, string zipPath, CompressionLevel level)
{
    // 确保源目录存在
    if (!Directory.Exists(sourceDir))
        throw new DirectoryNotFoundException($"Source directory not found: {sourceDir}");

    // 临时目录用于中间处理
    string tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
    Directory.CreateDirectory(tempDir);
    
    try
    {
        // 创建空zip文件
        using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
        {
            // 添加一个空条目以确保文件创建
            archive.CreateEntry("placeholder");
        }
        
        // 重新打开并添加实际内容
        using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Update))
        {
            foreach (var file in Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories))
            {
                // 计算相对路径
                string relativePath = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar);
                
                // 创建条目并设置压缩级别
                var entry = archive.CreateEntry(relativePath, level);
                using (var entryStream = entry.Open())
                using (var fileStream = File.OpenRead(file))
                {
                    fileStream.CopyTo(entryStream);
                }
            }
        }
    }
    finally
    {
        // 清理临时目录
        if (Directory.Exists(tempDir))
            Directory.Delete(tempDir, true);
    }
}

3.2 进度报告与取消支持

对于大文件夹的压缩，添加进度反馈和取消功能很有必要：

csharp复制public static async Task CreateZipWithProgressAsync(
    string sourceDir, 
    string zipPath, 
    IProgress<double> progress, 
    CancellationToken cancellationToken)
{
    var files = Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories);
    long totalBytes = files.Sum(f => new FileInfo(f).Length);
    long processedBytes = 0;
    
    using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
    {
        foreach (var file in files)
        {
            cancellationToken.ThrowIfCancellationRequested();
            
            string relativePath = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar);
            var entry = archive.CreateEntry(relativePath, CompressionLevel.Optimal);
            
            using (var entryStream = entry.Open())
            using (var fileStream = File.OpenRead(file))
            {
                await fileStream.CopyToAsync(entryStream);
                processedBytes += fileStream.Length;
                
                double percentage = (double)processedBytes / totalBytes * 100;
                progress?.Report(percentage);
            }
        }
    }
}

4. 异常处理与安全考虑

4.1 常见异常处理

在实际使用中，可能会遇到各种异常情况：

csharp复制public static void SafeCreateZip(string sourceDir, string zipPath)
{
    try
    {
        // 检查源目录
        if (!Directory.Exists(sourceDir))
            throw new DirectoryNotFoundException("Source directory does not exist");
            
        // 检查目标路径是否可用
        string zipDir = Path.GetDirectoryName(zipPath);
        if (!Directory.Exists(zipDir))
            Directory.CreateDirectory(zipDir);
            
        // 检查文件是否被占用
        if (File.Exists(zipPath))
        {
            try
            {
                using (var fs = new FileStream(zipPath, FileMode.Open))
                {
                    // 如果能打开，说明文件未被占用
                }
                File.Delete(zipPath);
            }
            catch (IOException)
            {
                throw new IOException("ZIP file is in use by another process");
            }
        }
        
        // 执行压缩
        ZipFile.CreateFromDirectory(sourceDir, zipPath, CompressionLevel.Optimal, false);
    }
    catch (UnauthorizedAccessException ex)
    {
        // 处理权限问题
        throw new Exception("Access denied - check permissions", ex);
    }
    catch (PathTooLongException ex)
    {
        // 处理路径过长问题
        throw new Exception("Path is too long - consider using shorter paths", ex);
    }
    catch (IOException ex)
    {
        // 处理其他IO问题
        throw new Exception("IO error occurred during compression", ex);
    }
    catch (Exception ex)
    {
        // 处理其他未预料到的异常
        throw new Exception("Unexpected error during ZIP creation", ex);
    }
}

4.2 安全注意事项

处理文件压缩时需要考虑以下安全因素：

1. 路径遍历攻击防护：

csharp复制string sanitizedPath = Path.GetFullPath(Path.Combine(basePath, relativePath));
if (!sanitizedPath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
    throw new SecurityException("Invalid path - possible directory traversal attempt");

2. 文件大小限制：

csharp复制const long MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
if (new FileInfo(filePath).Length > MAX_FILE_SIZE)
    throw new Exception("File size exceeds maximum allowed limit");

3. 文件类型过滤：

csharp复制string[] allowedExtensions = { ".txt", ".jpg", ".png" };
string extension = Path.GetExtension(filePath).ToLower();
if (!allowedExtensions.Contains(extension))
    throw new Exception("File type not allowed");

5. 性能优化技巧

5.1 并行压缩技术

对于包含大量文件的文件夹，可以使用并行处理提高速度：

csharp复制public static void ParallelCreateZip(string sourceDir, string zipPath)
{
    var files = Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories);
    
    using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
    {
        object lockObj = new object();
        
        Parallel.ForEach(files, file =>
        {
            string relativePath = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar);
            
            lock (lockObj)
            {
                var entry = archive.CreateEntry(relativePath, CompressionLevel.Fastest);
                using (var entryStream = entry.Open())
                using (var fileStream = File.OpenRead(file))
                {
                    fileStream.CopyTo(entryStream);
                }
            }
        });
    }
}

5.2 内存优化策略

处理大文件时，可以采用流式处理避免内存溢出：

csharp复制public static void StreamBasedCompression(string sourceDir, string zipPath)
{
    using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
    {
        foreach (var file in Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories))
        {
            string relativePath = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar);
            var entry = archive.CreateEntry(relativePath, CompressionLevel.Optimal);
            
            using (var entryStream = entry.Open())
            using (var fileStream = File.OpenRead(file))
            {
                byte[] buffer = new byte[81920]; // 80KB buffer
                int bytesRead;
                while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    entryStream.Write(buffer, 0, bytesRead);
                }
            }
        }
    }
}

6. 实际应用场景

6.1 日志文件自动归档

在服务器应用中，经常需要定期归档日志文件：

csharp复制public static void ArchiveLogs(string logDirectory, int daysToKeep)
{
    string archiveName = $"Logs_{DateTime.Now:yyyyMMddHHmmss}.zip";
    string archivePath = Path.Combine(logDirectory, "Archives", archiveName);
    
    // 获取需要归档的日志文件
    var filesToArchive = Directory.GetFiles(logDirectory, "*.log")
        .Where(f => (DateTime.Now - File.GetLastWriteTime(f)).TotalDays > daysToKeep)
        .ToList();
    
    if (filesToArchive.Any())
    {
        Directory.CreateDirectory(Path.GetDirectoryName(archivePath));
        
        using (var archive = ZipFile.Open(archivePath, ZipArchiveMode.Create))
        {
            foreach (var file in filesToArchive)
            {
                string entryName = Path.GetFileName(file);
                archive.CreateEntryFromFile(file, entryName, CompressionLevel.Optimal);
                
                // 归档后删除原文件
                File.Delete(file);
            }
        }
    }
}

6.2 应用程序数据备份

实现简单的数据备份功能：

csharp复制public static void BackupApplicationData(string appDataPath, string backupRoot)
{
    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string backupDir = Path.Combine(backupRoot, $"Backup_{timestamp}");
    string zipPath = Path.Combine(backupRoot, $"Backup_{timestamp}.zip");
    
    try
    {
        // 先复制到临时目录
        DirectoryCopy(appDataPath, backupDir, true);
        
        // 然后压缩
        ZipFile.CreateFromDirectory(backupDir, zipPath, CompressionLevel.Optimal, false);
        
        // 清理临时目录
        Directory.Delete(backupDir, true);
        
        // 保留最近5个备份
        var oldBackups = Directory.GetFiles(backupRoot, "Backup_*.zip")
            .OrderByDescending(f => f)
            .Skip(5);
            
        foreach (var oldBackup in oldBackups)
        {
            File.Delete(oldBackup);
        }
    }
    catch (Exception ex)
    {
        // 错误处理
        throw new Exception("Backup failed", ex);
    }
}

private static void DirectoryCopy(string sourceDir, string destDir, bool copySubDirs)
{
    DirectoryInfo dir = new DirectoryInfo(sourceDir);
    DirectoryInfo[] dirs = dir.GetDirectories();

    Directory.CreateDirectory(destDir);

    foreach (FileInfo file in dir.GetFiles())
    {
        string tempPath = Path.Combine(destDir, file.Name);
        file.CopyTo(tempPath, false);
    }

    if (copySubDirs)
    {
        foreach (DirectoryInfo subdir in dirs)
        {
            string tempPath = Path.Combine(destDir, subdir.Name);
            DirectoryCopy(subdir.FullName, tempPath, copySubDirs);
        }
    }
}

7. 常见问题与解决方案

7.1 文件锁定问题

在压缩正在被其他进程使用的文件时可能会遇到锁定问题。解决方案包括：

1. 尝试多次重试：

csharp复制public static bool TryAddFileToArchive(ZipArchive archive, string filePath, string entryName, int maxRetries = 3)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            archive.CreateEntryFromFile(filePath, entryName, CompressionLevel.Optimal);
            return true;
        }
        catch (IOException) when (i < maxRetries - 1)
        {
            Thread.Sleep(500 * (i + 1));
        }
    }
    return false;
}

2. 使用卷影复制服务(VSS) - 需要管理员权限：

csharp复制[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CreateFile(
    string lpFileName,
    uint dwDesiredAccess,
    uint dwShareMode,
    IntPtr lpSecurityAttributes,
    uint dwCreationDisposition,
    uint dwFlagsAndAttributes,
    IntPtr hTemplateFile);

const uint FILE_SHARE_READ = 0x00000001;
const uint FILE_SHARE_WRITE = 0x00000002;
const uint FILE_SHARE_DELETE = 0x00000004;
const uint OPEN_EXISTING = 3;
const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;

public static Stream OpenShadowCopy(string filePath)
{
    IntPtr handle = CreateFile(
        @"\\?\VolumeShadowCopy\" + filePath,
        0x80000000, // GENERIC_READ
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
        IntPtr.Zero,
        OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS,
        IntPtr.Zero);
    
    if (handle.ToInt32() == -1)
        throw new Win32Exception(Marshal.GetLastWin32Error());
        
    return new FileStream(handle, FileAccess.Read);
}

7.2 长路径问题

Windows默认路径长度限制是260个字符。解决方法：

1. 启用长路径支持(需要Windows 10 1607+和程序清单配置)：

xml复制<application xmlns="urn:schemas-microsoft-com:asm.v3">
    <windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
        <ws2:longPathAware>true</ws2:longPathAware>
    </windowsSettings>
</application>

2. 使用UNC路径前缀：

csharp复制string longPath = @"\\?\" + fullPath;

7.3 特殊字符处理

处理包含特殊字符的文件名时：

csharp复制public static string SanitizeEntryName(string name)
{
    var invalidChars = Path.GetInvalidFileNameChars();
    var sb = new StringBuilder(name);
    
    foreach (var c in invalidChars)
    {
        sb.Replace(c, '_');
    }
    
    // 处理其他特殊情况
    sb.Replace("%", "%25")
      .Replace("#", "%23")
      .Replace("?", "%3F");
      
    return sb.ToString();
}

8. 扩展功能实现

8.1 密码保护ZIP文件

虽然原生System.IO.Compression不支持密码保护，但可以通过Windows内置的CompressedFolder API实现：

csharp复制[ComImport]
[Guid("E88DCCE0-B7B3-11d1-A9F0-00AA0060FA31")]
[ClassInterface(ClassInterfaceType.None)]
private class ZipFolder { }

[ComImport]
[Guid("AA509086-5CA9-4C25-8F95-589D3C07B48A")]
private interface IZipFolder
{
    void AddItem(string filePath);
    void CopyHere(int itemCount);
}

public static void CreatePasswordProtectedZip(string sourceDir, string zipPath, string password)
{
    // 创建空zip文件
    File.WriteAllBytes(zipPath, new byte[] { 0x50, 0x4B, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
    
    // 使用Shell对象设置密码
    dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("Shell.Application"));
    dynamic zipFolder = shell.NameSpace(zipPath);
    
    if (!string.IsNullOrEmpty(password))
    {
        // 这些魔法数字代表不同的压缩选项
        zipFolder.CopyHere(0x14); // 开始加密
        zipFolder.CopyHere(0x54); // 设置密码
        zipFolder.CopyHere(password);
    }
    
    // 添加文件
    foreach (var file in Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories))
    {
        zipFolder.CopyHere(file);
        while (IsFileLocked(zipPath)) // 等待文件解锁
            Thread.Sleep(100);
    }
}

private static bool IsFileLocked(string filePath)
{
    try
    {
        using (File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            return false;
        }
    }
    catch (IOException)
    {
        return true;
    }
}

8.2 分卷压缩实现

实现将大ZIP文件分割为多个小文件：

csharp复制public static void CreateSplitZip(string sourceDir, string zipPathBase, long splitSize)
{
    int partNumber = 1;
    string currentZipPath = $"{zipPathBase}.zip.{partNumber:D3}";
    
    using (var archive = ZipFile.Open(currentZipPath, ZipArchiveMode.Create))
    {
        long currentSize = 0;
        
        foreach (var file in Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories))
        {
            string relativePath = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar);
            var fileInfo = new FileInfo(file);
            
            if (currentSize + fileInfo.Length > splitSize && currentSize > 0)
            {
                archive.Dispose();
                partNumber++;
                currentZipPath = $"{zipPathBase}.zip.{partNumber:D3}";
                currentSize = 0;
                
                archive = ZipFile.Open(currentZipPath, ZipArchiveMode.Create);
            }
            
            var entry = archive.CreateEntry(relativePath, CompressionLevel.Optimal);
            using (var entryStream = entry.Open())
            using (var fileStream = File.OpenRead(file))
            {
                fileStream.CopyTo(entryStream);
                currentSize += fileStream.Length;
            }
        }
    }
    
    // 创建合并批处理文件
    string batchContent = @"
@echo off
copy /b """ + zipPathBase + @".zip.*"" """ + zipPathBase + @".zip""
del """ + zipPathBase + @".zip.*""
";
    File.WriteAllText($"{zipPathBase}_combine.bat", batchContent);
}

9. 性能对比与测试

9.1 不同压缩级别对比

我测试了三种压缩级别在不同类型文件上的表现：

结论：

• 对于已经压缩的文件格式(如JPG)，压缩级别影响不大
• 对文本和数据库文件，最优压缩能显著减小体积但耗时更长
• 二进制文件压缩率较低

9.2 与第三方库对比

与常见第三方库的性能对比：

选择建议：

• 简单需求：优先使用System.IO.Compression
• 需要密码保护：DotNetZip
• 需要最高压缩率：SevenZipSharp
• 跨平台兼容性：SharpZipLib

10. 实际项目中的最佳实践

根据我在多个项目中的经验，总结以下最佳实践：

1. 压缩级别选择：

   • 日志文件：使用CompressionLevel.Fastest
   • 用户数据备份：使用CompressionLevel.Optimal
   • 临时文件传输：使用CompressionLevel.NoCompression

2. 异常处理策略：

csharp复制try
{
    ZipFile.CreateFromDirectory(source, target);
}
catch (IOException ex) when (ex.Message.Contains("already exists"))
{
    // 处理文件已存在情况
    File.Delete(target);
    ZipFile.CreateFromDirectory(source, target);
}
catch (UnauthorizedAccessException)
{
    // 尝试以管理员权限运行
    RequestAdminPermission();
    RetryOperation();
}
catch (Exception ex)
{
    Logger.Error("Zip failed", ex);
    throw new UserFriendlyException("无法创建压缩文件，请检查磁盘空间和权限");
}

3. 进度反馈实现：

csharp复制public class ZipProgressReporter
{
    private readonly IProgress<double> _progress;
    private readonly long _totalBytes;
    private long _processedBytes;
    
    public ZipProgressReporter(IProgress<double> progress, long totalBytes)
    {
        _progress = progress;
        _totalBytes = totalBytes;
    }
    
    public void ReportProgress(long bytesProcessed)
    {
        _processedBytes += bytesProcessed;
        double percentage = (double)_processedBytes / _totalBytes * 100;
        _progress?.Report(percentage);
    }
}

// 使用示例
var files = Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories);
long totalSize = files.Sum(f => new FileInfo(f).Length);
var progress = new Progress<double>(p => Console.WriteLine($"{p:F1}%"));
var reporter = new ZipProgressReporter(progress, totalSize);

using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
{
    foreach (var file in files)
    {
        var entry = archive.CreateEntry(Path.GetRelativePath(sourceDir, file));
        using (var entryStream = entry.Open())
        using (var fileStream = File.OpenRead(file))
        {
            byte[] buffer = new byte[81920];
            int bytesRead;
            while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
            {
                entryStream.Write(buffer, 0, bytesRead);
                reporter.ReportProgress(bytesRead);
            }
        }
    }
}

4. 资源清理模式：

csharp复制public class TempZipFile : IDisposable
{
    public string FilePath { get; }
    
    public TempZipFile(string prefix = null)
    {
        FilePath = Path.Combine(Path.GetTempPath(), 
            string.IsNullOrEmpty(prefix) ? 
                Path.GetRandomFileName() + ".zip" : 
                prefix + "_" + Path.GetRandomFileName() + ".zip");
    }
    
    public void AddFiles(IEnumerable<string> files, string baseDirectory = null)
    {
        using (var archive = ZipFile.Open(FilePath, ZipArchiveMode.Update))
        {
            foreach (var file in files)
            {
                string entryName = string.IsNullOrEmpty(baseDirectory) ? 
                    Path.GetFileName(file) : 
                    Path.GetRelativePath(baseDirectory, file);
                    
                archive.CreateEntryFromFile(file, entryName);
            }
        }
    }
    
    public void Dispose()
    {
        try
        {
            if (File.Exists(FilePath))
                File.Delete(FilePath);
        }
        catch
        {
            // 静默处理清理错误
        }
    }
}

// 使用示例
using (var tempZip = new TempZipFile("backup"))
{
    tempZip.AddFiles(Directory.GetFiles(logDir, "*.log"));
    // 使用tempZip.FilePath进行其他操作
} // 自动清理