How to Zip and Unzip Files in C#: A Complete Guide

File compression is an essential skill for any C# developer. Whether you're creating backups, reducing storage space, or preparing files for transmission, knowing how to zip and unzip files programmatically can streamline your applications.

This guide walks you through the process using C#'s built-in System.IO.Compression namespace.

Prerequisites

Before getting started, ensure you have:

  • Visual Studio or your preferred C# IDE
  • .NET Framework 4.5 or later
  • Basic understanding of C# file operations

Creating Zip Files in C#

The System.IO.Compression namespace provides the ZipFile and ZipArchive classes for handling zip operations. Here's how to create a zip file:

using System.IO.Compression;

// Create a zip file from a directory
ZipFile.CreateFromDirectory(@"C:\SourceFolder", @"C:\output.zip");

// Create a zip file with custom settings
using (var zipArchive = ZipFile.Open(@"C:\custom.zip", ZipArchiveMode.Create))
{
    zipArchive.CreateEntryFromFile(@"C:\file1.txt", "file1.txt");
    zipArchive.CreateEntryFromFile(@"C:\file2.pdf", "file2.pdf");
}

Extracting Zip Files

Unzipping files is just as straightforward:

// Extract all files to a directory
ZipFile.ExtractToDirectory(@"C:\archive.zip", @"C:\ExtractedFolder");

// Extract specific files
using (var archive = ZipFile.OpenRead(@"C:\archive.zip"))
{
    foreach (var entry in archive.Entries)
    {
        if (entry.Name.EndsWith(".txt"))
        {
            entry.ExtractToFile(Path.Combine(@"C:\ExtractedFolder", entry.Name));
        }
    }
}

Best Practices and Tips

  1. Always use 'using' statements when working with ZipArchive objects to ensure proper resource disposal.
  2. Handle exceptions appropriately, as file operations can fail due to permissions or file access issues.
  3. Check available disk space before extracting large zip files.
  4. Consider using compression levels for optimal file size versus speed trade-offs.

Advanced Features

The System.IO.Compression namespace offers additional features:

// Set compression level
using (var archive = ZipFile.Open(@"C:\compressed.zip", ZipArchiveMode.Create))
{
    archive.CreateEntryFromFile(@"C:\largefile.dat", "largefile.dat", CompressionLevel.Optimal);
}

// Update existing zip files
using (var archive = ZipFile.Open(@"C:\existing.zip", ZipArchiveMode.Update))
{
    archive.CreateEntryFromFile(@"C:\newfile.txt", "newfile.txt");
}

Common Issues and Solutions

  • File Access Errors: Ensure files aren't in use by other processes before zipping/unzipping.
  • Path Too Long: Use shorter file paths or enable long path support in Windows.
  • Out of Memory: Process large files in chunks rather than loading entirely into memory.

Conclusion

Mastering zip operations in C# enables you to create more efficient applications that handle file compression seamlessly. The System.IO.Compression namespace provides all the tools needed for basic to advanced zip operations, making it easy to implement file compression in your C# projects.

Remember to always test your zip operations thoroughly and implement proper error handling to ensure robust file compression functionality in your applications.

3
661

Related

When working with URLs in C#, encoding is essential to ensure that special characters (like spaces, ?, &, and =) don’t break the URL structure. The recommended way to encode a string for a URL is by using Uri.EscapeDataString(), which converts unsafe characters into their percent-encoded equivalents.

string rawText = "hello world!";
string encodedText = Uri.EscapeDataString(rawText);

Console.WriteLine(encodedText); // Output: hello%20world%21

This method encodes spaces as %20, making it ideal for query parameters.

For ASP.NET applications, you can also use HttpUtility.UrlEncode() (from System.Web), which encodes spaces as +:

using System.Web;

string encodedText = HttpUtility.UrlEncode("hello world!");
Console.WriteLine(encodedText); // Output: hello+world%21

For .NET Core and later, Uri.EscapeDataString() is the preferred choice.

27
1119

Reading a file line by line is useful when handling large files without loading everything into memory at once.

✅ Best Practice: Use File.ReadLines() which is more memory efficient.

Example

foreach (string line in File.ReadLines("file.txt"))
{
    Console.WriteLine(line);
}

Why use ReadLines()?

Reads one line at a time, reducing overall memory usage. Ideal for large files (e.g., logs, CSVs).

Alternative: Use StreamReader (More Control)

For scenarios where you need custom processing while reading the contents of the file:

using (StreamReader reader = new StreamReader("file.txt"))
{
    string? line;
    while ((line = reader.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

Why use StreamReader?

Lets you handle exceptions, encoding, and buffering. Supports custom processing (e.g., search for a keyword while reading).

When to Use ReadAllLines()? If you need all lines at once, use:

string[] lines = File.ReadAllLines("file.txt");

Caution: Loads the entire file into memory—avoid for large files!

3
291

In C#, you can format an integer with commas (thousands separator) using ToString with a format specifier.

int number = 1234567;
string formattedNumber = number.ToString("N0"); // "1,234,567"
Console.WriteLine(formattedNumber);

Explanation:

"N0": The "N" format specifier stands for Number, and "0" means no decimal places. The output depends on the culture settings, so in regions where , is the decimal separator, you might get 1.234.567.

Alternative:

You can also specify culture explicitly if you need a specific format:

using System.Globalization;

int number = 1234567;
string formattedNumber = number.ToString("N0", CultureInfo.InvariantCulture);
Console.WriteLine(formattedNumber); // "1,234,567"
3
411