ComponentOne Zip for .NET 2.0
In This Topic
    Compress Files to .NET Streams
    In This Topic

    C1Zip allows the user to compress individual files into compressed .NET streams (not zip files) on the disk. This is highly useful when the user wants to compress all files in an application directory.

    UI with buttons

    The Zip library provides medium-level classes like C1ZStreamWriter class and C1ZStreamReader class to use data compression on any .NET streams, not only in zip files.

    Medium-level Classes Description
    C1ZStreamWriter class

    It compresses data into .NET Streams. This can be done by creating a C1ZStreamWriter object passing the stream to the C1ZStreamWriter constructor.
    C1ZStreamReader class

    It decompresses data from .NET streams. This can be done by creating a C1ZStreamReader object and passing the compressed stream to the C1ZStreamReader constructor.

    The flow-diagram below illustrates how these classes work:

    The image depicts a flowchart of Zip library classes.

    Now that you got an idea about the medium-level classes in C1Zip library, let's see how we can compress and decompress files on .NET streams using the classes.

    Set up Application

    1. Start a new Visual Studio project and from the Toolbox, add two Button controls along the left edge and label control along the right edge of the form, as shown in the snapshot in the beginning of the tutorial.

    2. In the Properties window make the following changes:

      Button Button.Text Property Button.Name Property Button.Enabled Property
      1 Compress Files btnCompress True (Default)
      2 Expand Files btnExpand False

      Note that the Expand Files button cannot be used until we have some compressed files to expand. The Label control will display statistics about the compression/expanding process.

    For WPF applications, open the MainWindow.xaml and replace the existing XAML with the following code.

    XAML
    Copy Code 
    <Window x:Class="FilestoStreams_WPFCSharp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:FilestoStreams_WPFCSharp"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid HorizontalAlignment="Left" Width="792">
        <Button x:Name="btnCompress" Content="Compress Files" HorizontalAlignment="Left" Height="49" Margin="50,60,0,0" VerticalAlignment="Top" Width="219" Click="BtnCompress_Click"/>
        <Button x:Name="btnExpand" Content="Expand Files" HorizontalAlignment="Left" Height="48" Margin="50,271,0,0" VerticalAlignment="Top" Width="219" IsEnabled="False" Click="BtnExpand_Click"/>
        <Label x:Name="label1" Content="" HorizontalAlignment="Left" Height="259" Margin="328,60,0,0" VerticalAlignment="Top" Width="395"/>
    </Grid>
</Window>

    Define Directory Names

    Add a reference to the C1.Zip assembly. Define the directory names for the compressed and expanded files.

    This is the C# Code for defining directory names in WinForms applications:

    C#
    Copy Code 
    // compress all files in the demo directory to a new "compressed" directory
private const string DIR_COMP = @"\compressed";
private const string DIR_EXP = @"\expanded";

    This is the VB Code for defining directory names in WinForms applications:

    VB
    Copy Code 
    ' compress all files in the demo directory to a new "compressed" directory
Private Const DIR_COMP As String = "\compressed"
Private Const DIR_EXP As String = "\expanded"

    This is the C# code for defining directory names in WPF applications:

    C#
    Copy Code 
    // compress all files in the demo directory to a new "compressed" directory
        private const string DIR_COMP = @"\compressed";
        private const string DIR_EXP = @"\expanded";

    This is the VB code for defining directory names in WPF applications:

    VB
    Copy Code 
    ' Compress all files in the demo directory to a new "compressed" directory
    Private Const DIR_COMP As String = "\compressed"
    Private Const DIR_EXP As String = "\expanded"

    Compress Files

    1. Add the following code to handle the Click event for the Compress Files button:

      This is the C# Code for compressing files to .NET streams in WinForms applications:

      C#
      Copy Code 
      private void btnCompress_Click(object sender, EventArgs e)
{
    // get application directory
    string path = Application.ExecutablePath;
    int i = path.IndexOf(@"\bin\");
    if (i > 0) path = path.Substring(0, i);

    // create directory for compressed files
    if (Directory.Exists(path + DIR_COMP))
        Directory.Delete(path + DIR_COMP, true);
    Directory.CreateDirectory(path + DIR_COMP);

    // prepare to collect compression statistics
    long count = 0;
    long size = 0;
    long sizeCompressed = 0;
    long ticks = DateTime.Now.Ticks;

    // compress all files in application dir into compressed dir
    string[] files = Directory.GetFiles(path);
    foreach (string srcFile in files)
    {
        // compress file
        string dstFile = path + DIR_COMP + "\\" + Path.GetFileName(srcFile) + ".cmp";
        CompressFile(dstFile, srcFile);

        // update stats
        count++;
        size += new FileInfo(srcFile).Length;
        sizeCompressed += new FileInfo(dstFile).Length;
    }

    // show stats
    string msg = string.Format(
        "Compressed {0} files in {1} ms.\r\n" +
        "Original size:   {2:#,###}\r\n" +
        "Compressed size: {3:#,###} ({4:0.00}% of original)",
        count,
        (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
        size, sizeCompressed,
        (sizeCompressed / (double)size) * 100.0);
    label1.Text = msg;
}

      This is the VB Code for compressing files to .NET streams in WinForms applications:

      VB
      Copy Code 
      Private Sub btnCompress_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnCompress.Click
    ' get application directory
    Dim appPath As String = Application.ExecutablePath
    Dim i As Integer = appPath.IndexOf("\bin\")
    If i > 0 Then appPath = appPath.Substring(0, i)
    ' create directory for compressed files
    If (Directory.Exists(appPath + DIR_COMP)) Then
        Directory.Delete(appPath + DIR_COMP, True)
    End If
    Directory.CreateDirectory(appPath + DIR_COMP)
    ' prepare to collect compression statistics
    Dim count As Long
    Dim size As Long
    Dim sizeCompressed As Long
    Dim ticks As Long = DateTime.Now.Ticks
    ' compress all files in application dir into compressed dir
    Dim files As String() = Directory.GetFiles(appPath)
    Dim srcFile As String
    For Each srcFile In files
        ' compress file
        Dim dstFile As String = appPath + DIR_COMP + "\" + Path.GetFileName(srcFile) + ".cmp"
        CompressFile(dstFile, srcFile)
        ' update stats
        count = count + 1
        size = size + New FileInfo(srcFile).Length
        sizeCompressed = sizeCompressed + New FileInfo(dstFile).Length
    Next
    ' show stats
    Dim msg As String = String.Format(
            "Compressed {0} files in {1} ms." & vbCrLf &
            "Original size:   {2:#,###}" & vbCrLf &
            "Compressed size: {3:#,###} ({4:0.00}% of original)",
            count,
            (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
            size, sizeCompressed,
            (sizeCompressed / size) * 100.0)
    label1.Text = msg
    ' now we can expand
    btnExpand.Enabled = True
End Sub

      This is the C# code for compressing files to .NET streams in WPF applications:

      C#
      Copy Code 
      private void BtnCompress_Click(object sender, RoutedEventArgs e)
{
    // Get the application directory.   
    string appPath = Environment.CurrentDirectory;
    int i = appPath.IndexOf(@"\bin\");
    if (i > 0)
        appPath = appPath.Substring(0, i);
    // Create a directory for compressed files.   
    if ((Directory.Exists(appPath + DIR_COMP)))
        Directory.Delete(appPath + DIR_COMP, true);
    Directory.CreateDirectory(appPath + DIR_COMP);
    // Prepare to collect compression statistics.   
    long count = 0;
    long size = 0;
    long sizeCompressed = 0;
    long ticks = DateTime.Now.Ticks;
    // Compress all files in the application dir into the compressed dir.  
    foreach (string srcFile in Directory.GetFiles(appPath))
    {
        string dstFile = appPath + DIR_COMP + @"\" + System.IO.Path.GetFileName(srcFile) + ".cmp";
        // Compress file.       
        CompressFile(dstFile, srcFile);
        // Update stats.       
        count++;
        size += new FileInfo(srcFile).Length;
        sizeCompressed += new FileInfo(dstFile).Length;
    }
    // Show stats.   
    string msg = string.Format("Compressed {0} files in {1} ms.\n\r" + "Original size:   {2:#,###}\n\r" +
        "Compressed size: {3:#,###} ({4:0.00}% of original)", count,
        (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond, size,
        sizeCompressed, (sizeCompressed * 100.0 / size));
    label1.Content = msg;
    // Now we can expand.   
    btnExpand.IsEnabled = true;
}

      This is the VB code for compressing files to .NET streams in WPF applications:

      VB
      Copy Code 
      Private Sub BtnCompress_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Get the application directory.   
    Dim appPath As String = Environment.CurrentDirectory
    Dim i As Integer = appPath.IndexOf("\bin\")
    If i > 0 Then appPath = appPath.Substring(0, i)
    ' create directory for compressed files
    If (Directory.Exists(appPath + DIR_COMP)) Then
        Directory.Delete(appPath + DIR_COMP, True)
    End If
    Directory.CreateDirectory(appPath + DIR_COMP)
    ' prepare to collect compression statistics
    Dim count As Long
    Dim size As Long
    Dim sizeCompressed As Long
    Dim ticks As Long = DateTime.Now.Ticks
    ' compress all files in application dir into compressed dir
    Dim files As String() = Directory.GetFiles(appPath)
    Dim srcFile As String
    For Each srcFile In files
        ' compress file
        Dim dstFile As String = appPath + DIR_COMP + "\" + Path.GetFileName(srcFile) + ".cmp"
        CompressFile(dstFile, srcFile)
        ' update stats
        count = count + 1
        size = size + New FileInfo(srcFile).Length
        sizeCompressed = sizeCompressed + New FileInfo(dstFile).Length
    Next
    ' show stats
    Dim msg As String = String.Format(
            "Compressed {0} files in {1} ms." & vbCrLf &
            "Original size:   {2:#,###}" & vbCrLf &
            "Compressed size: {3:#,###} ({4:0.00}% of original)",
            count,
            (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
            size, sizeCompressed,
            (sizeCompressed / size) * 100.0)
    label1.Content = msg
    ' now we can expand
    btnExpand.IsEnabled = True
End Sub

    2. Add the code for CompressFile method. The main line calls the utility function CompressFile method to compress each selected file. The compressed files are stored in the \compressed directory under the application folder. They have the same name as the original file, plus a CMP extension. The function starts by creating two new file streams: one for the source file and the other for the compressed file. Then it creates a C1ZStreamWriter object and attaches it to the destination stream.

      This is the C# Code for compressing files in WinForms applications:

      C#
      Copy Code 
      private static bool CompressFile(string dstFile, string srcFile)
{
    // prepare to compress file
    bool retval = true;
    FileStream srcStream = null;
    FileStream dstStream = null;
    try
    {
        // open the files
        srcStream = new FileStream(srcFile, FileMode.Open, FileAccess.Read);
        dstStream = new FileStream(dstFile, FileMode.Create, FileAccess.Write);

        // open compressor stream on destination file
        C1ZStreamWriter sw = new C1ZStreamWriter(dstStream);

        // copy source into compressor stream
        StreamCopy(sw, srcStream);
    }
    catch // exception? tell caller we failed
    {
        retval = false;
    }
    finally // always close our streams
    {
        if (srcStream != null) srcStream.Close();
        if (dstStream != null) dstStream.Close();
    }

    // done
    return retval;
}

      This is the VB Code for compressing files in WinForms applications:

      VB
      Copy Code 
      Private Function CompressFile(ByVal dstFile As String, ByVal srcFile As String) As Boolean
    ' prepare to compress file
    Dim retval As Boolean = True
    Dim srcStream As FileStream = Nothing
    Dim dstStream As FileStream = Nothing
    Try
        ' open the files
        srcStream = New FileStream(srcFile, FileMode.Open, FileAccess.Read)
        dstStream = New FileStream(dstFile, FileMode.Create, FileAccess.Write)
        ' open compressor stream on destination file
        Dim sw As C1ZStreamWriter = New C1ZStreamWriter(dstStream)
        ' copy source into compressor stream
        StreamCopy(sw, srcStream)
    Catch ' exception? tell caller we failed
        retval = False
    Finally ' always close our streams
        If Not (srcStream Is Nothing) Then srcStream.Close()
        If Not (dstStream Is Nothing) Then dstStream.Close()
    End Try
    ' done
    CompressFile = False
End Function

      This is the C# code for compressing files in WPF applications:

      C#
      Copy Code 
      private bool CompressFile(string dstFile, string srcFile)
{
    FileStream srcStream = null;
    FileStream dstStream = null;
    try
    {
        // Open the files.   
        srcStream = new FileStream(srcFile, FileMode.Open, FileAccess.Read);
        dstStream = new FileStream(dstFile, FileMode.Create, FileAccess.Write);
        // Open a compressor stream on the destination file.       
        C1ZStreamWriter sw = new C1ZStreamWriter(dstStream);
        // Copy the source into the compressor stream.       
        StreamCopy(sw, srcStream);
    }
    catch
    {
    }
    finally
    {
        // Always close our streams.       
        if (srcStream != null)
            srcStream.Close();
        if (dstStream != null)
            dstStream.Close();
    }
    // Done.   
    return false;
}

      This is the VB code for compressing files in WPF applications:

      VB
      Copy Code 
      Private Function CompressFile(ByVal dstFile As String, ByVal srcFile As String) As Boolean
    ' prepare to compress file
    Dim retval As Boolean = True
    Dim srcStream As FileStream = Nothing
    Dim dstStream As FileStream = Nothing
    Try
        ' open the files
        srcStream = New FileStream(srcFile, FileMode.Open, FileAccess.Read)
        dstStream = New FileStream(dstFile, FileMode.Create, FileAccess.Write)

        ' open compressor stream on destination file
        Dim sw As C1ZStreamWriter = New C1ZStreamWriter(dstStream)

        ' copy source into compressor stream
        StreamCopy(sw, srcStream)
    Catch ' exception? tell caller we failed
        retval = False
    Finally ' always close our streams
        If Not (srcStream Is Nothing) Then srcStream.Close()
        If Not (dstStream Is Nothing) Then dstStream.Close()
    End Try
    ' done
    CompressFile = False
End Function

    3. Add the code for StreamCopy function. It transfers data from the source file and write it into the compressor stream. To put it simply, the StreamCopy function simply copies bytes from one stream to another. 

      This is the C# Code for compressing files in WinForms applications:

      C#
      Copy Code 
      private static void StreamCopy(Stream dstStream, Stream srcStream)
{
    byte[] buffer = new byte[32768];
    int read;
    while ((read = srcStream.Read(buffer, 0, buffer.Length)) != 0)
        dstStream.Write(buffer, 0, read);
    dstStream.Flush();
}

      This is the VB Code for compressing files in WinForms applications:

      VB
      Copy Code 
      Private Sub StreamCopy(ByVal dstStream As Stream, ByVal srcStream As Stream)
    Dim buffer(32768) As Byte
    Dim read As Integer
    Do
        read = srcStream.Read(buffer, 0, buffer.Length)
        If read = 0 Then Exit Do
        dstStream.Write(buffer, 0, read)
    Loop
    dstStream.Flush()
End Sub

      This is the C# code for compressing files in WPF applications:

      C#
      Copy Code 
      private static void StreamCopy(Stream dstStream, Stream srcStream)
{
    byte[] buffer = new byte[32768];
    int read;
    while ((read = srcStream.Read(buffer, 0, buffer.Length)) != 0)
        dstStream.Write(buffer, 0, read);
    dstStream.Flush();
}

      This is the VB code for compressing files in WPF applications:

      VB
      Copy Code 
      Private Shared Sub StreamCopy(ByVal dstStream As Stream, ByVal srcStream As Stream)
    Dim buffer(32768) As Byte
    Dim read As Integer
    Do
        read = srcStream.Read(buffer, 0, buffer.Length)
        If read = 0 Then Exit Do
        dstStream.Write(buffer, 0, read)
    Loop
    dstStream.Flush()
End Sub

      Note that the function calls the Flush method after it is done to ensure that any cached data is written out when the function is done copying. This is especially important when dealing with compressed streams, since they cache substantial amounts of data in order to achieve good compression rates.

    Decompress Files

    1. Add the following code to handle the Click event for the Expand Files button:

      This is the C# Code for decompressing files in WinForms applications:

      C#
      Copy Code 
      private void btnExpand_Click(object sender, EventArgs e)
{
    // get application directory
    string path = Application.ExecutablePath;
    int i = path.IndexOf(@"\bin\");
    if (i > 0) path = path.Substring(0, i);

    // create directory for expanded files
    if (Directory.Exists(path + DIR_EXP))
        Directory.Delete(path + DIR_EXP, true);
    Directory.CreateDirectory(path + DIR_EXP);

    // prepare to collect compression statistics
    long count = 0;
    long size = 0;
    long sizeExpanded = 0;
    long ticks = DateTime.Now.Ticks;

    // expand all files in "compressed" dir to "expanded" dir
    string[] files = Directory.GetFiles(path + DIR_COMP);
    foreach (string srcFile in files)
    {
        // expand file
        string dstFile = path + DIR_EXP + "\\" + Path.GetFileName(srcFile);
        dstFile = dstFile.Replace(".cmp", "");
        ExpandFile(dstFile, srcFile);

        // update stats
        count++;
        size += new FileInfo(srcFile).Length;
        sizeExpanded += new FileInfo(dstFile).Length;
    }

    // show stats
    string msg = string.Format(
        "Expanded {0} files in {1} ms.\r\n" +
        "Original size:   {2:#,###}\r\n" +
        "Expanded size: {3:#,###} ({4:0.00} x size of compressed)",
        count,
        (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
        size, sizeExpanded,
        sizeExpanded / (double)size);
    label1.Text = msg;
}

      This is the VB Code for decompressing files in WinForms applications:

      VB
      Copy Code 
      Private Sub btnExpand_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnExpand.Click
    ' get application directory
    Dim appPath As String = Application.ExecutablePath
    Dim i As Integer = appPath.IndexOf("\bin\")
    If i > 0 Then appPath = appPath.Substring(0, i)
    ' create directory for expanded files
    If Directory.Exists(appPath + DIR_EXP) Then
        Directory.Delete(appPath + DIR_EXP, True)
    End If
    Directory.CreateDirectory(appPath + DIR_EXP)
    ' prepare to collect compression statistics
    Dim count As Long
    Dim size As Long
    Dim sizeExpanded As Long
    Dim ticks As Long = DateTime.Now.Ticks
    ' expand all files in "compressed" dir to "expanded" dir
    Dim srcFile As String
    Dim files As String() = Directory.GetFiles(appPath + DIR_COMP)
    For Each srcFile In files
        ' expand file
        Dim dstFile As String = appPath + DIR_EXP + "\" + Path.GetFileName(srcFile)
        dstFile = dstFile.Replace(".cmp", "")
        ExpandFile(dstFile, srcFile)
        ' update stats
        count = count + 1
        size = size + New FileInfo(srcFile).Length
        sizeExpanded = sizeExpanded + New FileInfo(dstFile).Length
    Next
    ' show stats
    Dim msg As String = String.Format(
            "Expanded {0} files in {1} ms." & vbCrLf &
            "Original size:   {2:#,###}" & vbCrLf &
            "Expanded size: {3:#,###} ({4:0.00} x size of compressed)",
            count,
            (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
            size, sizeExpanded,
            sizeExpanded / size)
    label1.Text = msg
End Sub

      This is the C# code for decompressing files in WPF applications:

      C#
      Copy Code 
      private void BtnExpand_Click(object sender, RoutedEventArgs e)
{
    // Get the application directory.   
    string appPath = Environment.CurrentDirectory;
    int i = appPath.IndexOf(@"\bin\");
    if (i > 0) appPath = appPath.Substring(0, i);
    // Create a directory for expanded files.   
    if (Directory.Exists(appPath + DIR_EXP))
        Directory.Delete(appPath + DIR_EXP, true);
    Directory.CreateDirectory(appPath + DIR_EXP);
    // Prepare to collect compression statistics.   
    long count = 0;
    long size = 0;
    long sizeExpanded = 0;
    long ticks = DateTime.Now.Ticks;
    // Expand all files in the "compressed" dir to the "expanded" dir.   
    foreach (string srcFile in Directory.GetFiles(appPath + DIR_COMP))
    {
        // Expand file.       
        string dstFile = appPath + DIR_EXP + @"\" + System.IO.Path.GetFileName(srcFile);
        dstFile = dstFile.Replace(".cmp", "");
        ExpandFile(dstFile, srcFile);
        // Update stats. 
        count++;
        size += new FileInfo(srcFile).Length;
        sizeExpanded += new FileInfo(dstFile).Length;
    }
    // Show stats.   
    string msg = string.Format("Expanded {0} files in {1} ms.\r\n" + "Original size:   {2:#,###}\r\n" + "Expanded size: {3:#,###} ({4:0.00} x size of compressed)", count, (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond, size, sizeExpanded, sizeExpanded / size);
    label1.Content = msg;
}

      This is the VB code for decompressing files in WPF applications:

      VB
      Copy Code 
      Private Sub BtnExpand_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' get application directory
    Dim appPath As String = Environment.CurrentDirectory
    Dim i As Integer = appPath.IndexOf("\bin\")
    If i > 0 Then appPath = appPath.Substring(0, i)
    ' create directory for expanded files
    If Directory.Exists(appPath + DIR_EXP) Then
        Directory.Delete(appPath + DIR_EXP, True)
    End If
    Directory.CreateDirectory(appPath + DIR_EXP)
    ' prepare to collect compression statistics
    Dim count As Long
    Dim size As Long
    Dim sizeExpanded As Long
    Dim ticks As Long = DateTime.Now.Ticks
    ' expand all files in "compressed" dir to "expanded" dir
    Dim srcFile As String
    Dim files As String() = Directory.GetFiles(appPath + DIR_COMP)
    For Each srcFile In files
        ' expand file
        Dim dstFile As String = appPath + DIR_EXP + "\" + Path.GetFileName(srcFile)
        dstFile = dstFile.Replace(".cmp", "")
        ExpandFile(dstFile, srcFile)
        ' update stats
        count = count + 1
        size = size + New FileInfo(srcFile).Length
        sizeExpanded = sizeExpanded + New FileInfo(dstFile).Length
    Next
    ' show stats
    Dim msg As String = String.Format(
            "Expanded {0} files in {1} ms." & vbCrLf &
            "Original size:   {2:#,###}" & vbCrLf &
            "Expanded size: {3:#,###} ({4:0.00} x size of compressed)",
            count,
            (DateTime.Now.Ticks - ticks) / TimeSpan.TicksPerMillisecond,
            size, sizeExpanded,
            sizeExpanded / size)
    label1.Content = msg
End Sub

    2. Add the ExpandFile method. The main line calls the utility function ExpandFile utility method to expand the files that were compressed earlier. The expanded files are stored in the \expanded directory under the application folder. They have the same name as the original file, minus the CMP extension. This function is similar to CompressFile, except that it attaches a C1ZStreamReader to the source stream instead of attaching a C1ZStreamWriter to the destination stream.

      This is the C# Code for decompressing files in WinForms applications:

      C#
      Copy Code 
      private static bool ExpandFile(string dstFile, string srcFile)
{
    // prepare to expand file
    bool retval = true;
    FileStream srcStream = null;
    FileStream dstStream = null;
    try
    {
        // open the files
        srcStream = new FileStream(srcFile, FileMode.Open, FileAccess.Read);
        dstStream = new FileStream(dstFile, FileMode.Create, FileAccess.Write);

        // open expander stream on compressed source
        C1ZStreamReader sr = new C1ZStreamReader(srcStream);

        // copy expander stream into destination file
        StreamCopy(dstStream, sr);
    }
    catch // exception? tell caller we failed
    {
        retval = false;
    }
    finally // always close our streams
    {
        if (srcStream != null) srcStream.Close();
        if (dstStream != null) dstStream.Close();
    }

    // done
    return retval;
}

      This is the VB Code for decompressing files in WinForms applications:

      VB
      Copy Code 
      Private Function ExpandFile(ByVal dstFile As String, ByVal srcFile As String) As Boolean
    ' prepare to expand file
    Dim retval As Boolean = True
    Dim srcStream As FileStream = Nothing
    Dim dstStream As FileStream = Nothing
    Try
        ' open the files
        srcStream = New FileStream(srcFile, FileMode.Open, FileAccess.Read)
        dstStream = New FileStream(dstFile, FileMode.Create, FileAccess.Write)
        ' open expander stream on compressed source
        Dim sr As C1ZStreamReader = New C1ZStreamReader(srcStream)
        ' copy expander stream into destination file
        StreamCopy(dstStream, sr)
    Catch ' exception? tell caller we failed
        retval = False
    Finally ' always close our streams
        If Not (srcStream Is Nothing) Then srcStream.Close()
        If Not (dstStream Is Nothing) Then dstStream.Close()
    End Try
    ' done
    ExpandFile = retval
End Function

      This is the C# code for decompressing files in WPF applications:

      C#
      Copy Code 
      private bool ExpandFile(string dstFile, string srcFile)
{
    // Prepare to expand file.   
    bool retval = true;
    FileStream srcStream = null;
    FileStream dstStream = null;
    try
    {
        // Open the files.       
        srcStream = new FileStream(srcFile, FileMode.Open, FileAccess.Read);
        dstStream = new FileStream(dstFile, FileMode.Create, FileAccess.Write);
        // Open an expander stream on the compressed source.      
        C1ZStreamReader sr = new C1ZStreamReader(srcStream);
        // Copy the expander stream into the destination file.     
        StreamCopy(dstStream, sr);
    }
    catch
    {
        // Exception? Tell the caller we failed.
        retval = false;
    }
    finally
    {
        // Always close our streams.   
        if (srcStream != null)
            srcStream.Close();
        if (dstStream != null)
            dstStream.Close();
    }
    // Done.   
    return retval;
}

      This is the VB code for decompressing files in WPF applications:

      VB
      Copy Code 
      Private Function ExpandFile(ByVal dstFile As String, ByVal srcFile As String) As Boolean
    ' prepare to expand file
    Dim retval As Boolean = True
    Dim srcStream As FileStream = Nothing
    Dim dstStream As FileStream = Nothing
    Try
        ' open the files
        srcStream = New FileStream(srcFile, FileMode.Open, FileAccess.Read)
        dstStream = New FileStream(dstFile, FileMode.Create, FileAccess.Write)
        ' open expander stream on compressed source
        Dim sr As C1ZStreamReader = New C1ZStreamReader(srcStream)
        ' copy expander stream into destination file
        StreamCopy(dstStream, sr)
    Catch ' exception? tell caller we failed
        retval = False
    Finally ' always close our streams

        If Not (srcStream Is Nothing) Then srcStream.Close()
        If Not (dstStream Is Nothing) Then dstStream.Close()
    End Try
    ' done
    ExpandFile = retval
End Function

      Now, that you have you completed all the steps, press F5 to run the application.

    See Also
    Serialize and Deserialize Compressed Files
    Password Protecting Zip Files
    Quickstart