Better Data Transmission Using Compressed Streams in .NET

The Need for Data Compression

As web-based applications have increased, so has the need for faster connectivity and more bandwidth. The main reason? Data transmitted over networks is becoming voluminous, leading to high traffic. This can result in poor application performance and lower productivity.

To address this issue, data compression technology can save space and bandwidth significantly. .NET supports this feature by introducing classes that implement compression technology.

Compression Methods in .NET

The .NET framework offers compression and decompression services as part of its File Input/Output (I/O) system. Two methods of compression techniques are available: GZip and Deflate. Both adopt industry-standard compression algorithms and are free of patent protection. They can compress data up to a maximum size of 4GB.

The only difference between the methods is that GZip allows header information that can be used when decompressing the zip file with the popular gzip tool. For compression and decompression within your application, use Deflate since the compressed data is smaller due to its lack of header information.

GZipStream and DeflateStream Classes

The .NET framework provides two classes—GZipStream and DeflateStream—to implement lossless compression and decompression. Unlike other stream classes, these take in data like any other stream and write compressed data into another stream instead of writing to a file or memory.

Both classes have properties like the underlying BaseStream, timeout for read/write operations, and support for seeking. They also have methods to perform sequential reads (single or specified number of bytes) and write bytes. To use these classes, include the System.IO.Compression namespace.

The compression format includes a cyclic redundancy check value for verifying data integrity. Since compression executes by reading data byte-by-byte, it's not possible to perform multiple passes to determine the best compression method. Use compression on uncompressed data, not on already-compressed files. Make sure you have sufficient access rights to operate on the file system before executing the code.

Compressing Streams

Here are the steps to compress a stream:

• Create two FileStream objects: one for the source and one for the destination
• Create an instance of GZipStream by specifying the destination file and compression mode
• Traverse the source file byte by byte and pass each byte to the GZipStream object for compression
• Close both files

using System;
using System.IO;
using System.IO.Compression;

public class CompressionExample
{
    public static void CompressFile(string sourceFile, string destinationFile)
    {
        FileStream sourceFileObj = File.OpenRead(sourceFile);
        FileStream desFileObj = File.Create(destinationFile);
        
        GZipStream compressedStreamObj = new GZipStream(
            desFileObj, 
            CompressionMode.Compress
        );
        
        int aByte = sourceFileObj.ReadByte();
        while (aByte != -1)
        {
            compressedStreamObj.WriteByte((byte)aByte);
            aByte = sourceFileObj.ReadByte();
        }
        
        compressedStreamObj.Close();
        sourceFileObj.Close();
        desFileObj.Close();
        
        Console.WriteLine("Compression completed successfully!");
    }
}

Decompressing Streams

Here are the steps to decompress a stream:

• Create two FileStream objects: one for the source and one for the destination
• Create an instance of GZipStream by specifying the source file and decompression mode
• Traverse the compressed stream byte by byte and write the decompressed form directly into the destination file
• Close both files

using System;
using System.IO;
using System.IO.Compression;

public class DecompressionExample
{
    public static void DecompressFile(string sourceFile, string destinationFile)
    {
        FileStream sourceFileObj = File.OpenRead(sourceFile);
        FileStream desFileObj = File.Create(destinationFile);
        
        GZipStream compressedStreamObj = new GZipStream(
            sourceFileObj, 
            CompressionMode.Decompress
        );
        
        int aByte = compressedStreamObj.ReadByte();
        while (aByte != -1)
        {
            desFileObj.WriteByte((byte)aByte);
            aByte = compressedStreamObj.ReadByte();
        }
        
        compressedStreamObj.Close();
        sourceFileObj.Close();
        desFileObj.Close();
        
        Console.WriteLine("Decompression completed successfully!");
    }
}

Improved Implementation with Using Statements

Here's a more efficient approach using using statements for proper resource disposal:

using System;
using System.IO;
using System.IO.Compression;

public class BetterCompressionExample
{
    public static void CompressFile(string sourceFile, string destFile)
    {
        using (FileStream sourceStream = File.OpenRead(sourceFile))
        using (FileStream destStream = File.Create(destFile))
        using (GZipStream compressor = new GZipStream(destStream, CompressionMode.Compress))
        {
            sourceStream.CopyTo(compressor);
        }
        
        FileInfo sourceInfo = new FileInfo(sourceFile);
        FileInfo destInfo = new FileInfo(destFile);
        
        double ratio = (1 - ((double)destInfo.Length / sourceInfo.Length)) * 100;
        Console.WriteLine($"Compression complete. Size reduced by {ratio:F2}%");
    }
    
    public static void DecompressFile(string sourceFile, string destFile)
    {
        using (FileStream sourceStream = File.OpenRead(sourceFile))
        using (FileStream destStream = File.Create(destFile))
        using (GZipStream decompressor = new GZipStream(sourceStream, CompressionMode.Decompress))
        {
            decompressor.CopyTo(destStream);
        }
        
        Console.WriteLine("Decompression complete!");
    }
}

Using DeflateStream

The code for both compression and decompression remains the same when using DeflateStream, except you replace GZipStream with DeflateStream during stream creation:

using System.IO.Compression;

// Use DeflateStream instead of GZipStream
using (FileStream sourceStream = File.OpenRead(sourceFile))
using (FileStream destStream = File.Create(destFile))
using (DeflateStream compressor = new DeflateStream(destStream, CompressionMode.Compress))
{
    sourceStream.CopyTo(compressor);
}

Important Notes

• Stream wrapping: The compression stream wraps the stream containing (or that will contain) compressed data
• Namespace requirement: Include System.IO.Compression namespace with a using statement at the top
• Maximum size: Both methods support files up to 4GB
• Use on uncompressed data: Compression works best on uncompressed data, not already-compressed files
• File permissions: Ensure you have sufficient access rights to operate on the file system
• Data integrity: The compression format includes cyclic redundancy checks for verifying data hasn't been corrupted

Key Takeaways

Using compressed streams in .NET provides an efficient way to reduce bandwidth usage and improve application performance. By understanding when to use GZipStream versus DeflateStream, and following best practices for stream management, you can significantly optimize data transmission in your applications. Remember to use compression on uncompressed data for best results, and always ensure proper resource disposal with using statements.