您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
# .Net Core 多文件打包压缩的实现代码怎么写
## 前言
在现代软件开发中，文件打包和压缩是常见的需求场景。无论是日志归档、批量文件下载还是数据备份，都需要将多个文件高效地打包成一个压缩包。本文将深入探讨在.NET Core中实现多文件打包压缩的完整解决方案，涵盖从基础实现到高级优化的全过程。
## 一、准备工作
### 1.1 环境要求
- .NET Core 3.1 或更高版本
- Visual Studio 2019/2022 或 VS Code
- NuGet 包管理器
### 1.2 必要NuGet包
```bash
dotnet add package SharpZipLib
dotnet add package System.IO.Compression
dotnet add package System.IO.Compression.ZipFile
public class BasicZipArchiver
{
public static void CreateZipFile(IEnumerable<string> filesToZip, string outputPath)
{
using (var zipArchive = ZipFile.Open(outputPath, ZipArchiveMode.Create))
{
foreach (var file in filesToZip)
{
zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
}
}
}
}
public static void ZipDirectory(string sourceDirectory, string destinationFile)
{
if (!Directory.Exists(sourceDirectory))
throw new DirectoryNotFoundException($"Source directory not found: {sourceDirectory}");
ZipFile.CreateFromDirectory(
sourceDirectory,
destinationFile,
CompressionLevel.Optimal,
includeBaseDirectory: false);
}
public class MultiVolumeZipCreator
{
private const int MaxVolumeSize = 10 * 1024 * 1024; // 10MB per volume
public void CreateMultiVolumeZip(string[] sourceFiles, string outputBaseName)
{
int volumeNumber = 1;
using (var zipStream = new FileStream($"{outputBaseName}.zip", FileMode.Create))
{
using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
{
foreach (var file in sourceFiles)
{
var entry = archive.CreateEntry(Path.GetFileName(file));
using (var entryStream = entry.Open())
using (var fileStream = File.OpenRead(file))
{
fileStream.CopyTo(entryStream);
if (zipStream.Length > MaxVolumeSize)
{
zipStream.Close();
volumeNumber++;
zipStream = new FileStream(
$"{outputBaseName}.z{volumeNumber.ToString("00")}",
FileMode.Create);
archive = new ZipArchive(zipStream, ZipArchiveMode.Create);
}
}
}
}
}
}
}
public class SecureZipCreator
{
public void CreatePasswordProtectedZip(string[] files, string outputPath, string password)
{
using (var outputMemStream = new MemoryStream())
{
using (var zipStream = new ZipOutputStream(outputMemStream))
{
zipStream.Password = password;
zipStream.SetLevel(9); // Maximum compression
foreach (var file in files)
{
var entry = new ZipEntry(Path.GetFileName(file))
entry.DateTime = DateTime.Now;
zipStream.PutNextEntry(entry);
using (var fileStream = File.OpenRead(file))
{
fileStream.CopyTo(zipStream);
}
zipStream.CloseEntry();
}
}
File.WriteAllBytes(outputPath, outputMemStream.ToArray());
}
}
}
public async Task CreateZipAsync(IEnumerable<string> files, string outputPath)
{
using (var zipArchive = ZipFile.Open(outputPath, ZipArchiveMode.Create))
{
var tasks = files.Select(file => Task.Run(() =>
{
var entry = zipArchive.CreateEntry(Path.GetFileName(file));
using (var entryStream = entry.Open())
using (var fileStream = new FileStream(file, FileMode.Open))
{
return fileStream.CopyToAsync(entryStream);
}
}));
await Task.WhenAll(tasks);
}
}
public void CreateLargeZipWithLowMemory(string[] files, string outputPath)
{
using (var zipStream = new FileStream(outputPath, FileMode.Create))
{
using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
{
foreach (var file in files)
{
var entry = archive.CreateEntry(Path.GetFileName(file));
using (var entryStream = entry.Open())
using (var fileStream = new FileStream(
file,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
bufferSize: 4096,
FileOptions.SequentialScan))
{
fileStream.CopyTo(entryStream);
}
}
}
}
}
public class SafeZipCreator
{
private readonly ILogger _logger;
public SafeZipCreator(ILogger logger)
{
_logger = logger;
}
public bool TryCreateZip(string[] files, string outputPath)
{
try
{
using (var zipArchive = ZipFile.Open(outputPath, ZipArchiveMode.Create))
{
foreach (var file in files)
{
try
{
if (!File.Exists(file))
{
_logger.LogWarning($"File not found: {file}");
continue;
}
zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
_logger.LogDebug($"Added {file} to archive");
}
catch (UnauthorizedAccessException ex)
{
_logger.LogError(ex, $"Access denied for file: {file}");
}
catch (IOException ex)
{
_logger.LogError(ex, $"IO error processing file: {file}");
}
}
}
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to create zip archive");
if (File.Exists(outputPath))
{
File.Delete(outputPath);
}
return false;
}
}
}
[ApiController]
[Route("api/[controller]")]
public class DownloadController : ControllerBase
{
[HttpPost("zip")]
public async Task<IActionResult> DownloadAsZip([FromBody] string[] filePaths)
{
var tempFileName = Path.GetTempFileName() + ".zip";
try
{
using (var zipArchive = ZipFile.Open(tempFileName, ZipArchiveMode.Create))
{
foreach (var filePath in filePaths)
{
if (System.IO.File.Exists(filePath))
{
zipArchive.CreateEntryFromFile(
filePath,
Path.GetFileName(filePath));
}
}
}
var memoryStream = new MemoryStream();
using (var fileStream = new FileStream(tempFileName, FileMode.Open))
{
await fileStream.CopyToAsync(memoryStream);
}
memoryStream.Position = 0;
return File(memoryStream, "application/zip", "download.zip");
}
finally
{
if (System.IO.File.Exists(tempFileName))
{
System.IO.File.Delete(tempFileName);
}
}
}
}
public class BackupService : IHostedService, IDisposable
{
private Timer _timer;
private readonly ILogger<BackupService> _logger;
private readonly BackupConfig _config;
public BackupService(ILogger<BackupService> logger, IOptions<BackupConfig> config)
{
_logger = logger;
_config = config.Value;
}
public Task StartAsync(CancellationToken cancellationToken)
{
_timer = new Timer(DoBackup, null, TimeSpan.Zero,
TimeSpan.FromHours(_config.IntervalHours));
return Task.CompletedTask;
}
private void DoBackup(object state)
{
try
{
var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var backupFile = Path.Combine(
_config.BackupDirectory,
$"backup_{timestamp}.zip");
ZipFile.CreateFromDirectory(
_config.SourceDirectory,
backupFile,
CompressionLevel.Optimal,
includeBaseDirectory: true);
_logger.LogInformation($"Created backup: {backupFile}");
// Cleanup old backups
var oldBackups = Directory.GetFiles(_config.BackupDirectory, "backup_*.zip")
.OrderBy(f => f)
.SkipLast(_config.RetentionCount);
foreach (var oldBackup in oldBackups)
{
File.Delete(oldBackup);
_logger.LogInformation($"Deleted old backup: {oldBackup}");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Backup failed");
}
}
public Task StopAsync(CancellationToken cancellationToken)
{
_timer?.Change(Timeout.Infinite, 0);
return Task.CompletedTask;
}
public void Dispose()
{
_timer?.Dispose();
}
}
[TestClass]
public class ZipCreatorTests
{
private string _testDir;
private string[] _testFiles;
[TestInitialize]
public void Setup()
{
_testDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(_testDir);
_testFiles = new[]
{
Path.Combine(_testDir, "file1.txt"),
Path.Combine(_testDir, "file2.txt"),
Path.Combine(_testDir, "file3.txt")
};
foreach (var file in _testFiles)
{
File.WriteAllText(file, Guid.NewGuid().ToString());
}
}
[TestMethod]
public void CreateZip_WithValidFiles_CreatesZipWithAllFiles()
{
// Arrange
var outputFile = Path.Combine(_testDir, "test.zip");
var creator = new ZipCreator();
// Act
creator.CreateZip(_testFiles, outputFile);
// Assert
Assert.IsTrue(File.Exists(outputFile));
using (var archive = ZipFile.OpenRead(outputFile))
{
Assert.AreEqual(_testFiles.Length, archive.Entries.Count);
foreach (var file in _testFiles)
{
Assert.IsNotNull(archive.GetEntry(Path.GetFileName(file)));
}
}
}
[TestCleanup]
public void Cleanup()
{
try
{
Directory.Delete(_testDir, true);
}
catch { /* Ignore cleanup errors */ }
}
}
| 方法 | 压缩时间 | 压缩率 | 内存使用 |
|---|---|---|---|
| ZipFile (Optimal) | 1.2s | 65% | 120MB |
| ZipFile (Fastest) | 0.8s | 72% | 80MB |
| SharpZipLib | 1.5s | 60% | 150MB |
| 7z (LZMA) | 2.1s | 55% | 200MB |
| 文件大小 | 原始方法 | 内存优化方法 |
|---|---|---|
| 100MB | 3.2s / 250MB | 3.5s / 50MB |
| 1GB | 32s / 2.5GB | 35s / 60MB |
| 5GB | OutOfMemory | 180s / 70MB |
public class CustomCompressionZipCreator
{
public void CreateZipWithCustomCompression(string[] files, string outputPath)
{
using (var zipStream = new FileStream(outputPath, FileMode.Create))
{
using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
{
foreach (var file in files)
{
var entry = archive.CreateEntry(Path.GetFileName(file));
using (var entryStream = entry.Open())
using (var fileStream = File.OpenRead(file))
using (var customCompressor = new CustomCompressionStream(entryStream))
{
fileStream.CopyTo(customCompressor);
}
}
}
}
}
}
public class CustomCompressionStream : Stream
{
private readonly Stream _innerStream;
public CustomCompressionStream(Stream innerStream)
{
_innerStream = innerStream;
}
// Implement custom compression in Write method
public override void Write(byte[] buffer, int offset, int count)
{
// Custom compression logic here
var compressed = MyCompressionAlgorithm.Compress(buffer, offset, count);
_innerStream.Write(compressed, 0, compressed.Length);
}
// Other required Stream members omitted for brevity
}
// Good - Cross-platform var path = Path.Combine(“temp”, “file.zip”);
2. 文件权限：
```csharp
try
{
File.SetUnixFileMode(zipPath, UnixFileMode.UserRead | UnixFileMode.UserWrite);
}
catch (PlatformNotSupportedException)
{
// Ignore on Windows
}
using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create, options)) { // … }
## 十、总结与最佳实践
### 10.1 最佳实践总结
1. **选择合适的压缩级别**：
- 网络传输：使用最佳压缩(CompressionLevel.Optimal)
- 本地存储：考虑使用快速压缩(CompressionLevel.Fastest)
2. **资源管理**：
```csharp
// Always dispose streams and archives
using (var archive = ZipFile.Open(...))
{
// ...
}
错误处理：
性能考虑：
安全考虑：
var fullPath = Path.GetFullPath(Path.Combine(rootPath, entry.FullName));
if (!fullPath.StartsWith(rootPath))
{
throw new InvalidOperationException("Zip slip attack detected");
}
”`csharp public class AdvancedZipCreator { private readonly ILogger _logger; private readonly ZipCreationOptions _options;
public AdvancedZipCreator(ILogger logger, ZipCreationOptions options)
{
_logger = logger;
_options = options;
}
public async Task<bool> CreateZipAsync(
IEnumerable<string> sourceFiles,
string outputPath,
IProgress<int> progress = null)
{
try
{
var files = sourceFiles.ToArray();
var processed = 0;
using (var zipStream = new FileStream(
outputPath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
bufferSize: 4096,
FileOptions.Asynchronous))
{
using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
{
var options = new ParallelOptions
{
MaxDegreeOfParallelism = _options.MaxParallelism
};
await Parallel.ForEachAsync(files, options, async (file, ct) =>
{
try
{
if (!File.Exists(file))
{
_logger.LogWarning($"File not found: {file}");
return;
}
var entryName = _options.PreserveFolderStructure
? file.Substring(_options.BaseDirectory.Length)
: Path.GetFileName(file);
var entry = archive.CreateEntry(entryName, _options.CompressionLevel);
using (var entryStream = entry.Open())
using (var fileStream = new FileStream(
file,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
bufferSize: 4096,
FileOptions.SequentialScan | FileOptions.Asynchronous))
{
await fileStream.CopyToAsync(entryStream);
}
Interlocked.Increment(ref processed);
progress?.Report(processed * 100 / files.Length);
}
catch (Exception ex) when (
ex is UnauthorizedAccessException ||
ex is IOException)
{
_logger.LogError(ex, $"Failed to process file: {file}");
}
});
}
}
_logger.LogInformation($"Created zip archive: {outputPath}");
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, $"Failed to create zip archive: {outputPath}");
try { File.Delete(outputPath); } catch { }
return false;
}
}
}
public class ZipCreationOptions { public CompressionLevel CompressionLevel { get; set; } = CompressionLevel.Optimal; public int MaxParallelism { get; set; } = Environment.ProcessorCount; public bool PreserveFolderStructure { get; set; } public
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。