【C#】DotNetZipで簡単ファイル圧縮・解凍：基本操作と便利テクニック

dotnet add package DotNetZip

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        // 新しいZipFileインスタンスを生成
        using (ZipFile zip = new ZipFile())
        {
            // ここにファイルやフォルダーの追加処理を記述
            Console.WriteLine("ZipFileインスタンスを生成しました。");
        }
    }
}

ZipFileインスタンスを生成しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            // ファイルをルートに追加
            zip.AddFile(@"C:\Example\File1.txt", "");
            // ファイルを"Documents"フォルダーに追加
            zip.AddFile(@"C:\Example\File2.docx", "Documents");
            // ZIPファイルを保存
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("ファイルを追加して圧縮しました。");
        }
    }
}

ファイルを追加して圧縮しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            // フォルダーを"Backup"フォルダーとして追加
            zip.AddDirectory(@"C:\Example\Data", "Backup");
            // ZIPファイルを保存
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("フォルダーを追加して圧縮しました。");
        }
    }
}

フォルダーを追加して圧縮しました。

using Ionic.Zip;
using Ionic.Zlib;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            zip.AddFile(@"C:\Example\File1.txt", "");
            // 圧縮レベルを最高圧縮に設定
            zip.CompressionLevel = CompressionLevel.BestCompression;
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("最高圧縮レベルで圧縮しました。");
        }
    }
}

最高圧縮レベルで圧縮しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        try
        {
            // ZIPファイルを読み込む
            using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
            {
                Console.WriteLine("ZIPファイルを読み込みました。");
                // ZIP内のファイル一覧を表示
                foreach (ZipEntry entry in zip)
                {
                    Console.WriteLine($"ファイル名: {entry.FileName}, サイズ: {entry.UncompressedSize} バイト");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

ZIPファイルを読み込みました。
ファイル名: File1.txt, サイズ: 1024 バイト
ファイル名: Documents/File2.docx, サイズ: 20480 バイト

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        try
        {
            string extractPath = @"C:\Example\Extract";
            using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
            {
                foreach (ZipEntry entry in zip)
                {
                    // 解凍先にファイルを展開(既存ファイルは上書き)
                    entry.Extract(extractPath, ExtractExistingFileAction.OverwriteSilently);
                    Console.WriteLine($"解凍しました: {entry.FileName}");
                }
            }
            Console.WriteLine("すべてのファイルを解凍しました。");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

解凍しました: File1.txt
解凍しました: Documents/File2.docx
すべてのファイルを解凍しました。

entry.Extract(extractPath, ExtractExistingFileAction.OverwriteIfNewer);

using Ionic.Zip;
using System;
using System.Text;
class Program
{
    static void Main()
    {
        try
        {
            using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
            {
                // 文字コードをUTF-8に設定
                zip.AlternateEncoding = Encoding.UTF8;
                zip.AlternateEncodingUsage = ZipOption.Always;
                foreach (ZipEntry entry in zip)
                {
                    Console.WriteLine($"ファイル名: {entry.FileName}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            // "C:\Example\Data"フォルダーをそのまま階層構造を保持して圧縮
            zip.AddDirectory(@"C:\Example\Data");
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("フォルダーを階層構造を保持して圧縮しました。");
        }
    }
}

フォルダーを階層構造を保持して圧縮しました。

zip.AddDirectory(@"C:\Example\Data", "BackupData");

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            // "Data"フォルダーの中身をZIPのルートに追加(ルート除外)
            zip.AddDirectory(@"C:\Example\Data", "");
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("フォルダーの中身をルートに追加しました。");
        }
    }
}

フォルダーの中身をルートに追加しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            // ファイルをZIPの"Docs"フォルダーに格納
            zip.AddFile(@"C:\Example\Data\File1.txt", "Docs");
            // ファイルをZIPのルートに格納
            zip.AddFile(@"C:\Example\Data\File2.txt", "");
            zip.Save(@"C:\Example\Archive.zip");
            Console.WriteLine("ファイルを相対パスで格納しました。");
        }
    }
}

ファイルを相対パスで格納しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        try
        {
            using (ZipFile zip = new ZipFile())
            {
                // パスワードを設定
                zip.Password = "securepassword";
                // AES-256暗号化を有効にする
                zip.Encryption = EncryptionAlgorithm.WinZipAes256;
                // ファイルを追加
                zip.AddFile(@"C:\Example\SecretDocument.txt", "");
                // ZIPファイルを保存
                zip.Save(@"C:\Example\EncryptedArchive.zip");
                Console.WriteLine("AES-256で暗号化したZIPファイルを作成しました。");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

AES-256で暗号化したZIPファイルを作成しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            zip.Password = "securepassword";
            // ファイルを追加し、個別に暗号化設定
            ZipEntry entry1 = zip.AddFile(@"C:\Example\File1.txt", "");
            entry1.Encryption = EncryptionAlgorithm.WinZipAes256;
            ZipEntry entry2 = zip.AddFile(@"C:\Example\File2.txt", "");
            entry2.Encryption = EncryptionAlgorithm.None; // 暗号化しない
            zip.Save(@"C:\Example\MixedEncryption.zip");
            Console.WriteLine("ファイルごとに暗号化設定を行いました。");
        }
    }
}

ファイルごとに暗号化設定を行いました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            zip.Password = "password123";
            // 互換性重視のZipCrypto暗号化
            zip.Encryption = EncryptionAlgorithm.PkzipWeak;
            zip.AddFile(@"C:\Example\File.txt", "");
            zip.Save(@"C:\Example\ZipCryptoEncrypted.zip");
            Console.WriteLine("ZipCryptoで暗号化したZIPファイルを作成しました。");
        }
    }
}

ZipCryptoで暗号化したZIPファイルを作成しました。

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        Console.Write("圧縮ファイルのパスワードを入力してください: ");
        string password = Console.ReadLine();
        try
        {
            using (ZipFile zip = new ZipFile())
            {
                zip.Password = password;
                zip.Encryption = EncryptionAlgorithm.WinZipAes256;
                zip.AddFile(@"C:\Example\SensitiveData.txt", "");
                zip.Save(@"C:\Example\PasswordProtected.zip");
                Console.WriteLine("パスワード保護されたZIPファイルを作成しました。");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

圧縮ファイルのパスワードを入力してください: mysecret
パスワード保護されたZIPファイルを作成しました。

using Ionic.Zip;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        using (MemoryStream ms = new MemoryStream())
        {
            using (ZipFile zip = new ZipFile())
            {
                // メモリ上に圧縮データを作成
                zip.AddEntry("Hello.txt", "こんにちは、世界！"); // 文字列をファイルとして追加
                zip.Save(ms);
            }
            // メモリストリームの位置を先頭に戻す
            ms.Position = 0;
            Console.WriteLine($"メモリ上に圧縮データを作成しました。サイズ: {ms.Length} バイト");
            // 必要に応じてバイト配列として取得可能
            byte[] zipBytes = ms.ToArray();
            Console.WriteLine($"バイト配列の長さ: {zipBytes.Length}");
        }
    }
}

メモリ上に圧縮データを作成しました。サイズ: 123 バイト
バイト配列の長さ: 123

using Ionic.Zip;
using System;
using System.IO;
using System.Net.Sockets;
class Program
{
    static void Main()
    {
        string serverIp = "127.0.0.1";
        int port = 9000;
        try
        {
            using (TcpClient client = new TcpClient(serverIp, port))
            using (NetworkStream netStream = client.GetStream())
            using (ZipFile zip = new ZipFile())
            {
                // 圧縮ファイルを作成
                zip.AddEntry("Data.txt", "ネットワーク経由で送信する圧縮データです。");
                // NetworkStreamに直接書き出す
                zip.Save(netStream);
                Console.WriteLine("圧縮データをネットワークストリームに送信しました。");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"通信エラー: {ex.Message}");
        }
    }
}

圧縮データをネットワークストリームに送信しました。

using Ionic.Zip;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        byte[] compressedData;
        using (MemoryStream ms = new MemoryStream())
        {
            using (ZipFile zip = new ZipFile())
            {
                zip.AddEntry("Report.csv", "日付,売上,利益\n2024-06-01,10000,3000");
                zip.Save(ms);
            }
            compressedData = ms.ToArray();
        }
        Console.WriteLine($"圧縮データのバイト配列を取得しました。サイズ: {compressedData.Length} バイト");
        // ここでcompressedDataをデータベースのBLOBカラムに保存可能
    }
}

圧縮データのバイト配列を取得しました。サイズ: 85 バイト

using Ionic.Zip;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        // 例としてcompressedDataは前述の圧縮データ
        byte[] compressedData = /* データベースから取得したバイト配列 */ null;
        if (compressedData == null)
        {
            Console.WriteLine("圧縮データがありません。");
            return;
        }
        using (MemoryStream ms = new MemoryStream(compressedData))
        using (ZipFile zip = ZipFile.Read(ms))
        {
            foreach (ZipEntry entry in zip)
            {
                using (MemoryStream extracted = new MemoryStream())
                {
                    entry.Extract(extracted);
                    extracted.Position = 0;
                    using (StreamReader reader = new StreamReader(extracted))
                    {
                        string content = reader.ReadToEnd();
                        Console.WriteLine($"ファイル名: {entry.FileName}");
                        Console.WriteLine("内容:");
                        Console.WriteLine(content);
                    }
                }
            }
        }
    }
}

using Ionic.Zip;
using System;
class Program
{
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            zip.AddFile(@"C:\Example\File1.txt", "");
            zip.AddFile(@"C:\Example\File2.txt", "");
            // SaveProgressイベントにハンドラーを登録
            zip.SaveProgress += Zip_SaveProgress;
            zip.Save(@"C:\Example\Archive.zip");
        }
    }
    private static void Zip_SaveProgress(object sender, SaveProgressEventArgs e)
    {
        if (e.EventType == ZipProgressEventType.Saving_EntryBytesRead)
        {
            // 全体の進捗率を計算(エントリ単位)
            int totalEntries = e.EntriesTotal;
            int savedEntries = e.EntriesSaved;
            // 現在処理中のエントリの読み込み進捗(0～100%)
            double currentEntryProgress = 0;
            if (e.CurrentEntry != null && e.CurrentEntry.UncompressedSize > 0)
            {
                currentEntryProgress = (double)e.BytesTransferred / e.CurrentEntry.UncompressedSize;
            }
            // 全体の進捗率(エントリ単位＋現在のエントリの進捗を加味)
            double overallProgress = (savedEntries + currentEntryProgress) / totalEntries * 100;
            Console.WriteLine($"圧縮進捗: {overallProgress:F2}%");
        }
    }
}

圧縮進捗: 0.00%
圧縮進捗: 10.50%
圧縮進捗: 50.00%
圧縮進捗: 100.00%

using Ionic.Zip;
using System;
class Program
{
    static bool cancelRequested = false;
    static void Main()
    {
        using (ZipFile zip = new ZipFile())
        {
            zip.AddFile(@"C:\Example\File1.txt", "");
            zip.AddFile(@"C:\Example\File2.txt", "");
            zip.SaveProgress += Zip_SaveProgress;
            // 別スレッドやUIからキャンセル要求を受け付ける想定
            // ここでは簡単にコンソール入力でキャンセルを模擬
            Console.WriteLine("圧縮処理中。キャンセルするには 'c' を入力してください。");
            // キャンセル監視スレッドを起動
            System.Threading.Thread cancelThread = new System.Threading.Thread(() =>
            {
                if (Console.ReadLine()?.ToLower() == "c")
                {
                    cancelRequested = true;
                }
            });
            cancelThread.Start();
            try
            {
                zip.Save(@"C:\Example\Archive.zip");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"処理がキャンセルされました: {ex.Message}");
            }
        }
    }
    private static void Zip_SaveProgress(object sender, SaveProgressEventArgs e)
    {
        if (cancelRequested)
        {
            e.Cancel = true;
            Console.WriteLine("キャンセル要求を受け付けました。");
        }
    }
}

圧縮処理中。キャンセルするには 'c' を入力してください。
キャンセル要求を受け付けました。
処理がキャンセルされました: 圧縮処理がユーザーにより中断されました。

using Ionic.Zip;
using System;
using System.Threading.Tasks;
using System.Windows.Forms;
public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
    }
    private async void btnCompress_Click(object sender, EventArgs e)
    {
        progressBar1.Value = 0;
        await Task.Run(() =>
        {
            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(@"C:\Example\File1.txt", "");
                zip.AddFile(@"C:\Example\File2.txt", "");
                zip.SaveProgress += (s, ev) =>
                {
                    if (ev.EventType == ZipProgressEventType.Saving_EntryBytesRead)
                    {
                        int totalEntries = ev.EntriesTotal;
                        int savedEntries = ev.EntriesSaved;
                        double currentEntryProgress = 0;
                        if (ev.CurrentEntry != null && ev.CurrentEntry.UncompressedSize > 0)
                        {
                            currentEntryProgress = (double)ev.BytesTransferred / ev.CurrentEntry.UncompressedSize;
                        }
                        double overallProgress = (savedEntries + currentEntryProgress) / totalEntries * 100;
                        // UIスレッドに進捗を反映
                        progressBar1.Invoke(new Action(() =>
                        {
                            progressBar1.Value = (int)overallProgress;
                        }));
                    }
                };
                zip.Save(@"C:\Example\Archive.zip");
            }
        });
        MessageBox.Show("圧縮が完了しました。");
    }
}

using Ionic.Zip;
using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        Console.WriteLine("圧縮処理を開始します。");
        try
        {
            await CompressAsync(@"C:\Example\Archive.zip", new string[]
            {
                @"C:\Example\File1.txt",
                @"C:\Example\File2.txt"
            });
            Console.WriteLine("圧縮処理が完了しました。");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
    static Task CompressAsync(string zipPath, string[] files)
    {
        return Task.Run(() =>
        {
            using (ZipFile zip = new ZipFile())
            {
                foreach (var file in files)
                {
                    zip.AddFile(file, "");
                }
                zip.Save(zipPath);
            }
        });
    }
}

圧縮処理を開始します。
圧縮処理が完了しました。

using Ionic.Zip;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        var jobs = new List<(string zipPath, string[] files)>
        {
            (@"C:\Example\Archive1.zip", new[] { @"C:\Example\FileA.txt" }),
            (@"C:\Example\Archive2.zip", new[] { @"C:\Example\FileB.txt", @"C:\Example\FileC.txt" }),
            (@"C:\Example\Archive3.zip", new[] { @"C:\Example\FileD.txt" })
        };
        var tasks = new List<Task>();
        foreach (var job in jobs)
        {
            tasks.Add(Task.Run(() =>
            {
                using (ZipFile zip = new ZipFile())
                {
                    foreach (var file in job.files)
                    {
                        zip.AddFile(file, "");
                    }
                    zip.Save(job.zipPath);
                    Console.WriteLine($"{job.zipPath} の圧縮が完了しました。");
                }
            }));
        }
        await Task.WhenAll(tasks);
        Console.WriteLine("すべての圧縮処理が完了しました。");
    }
}

C:\Example\Archive1.zip の圧縮が完了しました。
C:\Example\Archive2.zip の圧縮が完了しました。
C:\Example\Archive3.zip の圧縮が完了しました。
すべての圧縮処理が完了しました。

using Ionic.Zip;
using System;
using System.Threading.Tasks;
using System.Windows;
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }
    private async void btnCompress_Click(object sender, RoutedEventArgs e)
    {
        btnCompress.IsEnabled = false;
        progressBar.Value = 0;
        lblStatus.Content = "圧縮中...";
        try
        {
            await Task.Run(() =>
            {
                using (ZipFile zip = new ZipFile())
                {
                    zip.AddFile(@"C:\Example\File1.txt", "");
                    zip.AddFile(@"C:\Example\File2.txt", "");
                    zip.SaveProgress += (s, ev) =>
                    {
                        if (ev.EventType == Ionic.Zip.ZipProgressEventType.Saving_EntryBytesRead)
                        {
                            double progress = (ev.EntriesSaved + (double)ev.BytesTransferred / ev.CurrentEntry.UncompressedSize) / ev.EntriesTotal * 100;
                            Dispatcher.Invoke(() =>
                            {
                                progressBar.Value = progress;
                                lblStatus.Content = $"圧縮進捗: {progress:F1}%";
                            });
                        }
                    };
                    zip.Save(@"C:\Example\Archive.zip");
                }
            });
            lblStatus.Content = "圧縮が完了しました。";
        }
        catch (Exception ex)
        {
            lblStatus.Content = $"エラー: {ex.Message}";
        }
        finally
        {
            btnCompress.IsEnabled = true;
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        try
        {
            using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
            {
                zip.ExtractAll(@"C:\Example\Extract", ExtractExistingFileAction.OverwriteSilently);
                Console.WriteLine("解凍が完了しました。");
            }
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine($"ファイルが見つかりません: {ex.Message}");
        }
        catch (BadPasswordException)
        {
            Console.WriteLine("パスワードが間違っています。");
        }
        catch (IOException ex)
        {
            Console.WriteLine($"I/Oエラーが発生しました: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"予期しないエラーが発生しました: {ex.Message}");
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
using System.Threading;
class Program
{
    static void Main()
    {
        int maxRetries = 3;
        int delayMilliseconds = 1000;
        int attempt = 0;
        while (attempt < maxRetries)
        {
            try
            {
                using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
                {
                    zip.ExtractAll(@"C:\Example\Extract", ExtractExistingFileAction.OverwriteSilently);
                    Console.WriteLine("解凍が完了しました。");
                    break; // 成功したらループを抜ける
                }
            }
            catch (IOException ex)
            {
                attempt++;
                Console.WriteLine($"I/Oエラーが発生しました。リトライ {attempt}/{maxRetries} - {ex.Message}");
                if (attempt >= maxRetries)
                {
                    Console.WriteLine("リトライ回数の上限に達しました。処理を中断します。");
                    break;
                }
                Thread.Sleep(delayMilliseconds);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"予期しないエラーが発生しました: {ex.Message}");
                break;
            }
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
class Logger
{
    private static readonly string logFile = @"C:\Example\app.log";
    public static void Log(string message)
    {
        string logEntry = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {message}";
        File.AppendAllText(logFile, logEntry + Environment.NewLine);
    }
}
class Program
{
    static void Main()
    {
        try
        {
            Logger.Log("圧縮処理を開始します。");
            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(@"C:\Example\File1.txt", "");
                zip.Save(@"C:\Example\Archive.zip");
            }
            Logger.Log("圧縮処理が正常に完了しました。");
        }
        catch (Exception ex)
        {
            Logger.Log($"エラー発生: {ex.Message}\n{ex.StackTrace}");
            Console.WriteLine("エラーが発生しました。ログを確認してください。");
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
using Xunit;
public class ZipTests
{
    [Fact]
    public void CompressAndExtract_MemoryStream_Success()
    {
        byte[] compressedData;
        // メモリ上で圧縮
        using (var ms = new MemoryStream())
        {
            using (var zip = new ZipFile())
            {
                zip.AddEntry("test.txt", "テストデータ");
                zip.Save(ms);
            }
            compressedData = ms.ToArray();
        }
        // メモリ上で解凍
        using (var ms = new MemoryStream(compressedData))
        using (var zip = ZipFile.Read(ms))
        {
            var entry = zip["test.txt"];
            using (var extractedStream = new MemoryStream())
            {
                entry.Extract(extractedStream);
                extractedStream.Position = 0;
                using (var reader = new StreamReader(extractedStream))
                {
                    string content = reader.ReadToEnd();
                    Assert.Equal("テストデータ", content);
                }
            }
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
using Xunit;
public class CorruptZipTests
{
    [Fact]
    public void ReadCorruptZip_ThrowsBadReadException()
    {
        // 破損ZIPファイルのパス
        string corruptZipPath = @"C:\Example\corrupt.zip";
        Assert.Throws<Ionic.Zip.BadReadException>(() =>
        {
            using (var zip = ZipFile.Read(corruptZipPath))
            {
                // 読み込み処理
            }
        });
    }
}

using Ionic.Zip;
using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        using (ZipFile zip = new ZipFile())
        {
            zip.AddFile(@"C:\Example\LargeFile.dat", "");
            zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression;
            zip.Save(@"C:\Example\Archive.zip");
        }
        sw.Stop();
        Console.WriteLine($"圧縮処理時間: {sw.ElapsedMilliseconds} ms");
    }
}

using Ionic.Zip;
using System;
using System.IO;
class BackupProgram
{
    static void Main()
    {
        string sourceDir = @"C:\DataToBackup";
        string backupDir = @"D:\Backups";
        string backupFileName = $"Backup_{DateTime.Now:yyyyMMdd}.zip";
        string backupPath = Path.Combine(backupDir, backupFileName);
        try
        {
            Directory.CreateDirectory(backupDir);
            using (ZipFile zip = new ZipFile())
            {
                // フォルダー全体を圧縮
                zip.AddDirectory(sourceDir, "");
                // 圧縮レベルを標準に設定
                zip.CompressionLevel = Ionic.Zlib.CompressionLevel.Default;
                zip.Save(backupPath);
            }
            Console.WriteLine($"バックアップが完了しました: {backupPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"バックアップ中にエラーが発生しました: {ex.Message}");
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
using System.Linq;
class LogCompressor
{
    static void Main()
    {
        string logDir = @"C:\AppLogs";
        string archiveDir = @"C:\AppLogs\Archive";
        Directory.CreateDirectory(archiveDir);
        var oldLogs = Directory.GetFiles(logDir, "*.log")
            .Where(f => File.GetLastWriteTime(f) < DateTime.Now.AddDays(-7))
            .ToList();
        if (oldLogs.Count == 0)
        {
            Console.WriteLine("圧縮対象の古いログファイルはありません。");
            return;
        }
        string archiveName = $"Logs_{DateTime.Now:yyyyMMddHHmmss}.zip";
        string archivePath = Path.Combine(archiveDir, archiveName);
        try
        {
            using (ZipFile zip = new ZipFile())
            {
                foreach (var logFile in oldLogs)
                {
                    zip.AddFile(logFile, "");
                }
                zip.Save(archivePath);
            }
            // 圧縮後に元のログファイルを削除
            foreach (var logFile in oldLogs)
            {
                File.Delete(logFile);
            }
            Console.WriteLine($"古いログを圧縮し、元ファイルを削除しました: {archivePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"ログ圧縮中にエラーが発生しました: {ex.Message}");
        }
    }
}

using Ionic.Zip;
using System;
using System.IO;
using System.Net.Sockets;
class NetworkSender
{
    static void Main()
    {
        string fileToSend = @"C:\LargeData\BigFile.dat";
        string serverIp = "192.168.1.100";
        int port = 9000;
        try
        {
            using (TcpClient client = new TcpClient(serverIp, port))
            using (NetworkStream netStream = client.GetStream())
            using (ZipFile zip = new ZipFile())
            {
                zip.AddFile(fileToSend, "");
                zip.Save(netStream);
            }
            Console.WriteLine("圧縮データをネットワーク経由で送信しました。");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"送信中にエラーが発生しました: {ex.Message}");
        }
    }
}

using System.IO.Compression;
using System.IO;
using (ZipArchive archive = ZipFile.Open("archive.zip", ZipArchiveMode.Create))
{
    archive.CreateEntryFromFile("file.txt", "file.txt", CompressionLevel.Optimal);
}

using ICSharpCode.SharpZipLib.Zip;
using System.IO;
using (FileStream fs = File.Create("archive.zip"))
using (ZipOutputStream zipStream = new ZipOutputStream(fs))
{
    zipStream.SetLevel(9); // 圧縮レベル設定
    var entry = new ZipEntry("file.txt");
    zipStream.PutNextEntry(entry);
    using (FileStream fileStream = File.OpenRead("file.txt"))
    {
        fileStream.CopyTo(zipStream);
    }
    zipStream.CloseEntry();
}

int retryCount = 3;
int delayMs = 1000;
for (int i = 0; i < retryCount; i++)
{
    try
    {
        using (ZipFile zip = ZipFile.Read(@"C:\Example\Archive.zip"))
        {
            zip.ExtractAll(@"C:\Example\Extract", ExtractExistingFileAction.OverwriteSilently);
        }
        break; // 成功したらループを抜ける
    }
    catch (IOException)
    {
        if (i == retryCount - 1) throw;
        System.Threading.Thread.Sleep(delayMs);
    }
}

zip.AlternateEncoding = System.Text.Encoding.UTF8;
zip.AlternateEncodingUsage = ZipOption.Always;

using (ZipFile zip = new ZipFile())
{
    zip.AlternateEncoding = System.Text.Encoding.UTF8;
    zip.AlternateEncodingUsage = ZipOption.Always;
    zip.AddFile(@"C:\Example\日本語ファイル.txt", "");
    zip.Save(@"C:\Example\Archive.zip");
}

using (FileStream fs = File.OpenRead(@"C:\Example\LargeFile.dat"))
using (FileStream zipFs = File.Create(@"C:\Example\LargeFile.zip"))
using (ZipFile zip = new ZipFile())
{
    zip.AddEntry("LargeFile.dat", fs);
    zip.Save(zipFs);
}