Export (0) Print
Expand All

DeflateStream Class

Provides methods and properties for compressing and decompressing streams using the Deflate algorithm.

Namespace: System.IO.Compression
Assembly: System (in system.dll)

public class DeflateStream : Stream
public class DeflateStream extends Stream
public class DeflateStream extends Stream
Not applicable.

This class represents the Deflate algorithm, an industry standard algorithm for lossless file compression and decompression. It uses a combination of the LZ77 algorithm and Huffman coding. Data can be produced or consumed, even for an arbitrarily long, sequentially presented input data stream, using only previously bound amount of intermediate storage. The format can be implemented readily in a manner not covered by patents. For more information, see RFC 1951. "DEFLATE Compressed Data Format Specification version 1.3." This class cannot be used to compress files larger than 4 GB.

This class does not inherently provide functionality for adding files to or extracting files from .zip archives. For an example of manipulating compressed file archives, see Compression Application Sample.

The GZipStream class uses the gzip data format, which includes a cyclic redundancy check value for detecting data corruption. The gzip data format uses the same compression algorithm as the DeflateStream class.

The compression functionality in DeflateStream and GZipStream is exposed as a stream. Data is read in on a byte-by-byte basis, so it is not possible to perform multiple passes to determine the best method for compressing entire files or large blocks of data. The DeflateStream and GZipStream classes are best used on uncompressed sources of data. If the source data is already compressed, using these classes may actually increase the size of the stream.

The following code example shows how to use the DeflateStream class to compress and decompress a file.

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

public class DeflateTest
{
	public static int ReadAllBytesFromStream(Stream stream, byte[] buffer) 
	{
	// Use this method is used to read all bytes from a stream.
	int offset = 0;
	int totalCount = 0;
		while (true) 
		{
		int bytesRead = stream.Read(buffer, offset, 100); 
			if ( bytesRead == 0) 
			{
			break; 
			}
	offset += bytesRead;
	totalCount += bytesRead; 
		}
	return totalCount;
	} 

	public static bool CompareData(byte[] buf1, int len1, byte[] buf2, int len2) 
	{
		// Use this method to compare data from two different buffers.
		if (len1 != len2) 
		{ 
		Console.WriteLine("Number of bytes in two buffer are different {0}:{1}", len1, len2);
		return false;
		}

		for ( int i= 0; i< len1; i++) 
		{
			if ( buf1[i] != buf2[i]) 
			{
			Console.WriteLine("byte {0} is different {1}|{2}", i, buf1[i], buf2[i]);
			return false;
			}
		}
	Console.WriteLine("All bytes compare.");
	return true; 
	}

	public static void DeflateCompressDecompress(string filename)
	{
	Console.WriteLine("Test compression and decompression on file {0}", filename);
	FileStream infile;
		try
		{
		// Open the file as a FileStream object.
		infile = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
		byte[] buffer = new byte[infile.Length];
		// Read the file to ensure it is readable.
		int count = infile.Read(buffer, 0, buffer.Length);
			if ( count != buffer.Length) 
			{
			infile.Close();
			Console.WriteLine("Test Failed: Unable to read data from file"); 
			return;
			}
		infile.Close();
		MemoryStream ms = new MemoryStream();
		// Use the newly created memory stream for the compressed data.
		DeflateStream compressedzipStream = new DeflateStream(ms , CompressionMode.Compress, true);
		Console.WriteLine("Compression");
		compressedzipStream.Write(buffer, 0, buffer.Length);
		// Close the stream.
		compressedzipStream.Close();
		Console.WriteLine("Original size: {0}, Compressed size: {1}", buffer.Length, ms.Length);

		// Reset the memory stream position to begin decompression.
		ms.Position = 0;
		DeflateStream zipStream = new DeflateStream(ms, CompressionMode.Decompress);
		Console.WriteLine("Decompression");
		byte[] decompressedBuffer = new byte[buffer.Length + 100];
		// Use the ReadAllBytesFromStream to read the stream.
		int totalCount = DeflateTest.ReadAllBytesFromStream(zipStream, decompressedBuffer);
		Console.WriteLine("Decompressed {0} bytes", totalCount);

		if( !DeflateTest.CompareData(buffer, buffer.Length, decompressedBuffer, totalCount) ) 
		{
		Console.WriteLine("Error. The two buffers did not compare.");
		}
	zipStream.Close(); 
		} // end try
		catch (InvalidDataException)
		{
			Console.WriteLine("Error: The file being read contains invalid data.");
		}
		catch (FileNotFoundException)
		{
			Console.WriteLine("Error:The file specified was not found.");
		}
		catch (ArgumentException)
		{
			Console.WriteLine("Error: path is a zero-length string, contains only white space, or contains one or more invalid characters");
		}
		catch (PathTooLongException)
		{
			Console.WriteLine("Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.");
		}
		catch (DirectoryNotFoundException)
		{
			Console.WriteLine("Error: The specified path is invalid, such as being on an unmapped drive.");
		}
		catch (IOException)
		{
			Console.WriteLine("Error: An I/O error occurred while opening the file.");
		}
		catch (UnauthorizedAccessException)
		{
			Console.WriteLine("Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions.");
		}
		catch (IndexOutOfRangeException)
		{
			Console.WriteLine("Error: You must provide parameters for MyGZIP.");
		}
	}
	public static void Main(string[] args)
	{
		string usageText = "Usage: DeflateTest <inputfilename>";
		//If no file name is specified, write usage text.
		if (args.Length == 0)
		{
			Console.WriteLine(usageText);
		}
		else
		{
			if (File.Exists(args[0]))
				DeflateCompressDecompress(args[0]);
		}
	}
}
	

import System.*;
import System.IO.*;
import System.IO.Compression.*;

public class DeflateTest
{
    public static int ReadAllBytesFromStream(Stream stream, ubyte buffer[])
    {
        // Use this method is used to read all bytes from a stream.
        int offSet = 0;
        int totalCount = 0;
        while (true) {
            int bytesRead = stream.Read(buffer, offSet, 100);
            if (bytesRead == 0) {
                break;
            }
            offSet += bytesRead;
            totalCount += bytesRead;
        }
        return totalCount;
    } //ReadAllBytesFromStream

    public static boolean CompareData(ubyte buf1[], int len1, 
        ubyte buf2[], int len2)
    {
        // Use this method to compare data from two different buffers.
        if (len1 != len2) {
            Console.WriteLine("Number of bytes in two buffer are "
                + "different {0}:{1}", System.Convert.ToString(len1), 
                System.Convert.ToString(len2));
            return false;
        }
        for (int i = 0; i < len1; i++) {
            if (!(buf1.get_Item(i).Equals(buf2.get_Item(i)))) {
                Console.WriteLine("byte {0} is different {1}|{2}", 
                    System.Convert.ToString(i), 
                    System.Convert.ToString(buf1.get_Item(i)), 
                    System.Convert.ToString(buf2.get_Item(i)));
                return false;
            }
        }
        Console.WriteLine("All bytes compare.");
        return true;
    } //CompareData

    public static void DeflateCompressDecompress(String fileName)
    {
        Console.WriteLine("Test compression and decompression on file {0}",
            fileName);
        FileStream inFile;
        try {
            // Open the file as a FileStream object.
            inFile = new FileStream(fileName, FileMode.Open, FileAccess.Read, 
                FileShare.Read);
            ubyte buffer[] = new ubyte[(ubyte)inFile.get_Length()];

            // Read the file to ensure it is readable.
            int count = inFile.Read(buffer, 0, buffer.length);
            if (count != buffer.length) {
                inFile.Close();
                Console.WriteLine("Test Failed: Unable to read data from file");
                return;
            }
            inFile.Close();
            MemoryStream ms = new MemoryStream();

            // Use the newly created memory stream for the compressed data.
            DeflateStream compressedZipStream = 
                new DeflateStream(ms, CompressionMode.Compress, true);
            Console.WriteLine("Compression");
            compressedZipStream.Write(buffer, 0, buffer.length);

            // Close the stream.
            compressedZipStream.Close();
            Console.WriteLine("Original size: {0}, Compressed size: {1}", 
                System.Convert.ToString(buffer.length), 
                System.Convert.ToString(ms.get_Length()));

            // Reset the memory stream position to begin decompression.
            ms.set_Position(0);
            DeflateStream zipStream = 
                new DeflateStream(ms, CompressionMode.Decompress);
            Console.WriteLine("Decompression");
            ubyte decompressedBuffer[] = new ubyte[buffer.length + 100];

            // Use the ReadAllBytesFromStream to read the stream.
            int totalCount = DeflateTest.ReadAllBytesFromStream(zipStream, 
                decompressedBuffer);
            Console.WriteLine("Decompressed {0} bytes", 
                System.Convert.ToString(totalCount));

            if (!(DeflateTest.CompareData(buffer, buffer.length, 
                decompressedBuffer, totalCount))) {
                Console.WriteLine("Error. The two buffers did not compare.");
            }
            zipStream.Close();
        } 
        catch (InvalidDataException exp) {
            Console.WriteLine("Error: The file being read contains"
                + " invalid data.");
        }
        catch (FileNotFoundException exp) {
            Console.WriteLine("Error:The file specified was not found.");
        }
        catch (ArgumentException exp) {
            Console.WriteLine("Error: path is a zero-length string, contains"
                + " only white space, or contains one or more "
                + "invalid characters");
        }
        catch (PathTooLongException exp) {
            Console.WriteLine("Error: The specified path, file name, or both"
                + " exceed the system-defined maximum length. For example, "
                + "on Windows-based platforms, paths must be less than 248 "
                + "characters, and file names must be less than 260 "
                + "characters.");
        }
        catch (DirectoryNotFoundException exp) {
            Console.WriteLine("Error: The specified path is invalid, such"
                + " as being on an unmapped drive.");
        }
        catch (IOException exp) {
            Console.WriteLine("Error: An I/O error occurred while "
                + "opening the file.");
        }
        catch (UnauthorizedAccessException exp) {
            Console.WriteLine("Error: path specified a file that is read-only,"
                + " the path is a directory, or caller does not have the"
                + " required permissions.");
        }
        catch (IndexOutOfRangeException exp) {
            Console.WriteLine("Error: You must provide parameters for MyGZIP.");
        }
    } //DeflateCompressDecompress

    public static void main(String[] args)
    {
        String usageText = "Usage: DeflateTest <inputfilename>";

        //If no file name is specified, write usage text.
        if (args.length == 0) {
            Console.WriteLine(usageText);
        }
        else {
            if (File.Exists(args[0])) {
                DeflateCompressDecompress(args[0]);
            }
        }
    } //main
} //DeflateTest

System.Object
   System.MarshalByRefObject
     System.IO.Stream
      System.IO.Compression.DeflateStream

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0

Community Additions

ADD
Show:
© 2014 Microsoft