SeeShell

2.1

bin/Ionic.Zip.xml

                                <?xml version="1.0"?>

<doc>

    <assembly>

        <name>Ionic.Zip</name>

    </assembly>

    <members>

        <member name="T:Ionic.Zip.ZipEntrySource">

            <summary>

            An enum that specifies the source of the ZipEntry. 

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.None">

            <summary>

            Default value.  Invalid on a bonafide ZipEntry.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.FileSystem">

            <summary>

            The entry was instantiated by calling AddFile() or another method that 

            added an entry from the filesystem.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.Stream">

            <summary>

            The entry was instantiated via <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String)"/> or

            <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)"/> .

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.ZipFile">

            <summary>

            The ZipEntry was instantiated by reading a zipfile.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.WriteDelegate">

            <summary>

            The content for the ZipEntry will be or was provided by the WriteDelegate.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.JitStream">

            <summary>

            The content for the ZipEntry will be obtained from the stream dispensed by the <c>OpenDelegate</c>.

            The entry was instantiated via <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntrySource.ZipOutputStream">

            <summary>

            The content for the ZipEntry will be or was obtained from a <c>ZipOutputStream</c>.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipOutputStream">

             <summary>

               Provides a stream metaphor for generating zip files.

             </summary>

             <remarks>

             <para>

               This class writes zip files, as defined in the <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specification

               for zip files described by PKWare</see>.  The compression for this

               implementation is provided by a managed-code version of Zlib, included with

               DotNetZip in the classes in the Ionic.Zlib namespace.

             </para>

             <para>

               This class provides an alternative programming model to the one enabled by the

               <see cref="T:Ionic.Zip.ZipFile"/> class. Use this when creating zip files, as an

               alternative to the <see cref="T:Ionic.Zip.ZipFile"/> class, when you would like to use a

               <c>Stream</c> type to write the zip file.

             </para>

             <para>

               Both the <c>ZipOutputStream</c> class and the <c>ZipFile</c> class can be used

               to create zip files. Both of them support many of the common zip features,

               including Unicode, different compression levels, and ZIP64.   They provide

               very similar performance when creating zip files.

             </para>

             <para>

               The <c>ZipFile</c> class is generally easier to use than

               <c>ZipOutputStream</c> and should be considered a higher-level interface.  For

               example, when creating a zip file via calls to the <c>PutNextEntry()</c> and

               <c>Write()</c> methods on the <c>ZipOutputStream</c> class, the caller is

               responsible for opening the file, reading the bytes from the file, writing

               those bytes into the <c>ZipOutputStream</c>, setting the attributes on the

               <c>ZipEntry</c>, and setting the created, last modified, and last accessed

               timestamps on the zip entry. All of these things are done automatically by a

               call to <see cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)">ZipFile.AddFile()</see>.

               For this reason, the <c>ZipOutputStream</c> is generally recommended for use

               only when your application emits arbitrary data, not necessarily data from a

               filesystem file, directly into a zip file, and does so using a <c>Stream</c>

               metaphor.

             </para>

             <para>

               Aside from the differences in programming model, there are other

               differences in capability between the two classes.

             </para>

             <list type="bullet">

               <item>

                 <c>ZipFile</c> can be used to read and extract zip files, in addition to

                 creating zip files. <c>ZipOutputStream</c> cannot read zip files. If you want

                 to use a stream to read zip files, check out the <see cref="T:Ionic.Zip.ZipInputStream"/> class.

               </item>

               <item>

                 <c>ZipOutputStream</c> does not support the creation of segmented or spanned

                 zip files.

               </item>

               <item>

                 <c>ZipOutputStream</c> cannot produce a self-extracting archive.

               </item>

             </list>

             <para>

               Be aware that the <c>ZipOutputStream</c> class implements the <see cref="T:System.IDisposable"/> interface.  In order for

               <c>ZipOutputStream</c> to produce a valid zip file, you use use it within

               a using clause (<c>Using</c> in VB), or call the <c>Dispose()</c> method

               explicitly.  See the examples for how to employ a using clause.

             </para>

             <para>

               Also, a note regarding compression performance: On the desktop .NET

               Framework, DotNetZip can use a multi-threaded compression implementation

               that provides significant speed increases on large files, over 300k or so,

               at the cost of increased memory use at runtime.  (The output of the

               compression is almost exactly the same size).  But, the multi-threaded

               approach incurs a performance hit on smaller files. There's no way for the

               ZipOutputStream to know whether parallel compression will be beneficial,

               because the ZipOutputStream does not know how much data you will write

               through the stream.  You may wish to set the <see cref="P:Ionic.Zip.ZipOutputStream.ParallelDeflateThreshold"/> property to zero, if you are compressing

               large files through <c>ZipOutputStream</c>.  This will cause parallel

               compression to be used, always.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.#ctor(System.IO.Stream)">

             <summary>

               Create a ZipOutputStream, wrapping an existing stream.

             </summary>

             <remarks>

             <para>

               The <see cref="T:Ionic.Zip.ZipFile"/> class is generally easier to use when creating

               zip files. The ZipOutputStream offers a different metaphor for creating a

               zip file, based on the <see cref="T:System.IO.Stream"/> class.

             </para>

             </remarks>

             <param name="stream">

             The stream to wrap. It must be writable. This stream will be closed at

             the time the ZipOutputStream is closed.

             </param>

             <example>

               This example shows how to create a zip file, using the

               ZipOutputStream class.

             <code lang="C#">

             private void Zipup()

             {

                 if (filesToZip.Count == 0)

                 {

                     System.Console.WriteLine("Nothing to do.");

                     return;

                 }

                 using (var raw = File.Open(_outputFileName, FileMode.Create, FileAccess.ReadWrite ))

                 {

                     using (var output= new ZipOutputStream(raw))

                     {

                         output.Password = "VerySecret!";

                         output.Encryption = EncryptionAlgorithm.WinZipAes256;

                         foreach (string inputFileName in filesToZip)

                         {

                             System.Console.WriteLine("file: {0}", inputFileName);

                             output.PutNextEntry(inputFileName);

                             using (var input = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write ))

                             {

                                 byte[] buffer= new byte[2048];

                                 int n;

                                 while ((n= input.Read(buffer,0,buffer.Length)) &gt; 0)

                                 {

                                     output.Write(buffer,0,n);

                                 }

                             }

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Private Sub Zipup()

                 Dim outputFileName As String = "XmlData.zip"

                 Dim filesToZip As String() = Directory.GetFiles(".", "*.xml")

                 If (filesToZip.Length = 0) Then

                     Console.WriteLine("Nothing to do.")

                 Else

                     Using raw As FileStream = File.Open(outputFileName, FileMode.Create, FileAccess.ReadWrite)

                         Using output As ZipOutputStream = New ZipOutputStream(raw)

                             output.Password = "VerySecret!"

                             output.Encryption = EncryptionAlgorithm.WinZipAes256

                             Dim inputFileName As String

                             For Each inputFileName In filesToZip

                                 Console.WriteLine("file: {0}", inputFileName)

                                 output.PutNextEntry(inputFileName)

                                 Using input As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)

                                     Dim n As Integer

                                     Dim buffer As Byte() = New Byte(2048) {}

                                     Do While (n = input.Read(buffer, 0, buffer.Length) &gt; 0)

                                         output.Write(buffer, 0, n)

                                     Loop

                                 End Using

                             Next

                         End Using

                     End Using

                 End If

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.#ctor(System.String)">

             <summary>

               Create a ZipOutputStream that writes to a filesystem file.

             </summary>

             <remarks>

               The <see cref="T:Ionic.Zip.ZipFile"/> class is generally easier to use when creating

               zip files. The ZipOutputStream offers a different metaphor for creating a

               zip file, based on the <see cref="T:System.IO.Stream"/> class.

             </remarks>

             <param name="fileName">

               The name of the zip file to create.

             </param>

             <example>

               This example shows how to create a zip file, using the

               ZipOutputStream class.

             <code lang="C#">

             private void Zipup()

             {

                 if (filesToZip.Count == 0)

                 {

                     System.Console.WriteLine("Nothing to do.");

                     return;

                 }

                 using (var output= new ZipOutputStream(outputFileName))

                 {

                     output.Password = "VerySecret!";

                     output.Encryption = EncryptionAlgorithm.WinZipAes256;

                     foreach (string inputFileName in filesToZip)

                     {

                         System.Console.WriteLine("file: {0}", inputFileName);

                         output.PutNextEntry(inputFileName);

                         using (var input = File.Open(inputFileName, FileMode.Open, FileAccess.Read,

                                                      FileShare.Read | FileShare.Write ))

                         {

                             byte[] buffer= new byte[2048];

                             int n;

                             while ((n= input.Read(buffer,0,buffer.Length)) &gt; 0)

                             {

                                 output.Write(buffer,0,n);

                             }

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Private Sub Zipup()

                 Dim outputFileName As String = "XmlData.zip"

                 Dim filesToZip As String() = Directory.GetFiles(".", "*.xml")

                 If (filesToZip.Length = 0) Then

                     Console.WriteLine("Nothing to do.")

                 Else

                     Using output As ZipOutputStream = New ZipOutputStream(outputFileName)

                         output.Password = "VerySecret!"

                         output.Encryption = EncryptionAlgorithm.WinZipAes256

                         Dim inputFileName As String

                         For Each inputFileName In filesToZip

                             Console.WriteLine("file: {0}", inputFileName)

                             output.PutNextEntry(inputFileName)

                             Using input As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)

                                 Dim n As Integer

                                 Dim buffer As Byte() = New Byte(2048) {}

                                 Do While (n = input.Read(buffer, 0, buffer.Length) &gt; 0)

                                     output.Write(buffer, 0, n)

                                 Loop

                             End Using

                         Next

                     End Using

                 End If

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.#ctor(System.IO.Stream,System.Boolean)">

             <summary>

               Create a ZipOutputStream.

             </summary>

             <remarks>

               See the documentation for the <see cref="M:Ionic.Zip.ZipOutputStream.#ctor(System.IO.Stream)">ZipOutputStream(Stream)</see>

               constructor for an example.

             </remarks>

             <param name="stream">

               The stream to wrap. It must be writable.

             </param>

             <param name="leaveOpen">

               true if the application would like the stream

               to remain open after the <c>ZipOutputStream</c> has been closed.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.ToString">

            <summary>Provides a string representation of the instance.</summary>

            <remarks>

              <para>

                This can be useful for debugging purposes.

              </para>

            </remarks>

            <returns>a string representation of the instance.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.ContainsEntry(System.String)">

             <summary>

               Returns true if an entry by the given name has already been written

               to the ZipOutputStream.

             </summary>

             <param name="name">

               The name of the entry to scan for.

             </param>

             <returns>

             true if an entry by the given name has already been written.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write the data from the buffer to the stream.

             </summary>

             <remarks>

               As the application writes data into this stream, the data may be

               compressed and encrypted before being written out to the underlying

               stream, depending on the settings of the <see cref="P:Ionic.Zip.ZipOutputStream.CompressionLevel"/>

               and the <see cref="P:Ionic.Zip.ZipOutputStream.Encryption"/> properties.

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.PutNextEntry(System.String)">

             <summary>

               Specify the name of the next entry that will be written to the zip file.

             </summary>

             <remarks>

             <para>

               Call this method just before calling <see cref="M:Ionic.Zip.ZipOutputStream.Write(System.Byte[],System.Int32,System.Int32)"/>, to

               specify the name of the entry that the next set of bytes written to

               the <c>ZipOutputStream</c> belongs to. All subsequent calls to <c>Write</c>,

               until the next call to <c>PutNextEntry</c>,

               will be inserted into the named entry in the zip file.

             </para>

             <para>

               If the <paramref name="entryName"/> used in <c>PutNextEntry()</c> ends in

               a slash, then the entry added is marked as a directory. Because directory

               entries do not contain data, a call to <c>Write()</c>, before an

               intervening additional call to <c>PutNextEntry()</c>, will throw an

               exception.

             </para>

             <para>

               If you don't call <c>Write()</c> between two calls to

               <c>PutNextEntry()</c>, the first entry is inserted into the zip file as a

               file of zero size.  This may be what you want.

             </para>

             <para>

               Because <c>PutNextEntry()</c> closes out the prior entry, if any, this

               method may throw if there is a problem with the prior entry.

             </para>

             <para>

               This method returns the <c>ZipEntry</c>.  You can modify public properties

               on the <c>ZipEntry</c>, such as <see cref="P:Ionic.Zip.ZipEntry.Encryption"/>, <see cref="P:Ionic.Zip.ZipEntry.Password"/>, and so on, until the first call to

               <c>ZipOutputStream.Write()</c>, or until the next call to

               <c>PutNextEntry()</c>.  If you modify the <c>ZipEntry</c> <em>after</em>

               having called <c>Write()</c>, you may get a runtime exception, or you may

               silently get an invalid zip archive.

             </para>

             </remarks>

             <example>

               This example shows how to create a zip file, using the

               <c>ZipOutputStream</c> class.

             <code>

             private void Zipup()

             {

                 using (FileStream fs raw = File.Open(_outputFileName, FileMode.Create, FileAccess.ReadWrite ))

                 {

                     using (var output= new ZipOutputStream(fs))

                     {

                         output.Password = "VerySecret!";

                         output.Encryption = EncryptionAlgorithm.WinZipAes256;

                         output.PutNextEntry("entry1.txt");

                         byte[] buffer= System.Text.Encoding.ASCII.GetBytes("This is the content for entry #1.");

                         output.Write(buffer,0,buffer.Length);

                         output.PutNextEntry("entry2.txt");  // this will be zero length

                         output.PutNextEntry("entry3.txt");

                         buffer= System.Text.Encoding.ASCII.GetBytes("This is the content for entry #3.");

                         output.Write(buffer,0,buffer.Length);

                     }

                 }

             }

             </code>

             </example>

             <param name="entryName">

               The name of the entry to be added, including any path to be used

               within the zip file.

             </param>

             <returns>

               The ZipEntry created.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.Dispose(System.Boolean)">

             <summary>

             Dispose the stream

             </summary>

             <remarks>

             <para>

               This method writes the Zip Central directory, then closes the stream.  The

               application must call Dispose() (or Close) in order to produce a valid zip file.

             </para>

             <para>

               Typically the application will call <c>Dispose()</c> implicitly, via a <c>using</c>

               statement in C#, or a <c>Using</c> statement in VB.

             </para>

             </remarks>

             <param name="disposing">set this to true, always.</param>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.Flush">

            <summary>

            This is a no-op.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="buffer">ignored</param>

            <param name="offset">ignored</param>

            <param name="count">ignored</param>

            <returns>nothing</returns>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="offset">ignored</param>

            <param name="origin">ignored</param>

            <returns>nothing</returns>

        </member>

        <member name="M:Ionic.Zip.ZipOutputStream.SetLength(System.Int64)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="value">ignored</param>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Password">

             <summary>

               Sets the password to be used on the <c>ZipOutputStream</c> instance.

             </summary>

             <remarks>

             <para>

               When writing a zip archive, this password is applied to the entries, not

               to the zip archive itself. It applies to any <c>ZipEntry</c> subsequently

               written to the <c>ZipOutputStream</c>.

             </para>

             <para>

               Using a password does not encrypt or protect the "directory" of the

               archive - the list of entries contained in the archive.  If you set the

               <c>Password</c> property, the password actually applies to individual

               entries that are added to the archive, subsequent to the setting of this

               property.  The list of filenames in the archive that is eventually created

               will appear in clear text, but the contents of the individual files are

               encrypted.  This is how Zip encryption works.

             </para>

             <para>

               If you set this property, and then add a set of entries to the archive via

               calls to <c>PutNextEntry</c>, then each entry is encrypted with that

               password.  You may also want to change the password between adding

               different entries. If you set the password, add an entry, then set the

               password to <c>null</c> (<c>Nothing</c> in VB), and add another entry, the

               first entry is encrypted and the second is not.

             </para>

             <para>

               When setting the <c>Password</c>, you may also want to explicitly set the <see cref="P:Ionic.Zip.ZipOutputStream.Encryption"/> property, to specify how to encrypt the entries added

               to the ZipFile.  If you set the <c>Password</c> to a non-null value and do not

               set <see cref="P:Ionic.Zip.ZipOutputStream.Encryption"/>, then PKZip 2.0 ("Weak") encryption is used.

               This encryption is relatively weak but is very interoperable. If

               you set the password to a <c>null</c> value (<c>Nothing</c> in VB),

               <c>Encryption</c> is reset to None.

             </para>

             <para>

               Special case: if you wrap a ZipOutputStream around a non-seekable stream,

               and use encryption, and emit an entry of zero bytes, the <c>Close()</c> or

               <c>PutNextEntry()</c> following the entry will throw an exception.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Encryption">

             <summary>

               The Encryption to use for entries added to the <c>ZipOutputStream</c>.

             </summary>

             <remarks>

             <para>

               The specified Encryption is applied to the entries subsequently

               written to the <c>ZipOutputStream</c> instance.

             </para>

             <para>

               If you set this to something other than

               EncryptionAlgorithm.None, you will also need to set the

               <see cref="P:Ionic.Zip.ZipOutputStream.Password"/> to a non-null, non-empty value in

               order to actually get encryption on the entry.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipOutputStream.Password">ZipOutputStream.Password</seealso>

             <seealso cref="P:Ionic.Zip.ZipEntry.Encryption">ZipEntry.Encryption</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CodecBufferSize">

             <summary>

               Size of the work buffer to use for the ZLIB codec during compression.

             </summary>

             <remarks>

               Setting this may affect performance.  For larger files, setting this to a

               larger size may improve performance, but I'm not sure.  Sorry, I don't

               currently have good recommendations on how to set it.  You can test it if

               you like.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Strategy">

             <summary>

               The compression strategy to use for all entries.

             </summary>

             <remarks>

               Set the Strategy used by the ZLIB-compatible compressor, when compressing

               data for the entries in the zip archive. Different compression strategies

               work better on different sorts of data. The strategy parameter can affect

               the compression ratio and the speed of compression but not the correctness

               of the compresssion.  For more information see <see cref="T:Ionic.Zlib.CompressionStrategy"/>.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Timestamp">

             <summary>

               The type of timestamp attached to the ZipEntry.

             </summary>

             <remarks>

               Set this in order to specify the kind of timestamp that should be emitted

               into the zip file for each entry.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CompressionLevel">

             <summary>

               Sets the compression level to be used for entries subsequently added to

               the zip archive.

             </summary>

             <remarks>

              <para>

                Varying the compression level used on entries can affect the

                size-vs-speed tradeoff when compression and decompressing data streams

                or files.

              </para>

              <para>

                As with some other properties on the <c>ZipOutputStream</c> class, like <see cref="P:Ionic.Zip.ZipOutputStream.Password"/>, and <see cref="P:Ionic.Zip.ZipOutputStream.Encryption"/>,

                setting this property on a <c>ZipOutputStream</c>

                instance will cause the specified <c>CompressionLevel</c> to be used on all

                <see cref="T:Ionic.Zip.ZipEntry"/> items that are subsequently added to the

                <c>ZipOutputStream</c> instance.

              </para>

              <para>

                If you do not set this property, the default compression level is used,

                which normally gives a good balance of compression efficiency and

                compression speed.  In some tests, using <c>BestCompression</c> can

                double the time it takes to compress, while delivering just a small

                increase in compression efficiency.  This behavior will vary with the

                type of data you compress.  If you are in doubt, just leave this setting

                alone, and accept the default.

              </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CompressionMethod">

            <summary>

              The compression method used on each entry added to the ZipOutputStream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Comment">

             <summary>

               A comment attached to the zip archive.

             </summary>

             <remarks>

             <para>

               The application sets this property to specify a comment to be embedded

               into the generated zip archive.

             </para>

             <para>

               According to <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see>, the comment is not encrypted, even if there is a

               password set on the zip file.

             </para>

             <para>

               The specification does not describe how to indicate the encoding used

               on a comment string. Many "compliant" zip tools and libraries use

               IBM437 as the code page for comments; DotNetZip, too, follows that

               practice.  On the other hand, there are situations where you want a

               Comment to be encoded with something else, for example using code page

               950 "Big-5 Chinese". To fill that need, DotNetZip will encode the

               comment following the same procedure it follows for encoding

               filenames: (a) if <see cref="P:Ionic.Zip.ZipOutputStream.AlternateEncodingUsage"/> is

               <c>Never</c>, it uses the default encoding (IBM437). (b) if <see cref="P:Ionic.Zip.ZipOutputStream.AlternateEncodingUsage"/> is <c>Always</c>, it always uses the

               alternate encoding (<see cref="P:Ionic.Zip.ZipOutputStream.AlternateEncoding"/>). (c) if <see cref="P:Ionic.Zip.ZipOutputStream.AlternateEncodingUsage"/> is <c>AsNecessary</c>, it uses the

               alternate encoding only if the default encoding is not sufficient for

               encoding the comment - in other words if decoding the result does not

               produce the original string.  This decision is taken at the time of

               the call to <c>ZipFile.Save()</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.EnableZip64">

             <summary>

               Specify whether to use ZIP64 extensions when saving a zip archive.

             </summary>

             <remarks>

             <para>

               The default value for the property is <see cref="F:Ionic.Zip.Zip64Option.Never"/>. <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> is

               safest, in the sense that you will not get an Exception if a

               pre-ZIP64 limit is exceeded.

             </para>

             <para>

               You must set this property before calling <c>Write()</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.OutputUsedZip64">

             <summary>

               Indicates whether ZIP64 extensions were used when saving the zip archive.

             </summary>

             <remarks>

               The value is defined only after the <c>ZipOutputStream</c> has been closed.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.IgnoreCase">

             <summary>

               Whether the ZipOutputStream should use case-insensitive comparisons when

               checking for uniqueness of zip entries.

             </summary>

             <remarks>

               <para>

               Though the zip specification doesn't prohibit zipfiles with duplicate

               entries, Sane zip files have no duplicates, and the DotNetZip library

               cannot create zip files with duplicate entries. If an application attempts

               to call <see cref="M:Ionic.Zip.ZipOutputStream.PutNextEntry(System.String)"/> with a name that duplicates one

               already used within the archive, the library will throw an Exception.

               </para>

               <para>

               This property allows the application to specify whether the

               ZipOutputStream instance considers ordinal case when checking for

               uniqueness of zip entries.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.UseUnicodeAsNecessary">

             <summary>

               Indicates whether to encode entry filenames and entry comments using

               Unicode (UTF-8).

             </summary>

             <remarks>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The

               PKWare zip specification</see> provides for encoding file names and file

               comments in either the IBM437 code page, or in UTF-8.  This flag selects

               the encoding according to that specification.  By default, this flag is

               false, and filenames and comments are encoded into the zip file in the

               IBM437 codepage.  Setting this flag to true will specify that filenames

               and comments that cannot be encoded with IBM437 will be encoded with

               UTF-8.

             </para>

             <para>

               Zip files created with strict adherence to the PKWare specification with

               respect to UTF-8 encoding can contain entries with filenames containing

               any combination of Unicode characters, including the full range of

               characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many other

               alphabets.  However, because at this time, the UTF-8 portion of the PKWare

               specification is not broadly supported by other zip libraries and

               utilities, such zip files may not be readable by your favorite zip tool or

               archiver. In other words, interoperability will decrease if you set this

               flag to true.

             </para>

             <para>

               In particular, Zip files created with strict adherence to the PKWare

               specification with respect to UTF-8 encoding will not work well with

               Explorer in Windows XP or Windows Vista, because Windows compressed

               folders, as far as I know, do not support UTF-8 in zip files.  Vista can

               read the zip files, but shows the filenames incorrectly. Unpacking from

               Windows Vista Explorer will result in filenames that have rubbish

               characters in place of the high-order UTF-8 bytes.

             </para>

             <para>

               Also, zip files that use UTF-8 encoding will not work well with Java

               applications that use the java.util.zip classes, as of v5.0 of the Java

               runtime. The Java runtime does not correctly implement the PKWare

               specification in this regard.

             </para>

             <para>

               As a result, we have the unfortunate situation that "correct" behavior by

               the DotNetZip library with regard to Unicode encoding of filenames during

               zip creation will result in zip files that are readable by strictly

               compliant and current tools (for example the most recent release of the

               commercial WinZip tool); but these zip files will not be readable by

               various other tools or libraries, including Windows Explorer.

             </para>

             <para>

               The DotNetZip library can read and write zip files with UTF8-encoded

               entries, according to the PKware spec.  If you use DotNetZip for both

               creating and reading the zip file, and you use UTF-8, there will be no

               loss of information in the filenames. For example, using a self-extractor

               created by this library will allow you to unpack files correctly with no

               loss of information in the filenames.

             </para>

             <para>

               If you do not set this flag, it will remain false.  If this flag is false,

               the <c>ZipOutputStream</c> will encode all filenames and comments using

               the IBM437 codepage.  This can cause "loss of information" on some

               filenames, but the resulting zipfile will be more interoperable with other

               utilities. As an example of the loss of information, diacritics can be

               lost.  The o-tilde character will be down-coded to plain o.  The c with a

               cedilla (Unicode 0xE7) used in Portugese will be downcoded to a c.

               Likewise, the O-stroke character (Unicode 248), used in Danish and

               Norwegian, will be down-coded to plain o. Chinese characters cannot be

               represented in codepage IBM437; when using the default encoding, Chinese

               characters in filenames will be represented as ?. These are all examples

               of "information loss".

             </para>

             <para>

               The loss of information associated to the use of the IBM437 encoding is

               inconvenient, and can also lead to runtime errors. For example, using

               IBM437, any sequence of 4 Chinese characters will be encoded as ????.  If

               your application creates a <c>ZipOutputStream</c>, does not set the

               encoding, then adds two files, each with names of four Chinese characters

               each, this will result in a duplicate filename exception.  In the case

               where you add a single file with a name containing four Chinese

               characters, the zipfile will save properly, but extracting that file

               later, with any zip tool, will result in an error, because the question

               mark is not legal for use within filenames on Windows.  These are just a

               few examples of the problems associated to loss of information.

             </para>

             <para>

               This flag is independent of the encoding of the content within the entries

               in the zip file. Think of the zip file as a container - it supports an

               encoding.  Within the container are other "containers" - the file entries

               themselves.  The encoding within those entries is independent of the

               encoding of the zip archive container for those entries.

             </para>

             <para>

               Rather than specify the encoding in a binary fashion using this flag, an

               application can specify an arbitrary encoding via the <see cref="P:Ionic.Zip.ZipOutputStream.ProvisionalAlternateEncoding"/> property.  Setting the encoding

               explicitly when creating zip archives will result in non-compliant zip

               files that, curiously, are fairly interoperable.  The challenge is, the

               PKWare specification does not provide for a way to specify that an entry

               in a zip archive uses a code page that is neither IBM437 nor UTF-8.

               Therefore if you set the encoding explicitly when creating a zip archive,

               you must take care upon reading the zip archive to use the same code page.

               If you get it wrong, the behavior is undefined and may result in incorrect

               filenames, exceptions, stomach upset, hair loss, and acne.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipOutputStream.ProvisionalAlternateEncoding"/>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.ProvisionalAlternateEncoding">

             <summary>

               The text encoding to use when emitting entries into the zip archive, for

               those entries whose filenames or comments cannot be encoded with the

               default (IBM437) encoding.

             </summary>

             <remarks>

             <para>

               In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its

               zip specification</see>, PKWare describes two options for encoding

               filenames and comments: using IBM437 or UTF-8.  But, some archiving tools

               or libraries do not follow the specification, and instead encode

               characters using the system default code page.  For example, WinRAR when

               run on a machine in Shanghai may encode filenames with the Big-5 Chinese

               (950) code page.  This behavior is contrary to the Zip specification, but

               it occurs anyway.

             </para>

             <para>

               When using DotNetZip to write zip archives that will be read by one of

               these other archivers, set this property to specify the code page to use

               when encoding the <see cref="P:Ionic.Zip.ZipEntry.FileName"/> and <see cref="P:Ionic.Zip.ZipEntry.Comment"/> for each <c>ZipEntry</c> in the zip file, for

               values that cannot be encoded with the default codepage for zip files,

               IBM437.  This is why this property is "provisional".  In all cases, IBM437

               is used where possible, in other words, where no loss of data would

               result. It is possible, therefore, to have a given entry with a

               <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with the

               specified "provisional" codepage.

             </para>

             <para>

               Be aware that a zip file created after you've explicitly set the

               <c>ProvisionalAlternateEncoding</c> property to a value other than

               IBM437 may not be compliant to the PKWare specification, and may not be

               readable by compliant archivers.  On the other hand, many (most?)

               archivers are non-compliant and can read zip files created in arbitrary

               code pages.  The trick is to use or specify the proper codepage when

               reading the zip.

             </para>

             <para>

               When creating a zip archive using this library, it is possible to change

               the value of <c>ProvisionalAlternateEncoding</c> between each entry you

               add, and between adding entries and the call to <c>Close()</c>. Don't do

               this. It will likely result in a zipfile that is not readable.  For best

               interoperability, either leave <c>ProvisionalAlternateEncoding</c>

               alone, or specify it only once, before adding any entries to the

               <c>ZipOutputStream</c> instance.  There is one exception to this

               recommendation, described later.

             </para>

             <para>

               When using an arbitrary, non-UTF8 code page for encoding, there is no

               standard way for the creator application - whether DotNetZip, WinZip,

               WinRar, or something else - to formally specify in the zip file which

               codepage has been used for the entries. As a result, readers of zip files

               are not able to inspect the zip file and determine the codepage that was

               used for the entries contained within it.  It is left to the application

               or user to determine the necessary codepage when reading zip files encoded

               this way.  If you use an incorrect codepage when reading a zipfile, you

               will get entries with filenames that are incorrect, and the incorrect

               filenames may even contain characters that are not legal for use within

               filenames in Windows. Extracting entries with illegal characters in the

               filenames will lead to exceptions. It's too bad, but this is just the way

               things are with code pages in zip files. Caveat Emptor.

             </para>

             <para>

               One possible approach for specifying the code page for a given zip file is

               to describe the code page in a human-readable form in the Zip comment. For

               example, the comment may read "Entries in this archive are encoded in the

               Big5 code page".  For maximum interoperability, the zip comment in this

               case should be encoded in the default, IBM437 code page.  In this case,

               the zip comment is encoded using a different page than the filenames.  To

               do this, Specify <c>ProvisionalAlternateEncoding</c> to your desired

               region-specific code page, once before adding any entries, and then set

               the <see cref="P:Ionic.Zip.ZipOutputStream.Comment"/> property and reset

               <c>ProvisionalAlternateEncoding</c> to IBM437 before calling <c>Close()</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.AlternateEncoding">

            <summary>

              A Text Encoding to use when encoding the filenames and comments for

              all the ZipEntry items, during a ZipFile.Save() operation.

            </summary>

            <remarks>

              <para>

                Whether the encoding specified here is used during the save depends

                on <see cref="P:Ionic.Zip.ZipOutputStream.AlternateEncodingUsage"/>.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.AlternateEncodingUsage">

            <summary>

              A flag that tells if and when this instance should apply

              AlternateEncoding to encode the filenames and comments associated to

              of ZipEntry objects contained within this instance.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.DefaultEncoding">

            <summary>

            The default text encoding used in zip archives.  It is numeric 437, also

            known as IBM437.

            </summary>

            <seealso cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.ParallelDeflateThreshold">

             <summary>

               The size threshold for an entry, above which a parallel deflate is used.

             </summary>

             <remarks>

               <para>

                 DotNetZip will use multiple threads to compress any ZipEntry, when

                 the <c>CompressionMethod</c> is Deflate, and if the entry is

                 larger than the given size.  Zero means "always use parallel

                 deflate", while -1 means "never use parallel deflate".

               </para>

               <para>

                 If the entry size cannot be known before compression, as with any entry

                 added via a ZipOutputStream, then Parallel deflate will never be

                 performed, unless the value of this property is zero.

               </para>

               <para>

                 A parallel deflate operations will speed up the compression of

                 large files, on computers with multiple CPUs or multiple CPU

                 cores.  For files above 1mb, on a dual core or dual-cpu (2p)

                 machine, the time required to compress the file can be 70% of the

                 single-threaded deflate.  For very large files on 4p machines the

                 compression can be done in 30% of the normal time.  The downside

                 is that parallel deflate consumes extra memory during the deflate,

                 and the deflation is slightly less effective.

               </para>

               <para>

                 Parallel deflate tends to not be as effective as single-threaded deflate

                 because the original data stream is split into multiple independent

                 buffers, each of which is compressed in parallel.  But because they are

                 treated independently, there is no opportunity to share compression

                 dictionaries, and additional framing bytes must be added to the output

                 stream.  For that reason, a deflated stream may be slightly larger when

                 compressed using parallel deflate, as compared to a traditional

                 single-threaded deflate. For files of about 512k, the increase over the

                 normal deflate is as much as 5% of the total compressed size. For larger

                 files, the difference can be as small as 0.1%.

               </para>

               <para>

                 Multi-threaded compression does not give as much an advantage when using

                 Encryption. This is primarily because encryption tends to slow down

                 the entire pipeline. Also, multi-threaded compression gives less of an

                 advantage when using lower compression levels, for example <see cref="F:Ionic.Zlib.CompressionLevel.BestSpeed"/>.  You may have to perform

                 some tests to determine the best approach for your situation.

               </para>

               <para>

                 The default value for this property is -1, which means parallel

                 compression will not be performed unless you set it to zero.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.ParallelDeflateMaxBufferPairs">

             <summary>

               The maximum number of buffer pairs to use when performing

               parallel compression.

             </summary>

             <remarks>

             <para>

               This property sets an upper limit on the number of memory

               buffer pairs to create when performing parallel

               compression.  The implementation of the parallel

               compression stream allocates multiple buffers to

               facilitate parallel compression.  As each buffer fills up,

               the stream uses <see cref="M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback)">

               ThreadPool.QueueUserWorkItem()</see> to compress those

               buffers in a background threadpool thread. After a buffer

               is compressed, it is re-ordered and written to the output

               stream.

             </para>

             <para>

               A higher number of buffer pairs enables a higher degree of

               parallelism, which tends to increase the speed of compression on

               multi-cpu computers.  On the other hand, a higher number of buffer

               pairs also implies a larger memory consumption, more active worker

               threads, and a higher cpu utilization for any compression. This

               property enables the application to limit its memory consumption and

               CPU utilization behavior depending on requirements.

             </para>

             <para>

               For each compression "task" that occurs in parallel, there are 2

               buffers allocated: one for input and one for output.  This property

               sets a limit for the number of pairs.  The total amount of storage

               space allocated for buffering will then be (N*S*2), where N is the

               number of buffer pairs, S is the size of each buffer (<see cref="P:Ionic.Zip.ZipOutputStream.CodecBufferSize"/>).  By default, DotNetZip allocates 4 buffer

               pairs per CPU core, so if your machine has 4 cores, and you retain

               the default buffer size of 128k, then the

               ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer

               memory in total, or 4mb, in blocks of 128kb.  If you then set this

               property to 8, then the number will be 8 * 2 * 128kb of buffer

               memory, or 2mb.

             </para>

             <para>

               CPU utilization will also go up with additional buffers, because a

               larger number of buffer pairs allows a larger number of background

               threads to compress in parallel. If you find that parallel

               compression is consuming too much memory or CPU, you can adjust this

               value downward.

             </para>

             <para>

               The default value is 16. Different values may deliver better or

               worse results, depending on your priorities and the dynamic

               performance characteristics of your storage and compute resources.

             </para>

             <para>

               This property is not the number of buffer pairs to use; it is an

               upper limit. An illustration: Suppose you have an application that

               uses the default value of this property (which is 16), and it runs

               on a machine with 2 CPU cores. In that case, DotNetZip will allocate

               4 buffer pairs per CPU core, for a total of 8 pairs.  The upper

               limit specified by this property has no effect.

             </para>

             <para>

               The application can set this value at any time, but it is

               effective only if set before calling

               <c>ZipOutputStream.Write()</c> for the first time.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipOutputStream.ParallelDeflateThreshold"/>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CanRead">

            <summary>

            Always returns false.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CanSeek">

            <summary>

            Always returns false.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.CanWrite">

            <summary>

            Always returns true.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Length">

            <summary>

            Always returns a NotSupportedException.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipOutputStream.Position">

            <summary>

            Setting this property always returns a NotSupportedException. Getting it

            returns the value of the Position on the underlying stream.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipInputStream">

             <summary>

               Provides a stream metaphor for reading zip files.

             </summary>

             <remarks>

             <para>

               This class provides an alternative programming model for reading zip files to

               the one enabled by the <see cref="T:Ionic.Zip.ZipFile"/> class.  Use this when reading zip

               files, as an alternative to the <see cref="T:Ionic.Zip.ZipFile"/> class, when you would

               like to use a Stream class to read the file.

             </para>

             <para>

               Some application designs require a readable stream for input. This stream can

               be used to read a zip file, and extract entries.

             </para>

             <para>

               Both the <c>ZipInputStream</c> class and the <c>ZipFile</c> class can be used

               to read and extract zip files.  Both of them support many of the common zip

               features, including Unicode, different compression levels, and ZIP64.  The

               programming models differ. For example, when extracting entries via calls to

               the <c>GetNextEntry()</c> and <c>Read()</c> methods on the

               <c>ZipInputStream</c> class, the caller is responsible for creating the file,

               writing the bytes into the file, setting the attributes on the file, and

               setting the created, last modified, and last accessed timestamps on the

               file. All of these things are done automatically by a call to <see cref="M:Ionic.Zip.ZipEntry.Extract">ZipEntry.Extract()</see>.  For this reason, the

               <c>ZipInputStream</c> is generally recommended for when your application wants

               to extract the data, without storing that data into a file.

             </para>

             <para>

               Aside from the obvious differences in programming model, there are some

               differences in capability between the <c>ZipFile</c> class and the

               <c>ZipInputStream</c> class.

             </para>

             <list type="bullet">

               <item>

                 <c>ZipFile</c> can be used to create or update zip files, or read and

                 extract zip files. <c>ZipInputStream</c> can be used only to read and

                 extract zip files. If you want to use a stream to create zip files, check

                 out the <see cref="T:Ionic.Zip.ZipOutputStream"/>.

               </item>

               <item>

                 <c>ZipInputStream</c> cannot read segmented or spanned

                 zip files.

               </item>

               <item>

                 <c>ZipInputStream</c> will not read Zip file comments.

               </item>

               <item>

                 When reading larger files, <c>ZipInputStream</c> will always underperform

                 <c>ZipFile</c>. This is because the <c>ZipInputStream</c> does a full scan on the

                 zip file, while the <c>ZipFile</c> class reads the central directory of the

                 zip file.

               </item>

             </list>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.#ctor(System.IO.Stream)">

             <summary>

               Create a <c>ZipInputStream</c>, wrapping it around an existing stream.

             </summary>

             <remarks>

             <para>

               While the <see cref="T:Ionic.Zip.ZipFile"/> class is generally easier

               to use, this class provides an alternative to those

               applications that want to read from a zipfile directly,

               using a <see cref="T:System.IO.Stream"/>.

             </para>

             <para>

               Both the <c>ZipInputStream</c> class and the <c>ZipFile</c> class can be used

               to read and extract zip files.  Both of them support many of the common zip

               features, including Unicode, different compression levels, and ZIP64.  The

               programming models differ. For example, when extracting entries via calls to

               the <c>GetNextEntry()</c> and <c>Read()</c> methods on the

               <c>ZipInputStream</c> class, the caller is responsible for creating the file,

               writing the bytes into the file, setting the attributes on the file, and

               setting the created, last modified, and last accessed timestamps on the

               file. All of these things are done automatically by a call to <see cref="M:Ionic.Zip.ZipEntry.Extract">ZipEntry.Extract()</see>.  For this reason, the

               <c>ZipInputStream</c> is generally recommended for when your application wants

               to extract the data, without storing that data into a file.

             </para>

             <para>

               Aside from the obvious differences in programming model, there are some

               differences in capability between the <c>ZipFile</c> class and the

               <c>ZipInputStream</c> class.

             </para>

             <list type="bullet">

               <item>

               <c>ZipFile</c> can be used to create or update zip files, or read and extract

               zip files. <c>ZipInputStream</c> can be used only to read and extract zip

                 files. If you want to use a stream to create zip files, check out the <see cref="T:Ionic.Zip.ZipOutputStream"/>.

               </item>

               <item>

                 <c>ZipInputStream</c> cannot read segmented or spanned

                 zip files.

               </item>

               <item>

                 <c>ZipInputStream</c> will not read Zip file comments.

               </item>

               <item>

                 When reading larger files, <c>ZipInputStream</c> will always underperform

                 <c>ZipFile</c>. This is because the <c>ZipInputStream</c> does a full scan on the

                 zip file, while the <c>ZipFile</c> class reads the central directory of the

                 zip file.

               </item>

             </list>

             </remarks>

             <param name="stream">

               The stream to read. It must be readable. This stream will be closed at

               the time the <c>ZipInputStream</c> is closed.

             </param>

             <example>

               This example shows how to read a zip file, and extract entries, using the

               <c>ZipInputStream</c> class.

             <code lang="C#">

             private void Unzip()

             {

                 byte[] buffer= new byte[2048];

                 int n;

                 using (var raw = File.Open(inputFileName, FileMode.Open, FileAccess.Read))

                 {

                     using (var input= new ZipInputStream(raw))

                     {

                         ZipEntry e;

                         while (( e = input.GetNextEntry()) != null)

                         {

                             if (e.IsDirectory) continue;

                             string outputPath = Path.Combine(extractDir, e.FileName);

                             using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))

                             {

                                 while ((n= input.Read(buffer, 0, buffer.Length)) &gt; 0)

                                 {

                                     output.Write(buffer,0,n);

                                 }

                             }

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Private Sub UnZip()

                 Dim inputFileName As String = "MyArchive.zip"

                 Dim extractDir As String = "extract"

                 Dim buffer As Byte() = New Byte(2048) {}

                 Using raw As FileStream = File.Open(inputFileName, FileMode.Open, FileAccess.Read)

                     Using input As ZipInputStream = New ZipInputStream(raw)

                         Dim e As ZipEntry

                         Do While (Not e = input.GetNextEntry Is Nothing)

                             If Not e.IsDirectory Then

                                 Using output As FileStream = File.Open(Path.Combine(extractDir, e.FileName), _

                                                                        FileMode.Create, FileAccess.ReadWrite)

                                     Dim n As Integer

                                     Do While (n = input.Read(buffer, 0, buffer.Length) &gt; 0)

                                         output.Write(buffer, 0, n)

                                     Loop

                                 End Using

                             End If

                         Loop

                     End Using

                 End Using

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.#ctor(System.String)">

             <summary>

               Create a <c>ZipInputStream</c>, given the name of an existing zip file.

             </summary>

             <remarks>

             <para>

               This constructor opens a <c>FileStream</c> for the given zipfile, and

               wraps a <c>ZipInputStream</c> around that.  See the documentation for the

               <see cref="M:Ionic.Zip.ZipInputStream.#ctor(System.IO.Stream)"/> constructor for full details.

             </para>

             <para>

               While the <see cref="T:Ionic.Zip.ZipFile"/> class is generally easier

               to use, this class provides an alternative to those

               applications that want to read from a zipfile directly,

               using a <see cref="T:System.IO.Stream"/>.

             </para>

             </remarks>

             <param name="fileName">

               The name of the filesystem file to read.

             </param>

             <example>

               This example shows how to read a zip file, and extract entries, using the

               <c>ZipInputStream</c> class.

             <code lang="C#">

             private void Unzip()

             {

                 byte[] buffer= new byte[2048];

                 int n;

                 using (var input= new ZipInputStream(inputFileName))

                 {

                     ZipEntry e;

                     while (( e = input.GetNextEntry()) != null)

                     {

                         if (e.IsDirectory) continue;

                         string outputPath = Path.Combine(extractDir, e.FileName);

                         using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))

                         {

                             while ((n= input.Read(buffer, 0, buffer.Length)) &gt; 0)

                             {

                                 output.Write(buffer,0,n);

                             }

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Private Sub UnZip()

                 Dim inputFileName As String = "MyArchive.zip"

                 Dim extractDir As String = "extract"

                 Dim buffer As Byte() = New Byte(2048) {}

                 Using input As ZipInputStream = New ZipInputStream(inputFileName)

                     Dim e As ZipEntry

                     Do While (Not e = input.GetNextEntry Is Nothing)

                         If Not e.IsDirectory Then

                             Using output As FileStream = File.Open(Path.Combine(extractDir, e.FileName), _

                                                                    FileMode.Create, FileAccess.ReadWrite)

                                 Dim n As Integer

                                 Do While (n = input.Read(buffer, 0, buffer.Length) &gt; 0)

                                     output.Write(buffer, 0, n)

                                 Loop

                             End Using

                         End If

                     Loop

                 End Using

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.#ctor(System.IO.Stream,System.Boolean)">

             <summary>

               Create a <c>ZipInputStream</c>, explicitly specifying whether to

               keep the underlying stream open.

             </summary>

             <remarks>

               See the documentation for the <see cref="M:Ionic.Zip.ZipInputStream.#ctor(System.IO.Stream)">ZipInputStream(Stream)</see>

               constructor for a discussion of the class, and an example of how to use the class.

             </remarks>

             <param name="stream">

               The stream to read from. It must be readable.

             </param>

             <param name="leaveOpen">

               true if the application would like the stream

               to remain open after the <c>ZipInputStream</c> has been closed.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.ToString">

            <summary>Provides a string representation of the instance.</summary>

            <remarks>

              <para>

                This can be useful for debugging purposes.

              </para>

            </remarks>

            <returns>a string representation of the instance.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.Read(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Read the data from the stream into the buffer.

             </summary>

             <remarks>

             <para>

               The data for the zipentry will be decrypted and uncompressed, as

               necessary, before being copied into the buffer.

             </para>

             <para>

               You must set the <see cref="P:Ionic.Zip.ZipInputStream.Password"/> property before calling

               <c>Read()</c> the first time for an encrypted entry.  To determine if an

               entry is encrypted and requires a password, check the <see cref="P:Ionic.Zip.ZipEntry.Encryption">ZipEntry.Encryption</see> property.

             </para>

             </remarks>

             <param name="buffer">The buffer to hold the data read from the stream.</param>

             <param name="offset">the offset within the buffer to copy the first byte read.</param>

             <param name="count">the number of bytes to read.</param>

             <returns>the number of bytes read, after decryption and decompression.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.GetNextEntry">

             <summary>

               Read the next entry from the zip file.

             </summary>

             <remarks>

             <para>

               Call this method just before calling <see cref="M:Ionic.Zip.ZipInputStream.Read(System.Byte[],System.Int32,System.Int32)"/>,

               to position the pointer in the zip file to the next entry that can be

               read.  Subsequent calls to <c>Read()</c>, will decrypt and decompress the

               data in the zip file, until <c>Read()</c> returns 0.

             </para>

             <para>

               Each time you call <c>GetNextEntry()</c>, the pointer in the wrapped

               stream is moved to the next entry in the zip file.  If you call <see cref="M:Ionic.Zip.ZipInputStream.Seek(System.Int64,System.IO.SeekOrigin)"/>, and thus re-position the pointer within

               the file, you will need to call <c>GetNextEntry()</c> again, to insure

               that the file pointer is positioned at the beginning of a zip entry.

             </para>

             <para>

               This method returns the <c>ZipEntry</c>. Using a stream approach, you will

               read the raw bytes for an entry in a zip file via calls to <c>Read()</c>.

               Alternatively, you can extract an entry into a file, or a stream, by

               calling <see cref="M:Ionic.Zip.ZipEntry.Extract"/>, or one of its siblings.

             </para>

             </remarks>

             <returns>

               The <c>ZipEntry</c> read. Returns null (or Nothing in VB) if there are no more

               entries in the zip file.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.Dispose(System.Boolean)">

             <summary>

               Dispose the stream.

             </summary>

             <remarks>

             <para>

               This method disposes the ZipInputStream.  It may also close the

               underlying stream, depending on which constructor was used.

             </para>

             <para>

               Typically the application will call <c>Dispose()</c> implicitly, via

               a <c>using</c> statement in C#, or a <c>Using</c> statement in VB.

             </para>

               <para>

                 Application code won't call this code directly.  This method may

                 be invoked in two distinct scenarios.  If disposing == true, the

                 method has been called directly or indirectly by a user's code,

                 for example via the public Dispose() method. In this case, both

                 managed and unmanaged resources can be referenced and disposed.

                 If disposing == false, the method has been called by the runtime

                 from inside the object finalizer and this method should not

                 reference other objects; in that case only unmanaged resources

                 must be referenced or disposed.

               </para>

             </remarks>

             <param name="disposing">

               true if the Dispose method was invoked by user code.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.Flush">

            <summary>

            This is a no-op.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.Write(System.Byte[],System.Int32,System.Int32)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="buffer">ignored</param>

            <param name="offset">ignored</param>

            <param name="count">ignored</param>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.Seek(System.Int64,System.IO.SeekOrigin)">

             <summary>

               This method seeks in the underlying stream.

             </summary>

             <remarks>

             <para>

               Call this method if you want to seek around within the zip file for random access.

             </para>

             <para>

               Applications can intermix calls to <c>Seek()</c> with calls to <see cref="M:Ionic.Zip.ZipInputStream.GetNextEntry"/>.  After a call to <c>Seek()</c>,

               <c>GetNextEntry()</c> will get the next <c>ZipEntry</c> that falls after

               the current position in the input stream. You're on your own for finding

               out just where to seek in the stream, to get to the various entries.

             </para>

             </remarks>

             <param name="offset">the offset point to seek to</param>

             <param name="origin">the reference point from which to seek</param>

             <returns>The new position</returns>

        </member>

        <member name="M:Ionic.Zip.ZipInputStream.SetLength(System.Int64)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="value">ignored</param>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.ProvisionalAlternateEncoding">

             <summary>

               The text encoding to use when reading entries into the zip archive, for

               those entries whose filenames or comments cannot be encoded with the

               default (IBM437) encoding.

             </summary>

             <remarks>

             <para>

               In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its

               zip specification</see>, PKWare describes two options for encoding

               filenames and comments: using IBM437 or UTF-8.  But, some archiving tools

               or libraries do not follow the specification, and instead encode

               characters using the system default code page.  For example, WinRAR when

               run on a machine in Shanghai may encode filenames with the Big-5 Chinese

               (950) code page.  This behavior is contrary to the Zip specification, but

               it occurs anyway.

             </para>

             <para>

               When using DotNetZip to read zip archives that use something other than

               UTF-8 or IBM437, set this property to specify the code page to use when

               reading encoded filenames and comments for each <c>ZipEntry</c> in the zip

               file.

             </para>

             <para>

               This property is "provisional". When the entry in the zip archive is not

               explicitly marked as using UTF-8, then IBM437 is used to decode filenames

               and comments. If a loss of data would result from using IBM436 -

               specifically when encoding and decoding is not reflexive - the codepage

               specified here is used. It is possible, therefore, to have a given entry

               with a <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with

               the specified "provisional" codepage.

             </para>

             <para>

               When a zip file uses an arbitrary, non-UTF8 code page for encoding, there

               is no standard way for the reader application - whether DotNetZip, WinZip,

               WinRar, or something else - to know which codepage has been used for the

               entries. Readers of zip files are not able to inspect the zip file and

               determine the codepage that was used for the entries contained within it.

               It is left to the application or user to determine the necessary codepage

               when reading zip files encoded this way.  If you use an incorrect codepage

               when reading a zipfile, you will get entries with filenames that are

               incorrect, and the incorrect filenames may even contain characters that

               are not legal for use within filenames in Windows. Extracting entries with

               illegal characters in the filenames will lead to exceptions. It's too bad,

               but this is just the way things are with code pages in zip files. Caveat

               Emptor.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.CodecBufferSize">

             <summary>

               Size of the work buffer to use for the ZLIB codec during decompression.

             </summary>

             <remarks>

               Setting this affects the performance and memory efficiency of compression

               and decompression.  For larger files, setting this to a larger size may

               improve performance, but the exact numbers vary depending on available

               memory, and a bunch of other variables. I don't have good firm

               recommendations on how to set it.  You'll have to test it yourself. Or

               just leave it alone and accept the default.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.Password">

             <summary>

               Sets the password to be used on the <c>ZipInputStream</c> instance.

             </summary>

             <remarks>

             <para>

               When reading a zip archive, this password is used to read and decrypt the

               entries that are encrypted within the zip file. When entries within a zip

               file use different passwords, set the appropriate password for the entry

               before the first call to <c>Read()</c> for each entry.

             </para>

             <para>

               When reading an entry that is not encrypted, the value of this property is

               ignored.

             </para>

             </remarks>

             <example>

               This example uses the ZipInputStream to read and extract entries from a

               zip file, using a potentially different password for each entry.

             <code lang="C#">

             byte[] buffer= new byte[2048];

             int n;

             using (var raw = File.Open(_inputFileName, FileMode.Open, FileAccess.Read ))

             {

                 using (var input= new ZipInputStream(raw))

                 {

                     ZipEntry e;

                     while (( e = input.GetNextEntry()) != null)

                     {

                         input.Password = PasswordForEntry(e.FileName);

                         if (e.IsDirectory) continue;

                         string outputPath = Path.Combine(_extractDir, e.FileName);

                         using (var output = File.Open(outputPath, FileMode.Create, FileAccess.ReadWrite))

                         {

                             while ((n= input.Read(buffer,0,buffer.Length)) > 0)

                             {

                                 output.Write(buffer,0,n);

                             }

                         }

                     }

                 }

             }

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.CanRead">

            <summary>

            Always returns true.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.CanSeek">

            <summary>

            Returns the value of <c>CanSeek</c> for the underlying (wrapped) stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.CanWrite">

            <summary>

            Always returns false.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.Length">

            <summary>

            Returns the length of the underlying stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipInputStream.Position">

            <summary>

            Gets or sets the position of the underlying stream.

            </summary>

            <remarks>

            Setting the position is equivalent to calling <c>Seek(value, SeekOrigin.Begin)</c>.

            </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipSegmentedStream.ForUpdate(System.String,System.UInt32)">

            <summary>

              Sort-of like a factory method, ForUpdate is used only when

              the application needs to update the zip entry metadata for

              a segmented zip file, when the starting segment is earlier

              than the ending segment, for a particular entry.

            </summary>

            <remarks>

              <para>

                The update is always contiguous, never rolls over.  As a

                result, this method doesn't need to return a ZSS; it can

                simply return a FileStream.  That's why it's "sort of"

                like a Factory method.

              </para>

              <para>

                Caller must Close/Dispose the stream object returned by

                this method.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipSegmentedStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Read from the stream

            </summary>

            <param name="buffer">the buffer to read</param>

            <param name="offset">the offset at which to start</param>

            <param name="count">the number of bytes to read</param>

            <returns>the number of bytes actually read</returns>

        </member>

        <member name="M:Ionic.Zip.ZipSegmentedStream.Write(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Write to the stream.

            </summary>

            <param name="buffer">the buffer from which to write</param>

            <param name="offset">the offset at which to start writing</param>

            <param name="count">the number of bytes to write</param>

        </member>

        <member name="P:Ionic.Zip.ZipSegmentedStream.CurrentName">

            <summary>

              Name of the filesystem file corresponding to the current segment.

            </summary>

            <remarks>

              <para>

                The name is not always the name currently being used in the

                filesystem.  When rwMode is RwMode.Write, the filesystem file has a

                temporary name until the stream is closed or until the next segment is

                started.

              </para>

            </remarks>

        </member>

        <member name="T:Ionic.Zip.ComHelper">

            <summary>

            This class exposes a set of COM-accessible wrappers for static

            methods available on the ZipFile class.  You don't need this

            class unless you are using DotNetZip from a COM environment.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ComHelper.IsZipFile(System.String)">

            <summary>

             A wrapper for <see cref="M:Ionic.Zip.ZipFile.IsZipFile(System.String)">ZipFile.IsZipFile(string)</see>

            </summary>

            <param name="filename">The filename to of the zip file to check.</param>

            <returns>true if the file contains a valid zip file.</returns>

        </member>

        <member name="M:Ionic.Zip.ComHelper.IsZipFileWithExtract(System.String)">

            <summary>

             A wrapper for <see cref="M:Ionic.Zip.ZipFile.IsZipFile(System.String,System.Boolean)">ZipFile.IsZipFile(string, bool)</see>

            </summary>

            <remarks>

            We cannot use "overloaded" Method names in COM interop.

            So, here, we use a unique name.

            </remarks>

            <param name="filename">The filename to of the zip file to check.</param>

            <returns>true if the file contains a valid zip file.</returns>

        </member>

        <member name="M:Ionic.Zip.ComHelper.CheckZip(System.String)">

             <summary>

              A wrapper for <see cref="M:Ionic.Zip.ZipFile.CheckZip(System.String)">ZipFile.CheckZip(string)</see>

             </summary>

             <param name="filename">The filename to of the zip file to check.</param>

             <returns>true if the named zip file checks OK. Otherwise, false. </returns>

        </member>

        <member name="M:Ionic.Zip.ComHelper.CheckZipPassword(System.String,System.String)">

             <summary>

              A COM-friendly wrapper for the static method <see cref="M:Ionic.Zip.ZipFile.CheckZipPassword(System.String,System.String)"/>.

             </summary>

             <param name="filename">The filename to of the zip file to check.</param>

             <param name="password">The password to check.</param>

             <returns>true if the named zip file checks OK. Otherwise, false. </returns>

        </member>

        <member name="M:Ionic.Zip.ComHelper.FixZipDirectory(System.String)">

            <summary>

             A wrapper for <see cref="M:Ionic.Zip.ZipFile.FixZipDirectory(System.String)">ZipFile.FixZipDirectory(string)</see>

            </summary>

            <param name="filename">The filename to of the zip file to fix.</param>

        </member>

        <member name="M:Ionic.Zip.ComHelper.GetZipLibraryVersion">

            <summary>

             A wrapper for <see cref="P:Ionic.Zip.ZipFile.LibraryVersion">ZipFile.LibraryVersion</see>

            </summary>

            <returns>

             the version number on the DotNetZip assembly, formatted as a string.

            </returns>

        </member>

        <member name="T:Ionic.Zip.ZipErrorAction">

             <summary>

             An enum providing the options when an error occurs during opening or reading

             of a file or directory that is being saved to a zip file. 

             </summary>

             <remarks>

              <para>

                This enum describes the actions that the library can take when an error occurs

                opening or reading a file, as it is being saved into a Zip archive. 

              </para>

              <para>

                 In some cases an error will occur when DotNetZip tries to open a file to be

                 added to the zip archive.  In other cases, an error might occur after the

                 file has been successfully opened, while DotNetZip is reading the file.

              </para>

              <para>

                The first problem might occur when calling AddDirectory() on a directory

                that contains a Clipper .dbf file; the file is locked by Clipper and

                cannot be opened by another process. An example of the second problem is

                the ERROR_LOCK_VIOLATION that results when a file is opened by another

                process, but not locked, and a range lock has been taken on the file.

                Microsoft Outlook takes range locks on .PST files.

              </para>

             </remarks>

        </member>

        <member name="F:Ionic.Zip.ZipErrorAction.Throw">

            <summary>

            Throw an exception when an error occurs while zipping.  This is the default

            behavior.  (For COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipErrorAction.Skip">

            <summary>

            When an error occurs during zipping, for example a file cannot be opened,

            skip the file causing the error, and continue zipping.  (For COM clients,

            this is a 1.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipErrorAction.Retry">

            <summary>

            When an error occurs during zipping, for example a file cannot be opened,

            retry the operation that caused the error. Be careful with this option. If

            the error is not temporary, the library will retry forever.  (For COM

            clients, this is a 2.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipErrorAction.InvokeErrorEvent">

            <summary>

            When an error occurs, invoke the zipError event.  The event type used is

            <see cref="F:Ionic.Zip.ZipProgressEventType.Error_Saving"/>.  A typical use of this option:

            a GUI application may wish to pop up a dialog to allow the user to view the

            error that occurred, and choose an appropriate action.  After your

            processing in the error event, if you want to skip the file, set <see cref="P:Ionic.Zip.ZipEntry.ZipErrorAction"/> on the

            <c>ZipProgressEventArgs.CurrentEntry</c> to <c>Skip</c>.  If you want the

            exception to be thrown, set <c>ZipErrorAction</c> on the <c>CurrentEntry</c>

            to <c>Throw</c>.  If you want to cancel the zip, set

            <c>ZipProgressEventArgs.Cancel</c> to true.  Cancelling differs from using

            Skip in that a cancel will not save any further entries, if there are any.

            (For COM clients, the value of this enum is a 3.)

            </summary>

        </member>

        <member name="T:Ionic.Zip.EncryptionAlgorithm">

             <summary>

             An enum that provides the various encryption algorithms supported by this

             library.

             </summary>

             <remarks>

             <para>

               <c>PkzipWeak</c> implies the use of Zip 2.0 encryption, which is known to be

               weak and subvertible.

             </para>

             <para>

               A note on interoperability: Values of <c>PkzipWeak</c> and <c>None</c> are

               specified in <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's zip

               specification</see>, and are considered to be "standard".  Zip archives

               produced using these options will be interoperable with many other zip tools

               and libraries, including Windows Explorer.

             </para>

             <para>

               Values of <c>WinZipAes128</c> and <c>WinZipAes256</c> are not part of the Zip

               specification, but rather imply the use of a vendor-specific extension from

               WinZip. If you want to produce interoperable Zip archives, do not use these

               values.  For example, if you produce a zip archive using WinZipAes256, you

               will be able to open it in Windows Explorer on Windows XP and Vista, but you

               will not be able to extract entries; trying this will lead to an "unspecified

               error". For this reason, some people have said that a zip archive that uses

               WinZip's AES encryption is not actually a zip archive at all.  A zip archive

               produced this way will be readable with the WinZip tool (Version 11 and

               beyond).

             </para>

             <para>

               There are other third-party tools and libraries, both commercial and

               otherwise, that support WinZip's AES encryption. These will be able to read

               AES-encrypted zip archives produced by DotNetZip, and conversely applications

               that use DotNetZip to read zip archives will be able to read AES-encrypted

               archives produced by those tools or libraries.  Consult the documentation for

               those other tools and libraries to find out if WinZip's AES encryption is

               supported.

             </para>

             <para>

               In case you care: According to <see href="http://www.winzip.com/aes_info.htm">the WinZip specification</see>, the

               actual AES key used is derived from the <see cref="P:Ionic.Zip.ZipEntry.Password"/> via an

               algorithm that complies with <see href="http://www.ietf.org/rfc/rfc2898.txt">RFC 2898</see>, using an iteration

               count of 1000.  The algorithm is sometimes referred to as PBKDF2, which stands

               for "Password Based Key Derivation Function #2".

             </para>

             <para>

               A word about password strength and length: The AES encryption technology is

               very good, but any system is only as secure as the weakest link.  If you want

               to secure your data, be sure to use a password that is hard to guess.  To make

               it harder to guess (increase its "entropy"), you should make it longer.  If

               you use normal characters from an ASCII keyboard, a password of length 20 will

               be strong enough that it will be impossible to guess.  For more information on

               that, I'd encourage you to read <see href="http://www.redkestrel.co.uk/Articles/RandomPasswordStrength.html">this

               article.</see>

             </para>

             <para>

               The WinZip AES algorithms are not supported with the version of DotNetZip that

               runs on the .NET Compact Framework.  This is because .NET CF lacks the

               HMACSHA1 class that is required for producing the archive.

             </para>

             </remarks>

        </member>

        <member name="F:Ionic.Zip.EncryptionAlgorithm.None">

            <summary>

            No encryption at all.

            </summary>

        </member>

        <member name="F:Ionic.Zip.EncryptionAlgorithm.PkzipWeak">

            <summary>

            Traditional or Classic pkzip encryption.

            </summary>

        </member>

        <member name="F:Ionic.Zip.EncryptionAlgorithm.WinZipAes128">

            <summary>

            WinZip AES encryption (128 key bits).

            </summary>

        </member>

        <member name="F:Ionic.Zip.EncryptionAlgorithm.WinZipAes256">

            <summary>

            WinZip AES encryption (256 key bits).

            </summary>

        </member>

        <member name="F:Ionic.Zip.EncryptionAlgorithm.Unsupported">

            <summary>

            An encryption algorithm that is not supported by DotNetZip.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ExtractExistingFileAction">

             <summary>

             An enum for the options when extracting an entry would overwrite an existing file. 

             </summary>

             <remarks>

               <para>

                 This enum describes the actions that the library can take when an

                 <c>Extract()</c> or <c>ExtractWithPassword()</c> method is called to extract an

                 entry to a filesystem, and the extraction would overwrite an existing filesystem

                 file.

               </para>

             </remarks>

        </member>

        <member name="F:Ionic.Zip.ExtractExistingFileAction.Throw">

            <summary>

            Throw an exception when extraction would overwrite an existing file. (For

            COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ExtractExistingFileAction.OverwriteSilently">

            <summary>

            When extraction would overwrite an existing file, overwrite the file silently.

            The overwrite will happen even if the target file is marked as read-only.

            (For COM clients, this is a 1.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ExtractExistingFileAction.DoNotOverwrite">

            <summary>

            When extraction would overwrite an existing file, don't overwrite the file, silently. 

            (For COM clients, this is a 2.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ExtractExistingFileAction.InvokeExtractProgressEvent">

            <summary>

            When extraction would overwrite an existing file, invoke the ExtractProgress

            event, using an event type of <see cref="F:Ionic.Zip.ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite"/>.  In

            this way, the application can decide, just-in-time, whether to overwrite the

            file. For example, a GUI application may wish to pop up a dialog to allow

            the user to choose. You may want to examine the <see cref="P:Ionic.Zip.ExtractProgressEventArgs.ExtractLocation"/> property before making

            the decision. If, after your processing in the Extract progress event, you

            want to NOT extract the file, set <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

            on the <c>ZipProgressEventArgs.CurrentEntry</c> to <c>DoNotOverwrite</c>.

            If you do want to extract the file, set <c>ZipEntry.ExtractExistingFile</c>

            to <c>OverwriteSilently</c>.  If you want to cancel the Extraction, set

            <c>ZipProgressEventArgs.Cancel</c> to true.  Cancelling differs from using

            DoNotOverwrite in that a cancel will not extract any further entries, if

            there are any.  (For COM clients, the value of this enum is a 3.)

            </summary>

        </member>

        <member name="T:Ionic.LogicalConjunction">

            <summary>

            Enumerates the options for a logical conjunction. This enum is intended for use

            internally by the FileSelector class.

            </summary>

        </member>

        <member name="T:Ionic.FileSelector">

             <summary>

               FileSelector encapsulates logic that selects files from a source - a zip file

               or the filesystem - based on a set of criteria.  This class is used internally

               by the DotNetZip library, in particular for the AddSelectedFiles() methods.

               This class can also be used independently of the zip capability in DotNetZip.

             </summary>

             <remarks>

             <para>

               The FileSelector class is used internally by the ZipFile class for selecting

               files for inclusion into the ZipFile, when the <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)"/> method, or one of

               its overloads, is called.  It's also used for the <see cref="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String)"/> methods.  Typically, an

               application that creates or manipulates Zip archives will not directly

               interact with the FileSelector class.

             </para>

             <para>

               Some applications may wish to use the FileSelector class directly, to

               select files from disk volumes based on a set of criteria, without creating or

               querying Zip archives.  The file selection criteria include: a pattern to

               match the filename; the last modified, created, or last accessed time of the

               file; the size of the file; and the attributes of the file.

             </para>

             <para>

               Consult the documentation for <see cref="P:Ionic.FileSelector.SelectionCriteria"/>

               for more information on specifying the selection criteria.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.FileSelector.#ctor(System.String)">

             <summary>

               Constructor that allows the caller to specify file selection criteria.

             </summary>

             <remarks>

             <para>

               This constructor allows the caller to specify a set of criteria for

               selection of files.

             </para>

             <para>

               See <see cref="P:Ionic.FileSelector.SelectionCriteria"/> for a description of

               the syntax of the selectionCriteria string.

             </para>

             <para>

               By default the FileSelector will traverse NTFS Reparse Points.  To

               change this, use <see cref="M:Ionic.FileSelector.#ctor(System.String,System.Boolean)">FileSelector(String, bool)</see>.

             </para>

             </remarks>

             <param name="selectionCriteria">The criteria for file selection.</param>

        </member>

        <member name="M:Ionic.FileSelector.#ctor(System.String,System.Boolean)">

             <summary>

               Constructor that allows the caller to specify file selection criteria.

             </summary>

             <remarks>

             <para>

               This constructor allows the caller to specify a set of criteria for

               selection of files.

             </para>

             <para>

               See <see cref="P:Ionic.FileSelector.SelectionCriteria"/> for a description of

               the syntax of the selectionCriteria string.

             </para>

             </remarks>

             <param name="selectionCriteria">The criteria for file selection.</param>

             <param name="traverseDirectoryReparsePoints">

             whether to traverse NTFS reparse points (junctions).

             </param>

        </member>

        <member name="M:Ionic.FileSelector.ToString">

            <summary>

            Returns a string representation of the FileSelector object.

            </summary>

            <returns>The string representation of the boolean logic statement of the file

            selection criteria for this instance. </returns>

        </member>

        <member name="M:Ionic.FileSelector.SelectFiles(System.String)">

             <summary>

               Returns the names of the files in the specified directory

               that fit the selection criteria specified in the FileSelector.

             </summary>

             <remarks>

               This is equivalent to calling <see cref="M:Ionic.FileSelector.SelectFiles(System.String,System.Boolean)"/>

               with recurseDirectories = false.

             </remarks>

             <param name="directory">

               The name of the directory over which to apply the FileSelector

               criteria.

             </param>

             <returns>

               A collection of strings containing fully-qualified pathnames of files

               that match the criteria specified in the FileSelector instance.

             </returns>

        </member>

        <member name="M:Ionic.FileSelector.SelectFiles(System.String,System.Boolean)">

             <summary>

               Returns the names of the files in the specified directory that fit the

               selection criteria specified in the FileSelector, optionally recursing

               through subdirectories.

             </summary>

             <remarks>

               This method applies the file selection criteria contained in the

               FileSelector to the files contained in the given directory, and

               returns the names of files that conform to the criteria.

             </remarks>

             <param name="directory">

               The name of the directory over which to apply the FileSelector

               criteria.

             </param>

             <param name="recurseDirectories">

               Whether to recurse through subdirectories when applying the file

               selection criteria.

             </param>

             <returns>

               A collection of strings containing fully-qualified pathnames of files

               that match the criteria specified in the FileSelector instance.

             </returns>

        </member>

        <member name="M:Ionic.FileSelector.SelectEntries(Ionic.Zip.ZipFile)">

             <summary>

             Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.

             </summary>

             <remarks>

             <para>

             This method applies the criteria set in the FileSelector instance (as described in

             the <see cref="P:Ionic.FileSelector.SelectionCriteria"/>) to the specified ZipFile.  Using this

             method, for example, you can retrieve all entries from the given ZipFile that

             have filenames ending in .txt.

             </para>

             <para>

             Normally, applications would not call this method directly.  This method is used

             by the ZipFile class.

             </para>

             <para>

             Using the appropriate SelectionCriteria, you can retrieve entries based on size,

             time, and attributes. See <see cref="P:Ionic.FileSelector.SelectionCriteria"/> for a

             description of the syntax of the SelectionCriteria string.

             </para>

             </remarks>

             <param name="zip">The ZipFile from which to retrieve entries.</param>

             <returns>a collection of ZipEntry objects that conform to the criteria.</returns>

        </member>

        <member name="M:Ionic.FileSelector.SelectEntries(Ionic.Zip.ZipFile,System.String)">

             <summary>

             Retrieve the ZipEntry items in the ZipFile that conform to the specified criteria.

             </summary>

             <remarks>

             <para>

             This method applies the criteria set in the FileSelector instance (as described in

             the <see cref="P:Ionic.FileSelector.SelectionCriteria"/>) to the specified ZipFile.  Using this

             method, for example, you can retrieve all entries from the given ZipFile that

             have filenames ending in .txt.

             </para>

             <para>

             Normally, applications would not call this method directly.  This method is used

             by the ZipFile class.

             </para>

             <para>

             This overload allows the selection of ZipEntry instances from the ZipFile to be restricted

             to entries contained within a particular directory in the ZipFile.

             </para>

             <para>

             Using the appropriate SelectionCriteria, you can retrieve entries based on size,

             time, and attributes. See <see cref="P:Ionic.FileSelector.SelectionCriteria"/> for a

             description of the syntax of the SelectionCriteria string.

             </para>

             </remarks>

             <param name="zip">The ZipFile from which to retrieve entries.</param>

             <param name="directoryPathInArchive">

             the directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <returns>a collection of ZipEntry objects that conform to the criteria.</returns>

        </member>

        <member name="P:Ionic.FileSelector.SelectionCriteria">

             <summary>

               The string specifying which files to include when retrieving.

             </summary>

             <remarks>

             <para>

               Specify the criteria in statements of 3 elements: a noun, an operator,

               and a value.  Consider the string "name != *.doc" .  The noun is

               "name".  The operator is "!=", implying "Not Equal".  The value is

               "*.doc".  That criterion, in English, says "all files with a name that

               does not end in the .doc extension."

             </para>

             <para>

               Supported nouns include "name" (or "filename") for the filename;

               "atime", "mtime", and "ctime" for last access time, last modfied time,

               and created time of the file, respectively; "attributes" (or "attrs")

               for the file attributes; "size" (or "length") for the file length

               (uncompressed); and "type" for the type of object, either a file or a

               directory.  The "attributes", "type", and "name" nouns all support =

               and != as operators.  The "size", "atime", "mtime", and "ctime" nouns

               support = and !=, and &gt;, &gt;=, &lt;, &lt;= as well.  The times are

               taken to be expressed in local time.

             </para>

             <para>

               Specify values for the file attributes as a string with one or more of

               the characters H,R,S,A,I,L in any order, implying file attributes of

               Hidden, ReadOnly, System, Archive, NotContextIndexed, and ReparsePoint

               (symbolic link) respectively.

             </para>

             <para>

               To specify a time, use YYYY-MM-DD-HH:mm:ss or YYYY/MM/DD-HH:mm:ss as

               the format.  If you omit the HH:mm:ss portion, it is assumed to be

               00:00:00 (midnight).

             </para>

             <para>

               The value for a size criterion is expressed in integer quantities of

               bytes, kilobytes (use k or kb after the number), megabytes (m or mb),

               or gigabytes (g or gb).

             </para>

             <para>

               The value for a name is a pattern to match against the filename,

               potentially including wildcards.  The pattern follows CMD.exe glob

               rules: * implies one or more of any character, while ?  implies one

               character.  If the name pattern contains any slashes, it is matched to

               the entire filename, including the path; otherwise, it is matched

               against only the filename without the path.  This means a pattern of

               "*\*.*" matches all files one directory level deep, while a pattern of

               "*.*" matches all files in all directories.

             </para>

             <para>

               To specify a name pattern that includes spaces, use single quotes

               around the pattern.  A pattern of "'* *.*'" will match all files that

               have spaces in the filename.  The full criteria string for that would

               be "name = '* *.*'" .

             </para>

             <para>

               The value for a type criterion is either F (implying a file) or D

               (implying a directory).

             </para>

             <para>

               Some examples:

             </para>

             <list type="table">

               <listheader>

                 <term>criteria</term>

                 <description>Files retrieved</description>

               </listheader>

               <item>

                 <term>name != *.xls </term>

                 <description>any file with an extension that is not .xls

                 </description>

               </item>

               <item>

                 <term>name = *.mp3 </term>

                 <description>any file with a .mp3 extension.

                 </description>

               </item>

               <item>

                 <term>*.mp3</term>

                 <description>(same as above) any file with a .mp3 extension.

                 </description>

               </item>

               <item>

                 <term>attributes = A </term>

                 <description>all files whose attributes include the Archive bit.

                 </description>

               </item>

               <item>

                 <term>attributes != H </term>

                 <description>all files whose attributes do not include the Hidden bit.

                 </description>

               </item>

               <item>

                 <term>mtime &gt; 2009-01-01</term>

                 <description>all files with a last modified time after January 1st, 2009.

                 </description>

               </item>

               <item>

                 <term>ctime &gt; 2009/01/01-03:00:00</term>

                 <description>all files with a created time after 3am (local time),

                 on January 1st, 2009.

                 </description>

               </item>

               <item>

                 <term>size &gt; 2gb</term>

                 <description>all files whose uncompressed size is greater than 2gb.

                 </description>

               </item>

               <item>

                 <term>type = D</term>

                 <description>all directories in the filesystem. </description>

               </item>

             </list>

             <para>

               You can combine criteria with the conjunctions AND, OR, and XOR. Using

               a string like "name = *.txt AND size &gt;= 100k" for the

               selectionCriteria retrieves entries whose names end in .txt, and whose

               uncompressed size is greater than or equal to 100 kilobytes.

             </para>

             <para>

               For more complex combinations of criteria, you can use parenthesis to

               group clauses in the boolean logic.  Absent parenthesis, the

               precedence of the criterion atoms is determined by order of

               appearance.  Unlike the C# language, the AND conjunction does not take

               precendence over the logical OR.  This is important only in strings

               that contain 3 or more criterion atoms.  In other words, "name = *.txt

               and size &gt; 1000 or attributes = H" implies "((name = *.txt AND size

               &gt; 1000) OR attributes = H)" while "attributes = H OR name = *.txt

               and size &gt; 1000" evaluates to "((attributes = H OR name = *.txt)

               AND size &gt; 1000)".  When in doubt, use parenthesis.

             </para>

             <para>

               Using time properties requires some extra care. If you want to

               retrieve all entries that were last updated on 2009 February 14,

               specify "mtime &gt;= 2009-02-14 AND mtime &lt; 2009-02-15".  Read this

               to say: all files updated after 12:00am on February 14th, until

               12:00am on February 15th.  You can use the same bracketing approach to

               specify any time period - a year, a month, a week, and so on.

             </para>

             <para>

               The syntax allows one special case: if you provide a string with no

               spaces, it is treated as a pattern to match for the filename.

               Therefore a string like "*.xls" will be equivalent to specifying "name

               = *.xls".  This "shorthand" notation does not work with compound

               criteria.

             </para>

             <para>

               There is no logic in this class that insures that the inclusion

               criteria are internally consistent.  For example, it's possible to

               specify criteria that says the file must have a size of less than 100

               bytes, as well as a size that is greater than 1000 bytes.  Obviously

               no file will ever satisfy such criteria, but this class does not check

               for or detect such inconsistencies.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

               Thrown in the setter if the value has an invalid syntax.

             </exception>

        </member>

        <member name="P:Ionic.FileSelector.TraverseReparsePoints">

            <summary>

             Indicates whether searches will traverse NTFS reparse points, like Junctions.

            </summary>

        </member>

        <member name="T:Ionic.EnumUtil">

            <summary>

            Summary description for EnumUtil.

            </summary>

        </member>

        <member name="M:Ionic.EnumUtil.GetDescription(System.Enum)">

            <summary>

              Returns the value of the DescriptionAttribute if the specified Enum

              value has one.  If not, returns the ToString() representation of the

              Enum value.

            </summary>

            <param name="value">The Enum to get the description for</param>

            <returns></returns>

        </member>

        <member name="M:Ionic.EnumUtil.Parse(System.Type,System.String)">

            <summary>

              Converts the string representation of the name or numeric value of one

              or more enumerated constants to an equivalent enumerated object.

              Note: use the DescriptionAttribute on enum values to enable this.

            </summary>

            <param name="enumType">The System.Type of the enumeration.</param>

            <param name="stringRepresentation">

              A string containing the name or value to convert.

            </param>

            <returns></returns>

        </member>

        <member name="M:Ionic.EnumUtil.Parse(System.Type,System.String,System.Boolean)">

            <summary>

              Converts the string representation of the name or numeric value of one

              or more enumerated constants to an equivalent enumerated object.  A

              parameter specified whether the operation is case-sensitive.  Note:

              use the DescriptionAttribute on enum values to enable this.

            </summary>

            <param name="enumType">The System.Type of the enumeration.</param>

            <param name="stringRepresentation">

              A string containing the name or value to convert.

            </param>

            <param name="ignoreCase">

              Whether the operation is case-sensitive or not.</param>

            <returns></returns>

        </member>

        <member name="T:Ionic.Zip.WinZipAesCrypto">

             <summary>

               This is a helper class supporting WinZip AES encryption.

               This class is intended for use only by the DotNetZip library.

             </summary>

             <remarks>

               Most uses of the DotNetZip library will not involve direct calls into

               the WinZipAesCrypto class.  Instead, the WinZipAesCrypto class is

               instantiated and used by the ZipEntry() class when WinZip AES

               encryption or decryption on an entry is employed.

             </remarks>

        </member>

        <member name="T:Ionic.Zip.WinZipAesCipherStream">

             <summary>

               A stream that encrypts as it writes, or decrypts as it reads.  The

               Crypto is AES in CTR (counter) mode, which is compatible with the AES

               encryption employed by WinZip 12.0.

             </summary>

             <remarks>

               <para>

                 The AES/CTR encryption protocol used by WinZip works like this:

                   - start with a counter, initialized to zero.

                   - to encrypt, take the data by 16-byte blocks. For each block:

                     - apply the transform to the counter

                     - increement the counter

                     - XOR the result of the transform with the plaintext to

                       get the ciphertext.

                     - compute the mac on the encrypted bytes

                   - when finished with all blocks, store the computed MAC.

                   - to decrypt, take the data by 16-byte blocks. For each block:

                     - compute the mac on the encrypted bytes,

                     - apply the transform to the counter

                     - increement the counter

                     - XOR the result of the transform with the ciphertext to

                       get the plaintext.

                   - when finished with all blocks, compare the computed MAC against

                     the stored MAC

               </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.WinZipAesCipherStream.#ctor(System.IO.Stream,Ionic.Zip.WinZipAesCrypto,System.Int64,Ionic.Zip.CryptoMode)">

            <summary>

            The constructor.

            </summary>

            <param name="s">The underlying stream</param>

            <param name="mode">To either encrypt or decrypt.</param>

            <param name="cryptoParams">The pre-initialized WinZipAesCrypto object.</param>

            <param name="length">The maximum number of bytes to read from the stream.</param>

        </member>

        <member name="M:Ionic.Zip.WinZipAesCipherStream.Close">

            <summary>

              Close the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zip.WinZipAesCipherStream.Flush">

            <summary>

            Flush the content in the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zip.WinZipAesCipherStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            This method throws a NotImplementedException.

            </summary>

        </member>

        <member name="M:Ionic.Zip.WinZipAesCipherStream.SetLength(System.Int64)">

            <summary>

            This method throws a NotImplementedException.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.FinalAuthentication">

            <summary>

            Returns the final HMAC-SHA1-80 for the data that was encrypted.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.CanRead">

            <summary>

            Returns true if the stream can be read.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.CanSeek">

            <summary>

            Always returns false.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.CanWrite">

            <summary>

            Returns true if the CryptoMode is Encrypt.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.Length">

            <summary>

            Getting this property throws a NotImplementedException.

            </summary>

        </member>

        <member name="P:Ionic.Zip.WinZipAesCipherStream.Position">

            <summary>

            Getting or Setting this property throws a NotImplementedException.

            </summary>

        </member>

        <member name="T:Ionic.Zip.BadPasswordException">

            <summary>

            Issued when an <c>ZipEntry.ExtractWithPassword()</c> method is invoked

            with an incorrect password.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipException">

            <summary>

            Base class for all exceptions defined by and throw by the Zip library.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.ZipException.#ctor(System.String,System.Exception)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

            <param name="innerException">The innerException for this exception.</param>

        </member>

        <member name="M:Ionic.Zip.ZipException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="M:Ionic.Zip.BadPasswordException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadPasswordException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadPasswordException.#ctor(System.String,System.Exception)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

            <param name="innerException">The innerException for this exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadPasswordException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="T:Ionic.Zip.BadReadException">

            <summary>

            Indicates that a read was attempted on a stream, and bad or incomplete data was

            received.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadReadException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadReadException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadReadException.#ctor(System.String,System.Exception)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

            <param name="innerException">The innerException for this exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadReadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="T:Ionic.Zip.BadCrcException">

            <summary>

            Issued when an CRC check fails upon extracting an entry from a zip archive.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadCrcException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadCrcException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadCrcException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="T:Ionic.Zip.SfxGenerationException">

            <summary>

            Issued when errors occur saving a self-extracting archive.

            </summary>

        </member>

        <member name="M:Ionic.Zip.SfxGenerationException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.SfxGenerationException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.SfxGenerationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="T:Ionic.Zip.BadStateException">

            <summary>

            Indicates that an operation was attempted on a ZipFile which was not possible

            given the state of the instance. For example, if you call <c>Save()</c> on a ZipFile

            which has no filename set, you can get this exception.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadStateException.#ctor">

            <summary>

            Default ctor.

            </summary>

        </member>

        <member name="M:Ionic.Zip.BadStateException.#ctor(System.String)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadStateException.#ctor(System.String,System.Exception)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="message">The message in the exception.</param>

            <param name="innerException">The innerException for this exception.</param>

        </member>

        <member name="M:Ionic.Zip.BadStateException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">

            <summary>

            Come on, you know how exceptions work. Why are you looking at this documentation?

            </summary>

            <param name="info">The serialization info for the exception.</param>

            <param name="context">The streaming context from which to deserialize.</param>

        </member>

        <member name="T:Ionic.Zip.SharedUtilities">

            <summary>

            Collects general purpose utility methods.

            </summary>

        </member>

        <member name="M:Ionic.Zip.SharedUtilities.GetFileLength(System.String)">

            private null constructor

        </member>

        <member name="M:Ionic.Zip.SharedUtilities.NormalizePathForUseInZipFile(System.String)">

            <summary>

            Utility routine for transforming path names from filesystem format (on Windows that means backslashes) to

            a format suitable for use within zipfiles. This means trimming the volume letter and colon (if any) And

            swapping backslashes for forward slashes.

            </summary>

            <param name="pathName">source path.</param>

            <returns>transformed path</returns>

        </member>

        <member name="M:Ionic.Zip.SharedUtilities.FindSignature(System.IO.Stream,System.Int32)">

             <summary>

               Finds a signature in the zip stream. This is useful for finding

               the end of a zip entry, for example, or the beginning of the next ZipEntry.

             </summary>

             <remarks>

               <para>

                 Scans through 64k at a time.

               </para>

               <para>

                 If the method fails to find the requested signature, the stream Position

                 after completion of this method is unchanged. If the method succeeds in

                 finding the requested signature, the stream position after completion is

                 direct AFTER the signature found in the stream.

               </para>

             </remarks>

             <param name="stream">The stream to search</param>

             <param name="SignatureToFind">The 4-byte signature to find</param>

             <returns>The number of bytes read</returns>

        </member>

        <member name="M:Ionic.Zip.SharedUtilities.CreateAndOpenUniqueTempFile(System.String,System.IO.Stream@,System.String@)">

            <summary>

              Create a pseudo-random filename, suitable for use as a temporary

              file, and open it.

            </summary>

            <remarks>

            <para>

              The System.IO.Path.GetRandomFileName() method is not available on

              the Compact Framework, so this library provides its own substitute

              on NETCF.

            </para>

            <para>

              This method produces a filename of the form

              DotNetZip-xxxxxxxx.tmp, where xxxxxxxx is replaced by randomly

              chosen characters, and creates that file.

            </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zip.SharedUtilities.ReadWithRetry(System.IO.Stream,System.Byte[],System.Int32,System.Int32,System.String)">

            <summary>

            Workitem 7889: handle ERROR_LOCK_VIOLATION during read

            </summary>

            <remarks>

            This could be gracefully handled with an extension attribute, but

            This assembly is built for .NET 2.0, so I cannot use them.

            </remarks>

        </member>

        <member name="T:Ionic.Zip.CountingStream">

            <summary>

              A decorator stream. It wraps another stream, and performs bookkeeping

              to keep track of the stream Position.

            </summary>

            <remarks>

              <para>

                In some cases, it is not possible to get the Position of a stream, let's

                say, on a write-only output stream like ASP.NET's

                <c>Response.OutputStream</c>, or on a different write-only stream

                provided as the destination for the zip by the application.  In this

                case, programmers can use this counting stream to count the bytes read

                or written.

              </para>

              <para>

                Consider the scenario of an application that saves a self-extracting

                archive (SFX), that uses a custom SFX stub.

              </para>

              <para>

                Saving to a filesystem file, the application would open the

                filesystem file (getting a <c>FileStream</c>), save the custom sfx stub

                into it, and then call <c>ZipFile.Save()</c>, specifying the same

                FileStream. <c>ZipFile.Save()</c> does the right thing for the zipentry

                offsets, by inquiring the Position of the <c>FileStream</c> before writing

                any data, and then adding that initial offset into any ZipEntry

                offsets in the zip directory. Everything works fine.

              </para>

              <para>

                Now suppose the application is an ASPNET application and it saves

                directly to <c>Response.OutputStream</c>. It's not possible for DotNetZip to

                inquire the <c>Position</c>, so the offsets for the SFX will be wrong.

              </para>

              <para>

                The workaround is for the application to use this class to wrap

                <c>HttpResponse.OutputStream</c>, then write the SFX stub and the ZipFile

                into that wrapper stream. Because <c>ZipFile.Save()</c> can inquire the

                <c>Position</c>, it will then do the right thing with the offsets.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zip.CountingStream.#ctor(System.IO.Stream)">

            <summary>

            The constructor.

            </summary>

            <param name="stream">The underlying stream</param>

        </member>

        <member name="M:Ionic.Zip.CountingStream.Adjust(System.Int64)">

             <summary>

                Adjust the byte count on the stream.

             </summary>

             <param name='delta'>

               the number of bytes to subtract from the count.

             </param>

             <remarks>

               <para>

                 Subtract delta from the count of bytes written to the stream.

                 This is necessary when seeking back, and writing additional data,

                 as happens in some cases when saving Zip files.

               </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.CountingStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

              The read method.

            </summary>

            <param name="buffer">The buffer to hold the data read from the stream.</param>

            <param name="offset">the offset within the buffer to copy the first byte read.</param>

            <param name="count">the number of bytes to read.</param>

            <returns>the number of bytes read, after decryption and decompression.</returns>

        </member>

        <member name="M:Ionic.Zip.CountingStream.Write(System.Byte[],System.Int32,System.Int32)">

            <summary>

              Write data into the stream.

            </summary>

            <param name="buffer">The buffer holding data to write to the stream.</param>

            <param name="offset">the offset within that data array to find the first byte to write.</param>

            <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zip.CountingStream.Flush">

            <summary>

              Flushes the underlying stream.

            </summary>

        </member>

        <member name="M:Ionic.Zip.CountingStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

              Seek in the stream.

            </summary>

            <param name="offset">the offset point to seek to</param>

            <param name="origin">the reference point from which to seek</param>

            <returns>The new position</returns>

        </member>

        <member name="M:Ionic.Zip.CountingStream.SetLength(System.Int64)">

             <summary>

               Set the length of the underlying stream.  Be careful with this!

             </summary>

             <param name='value'>the length to set on the underlying stream.</param>

        </member>

        <member name="P:Ionic.Zip.CountingStream.WrappedStream">

            <summary>

              Gets the wrapped stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.BytesWritten">

            <summary>

              The count of bytes written out to the stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.BytesRead">

            <summary>

              the count of bytes that have been read from the stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.CanRead">

            <summary>

              Whether the stream can be read.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.CanSeek">

            <summary>

              Whether it is possible to call Seek() on the stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.CanWrite">

            <summary>

              Whether it is possible to call Write() on the stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.Length">

            <summary>

              The length of the underlying stream.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.ComputedPosition">

            <summary>

              Returns the sum of number of bytes written, plus the initial

              offset before writing.

            </summary>

        </member>

        <member name="P:Ionic.Zip.CountingStream.Position">

            <summary>

              The Position of the stream.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipCrypto">

             <summary>

               This class implements the "traditional" or "classic" PKZip encryption,

               which today is considered to be weak. On the other hand it is

               ubiquitous. This class is intended for use only by the DotNetZip

               library.

             </summary>

             <remarks>

               Most uses of the DotNetZip library will not involve direct calls into

               the ZipCrypto class.  Instead, the ZipCrypto class is instantiated and

               used by the ZipEntry() class when encryption or decryption on an entry

               is employed.  If for some reason you really wanted to use a weak

               encryption algorithm in some other application, you might use this

               library.  But you would be much better off using one of the built-in

               strong encryption libraries in the .NET Framework, like the AES

               algorithm or SHA.

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipCrypto.#ctor">

             <summary>

               The default constructor for ZipCrypto.

             </summary>

             <remarks>

               This class is intended for internal use by the library only. It's

               probably not useful to you. Seriously.  Stop reading this

               documentation.  It's a waste of your time.  Go do something else.

               Check the football scores. Go get an ice cream with a friend.

               Seriously.

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipCrypto.DecryptMessage(System.Byte[],System.Int32)">

             <summary>

               Call this method on a cipher text to render the plaintext. You must

               first initialize the cipher with a call to InitCipher.

             </summary>

             <example>

               <code>

                 var cipher = new ZipCrypto();

                 cipher.InitCipher(Password);

                 // Decrypt the header.  This has a side effect of "further initializing the

                 // encryption keys" in the traditional zip encryption.

                 byte[] DecryptedMessage = cipher.DecryptMessage(EncryptedMessage);

               </code>

             </example>

             <param name="cipherText">The encrypted buffer.</param>

             <param name="length">

               The number of bytes to encrypt.

               Should be less than or equal to CipherText.Length.

             </param>

             <returns>The plaintext.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipCrypto.EncryptMessage(System.Byte[],System.Int32)">

             <summary>

               This is the converse of DecryptMessage.  It encrypts the plaintext

               and produces a ciphertext.

             </summary>

             <param name="plainText">The plain text buffer.</param>

             <param name="length">

               The number of bytes to encrypt.

               Should be less than or equal to plainText.Length.

             </param>

             <returns>The ciphertext.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipCrypto.InitCipher(System.String)">

             <summary>

               This initializes the cipher with the given password.

               See AppNote.txt for details.

             </summary>

             <param name="passphrase">

               The passphrase for encrypting or decrypting with this cipher.

             </param>

             <remarks>

             <code>

             Step 1 - Initializing the encryption keys

             -----------------------------------------

             Start with these keys:

             Key(0) := 305419896 (0x12345678)

             Key(1) := 591751049 (0x23456789)

             Key(2) := 878082192 (0x34567890)

             Then, initialize the keys with a password:

             loop for i from 0 to length(password)-1

                 update_keys(password(i))

             end loop

             Where update_keys() is defined as:

             update_keys(char):

               Key(0) := crc32(key(0),char)

               Key(1) := Key(1) + (Key(0) bitwiseAND 000000ffH)

               Key(1) := Key(1) * 134775813 + 1

               Key(2) := crc32(key(2),key(1) rightshift 24)

             end update_keys

             Where crc32(old_crc,char) is a routine that given a CRC value and a

             character, returns an updated CRC value after applying the CRC-32

             algorithm described elsewhere in this document.

             </code>

             <para>

               After the keys are initialized, then you can use the cipher to

               encrypt the plaintext.

             </para>

             <para>

               Essentially we encrypt the password with the keys, then discard the

               ciphertext for the password. This initializes the keys for later use.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipCrypto.MagicByte">

            <summary>

            From AppNote.txt:

            unsigned char decrypt_byte()

                local unsigned short temp

                temp :=- Key(2) | 2

                decrypt_byte := (temp * (temp ^ 1)) bitshift-right 8

            end decrypt_byte

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipCipherStream">

            <summary>

              A Stream for reading and concurrently decrypting data from a zip file,

              or for writing and concurrently encrypting data to a zip file.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipCipherStream.#ctor(System.IO.Stream,Ionic.Zip.ZipCrypto,Ionic.Zip.CryptoMode)">

            <summary>  The constructor. </summary>

            <param name="s">The underlying stream</param>

            <param name="mode">To either encrypt or decrypt.</param>

            <param name="cipher">The pre-initialized ZipCrypto object.</param>

        </member>

        <member name="T:Ionic.Zip.WriteDelegate">

             <summary>

               Delegate in which the application writes the <c>ZipEntry</c> content for the named entry.

             </summary>

             <param name="entryName">The name of the entry that must be written.</param>

             <param name="stream">The stream to which the entry data should be written.</param>

             <remarks>

               When you add an entry and specify a <c>WriteDelegate</c>, via <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.WriteDelegate)"/>, the application

               code provides the logic that writes the entry data directly into the zip file.

             </remarks>

             <example>

             This example shows how to define a WriteDelegate that obtains a DataSet, and then

             writes the XML for the DataSet into the zip archive.  There's no need to

             save the XML to a disk file first.

             <code lang="C#">

             private void WriteEntry (String filename, Stream output)

             {

                 DataSet ds1 = ObtainDataSet();

                 ds1.WriteXml(output);

             }

             private void Run()

             {

                 using (var zip = new ZipFile())

                 {

                     zip.AddEntry(zipEntryName, WriteEntry);

                     zip.Save(zipFileName);

                 }

             }

             </code>

             <code lang="vb">

             Private Sub WriteEntry (ByVal filename As String, ByVal output As Stream)

                 DataSet ds1 = ObtainDataSet()

                 ds1.WriteXml(stream)

             End Sub

             Public Sub Run()

                 Using zip = New ZipFile

                     zip.AddEntry(zipEntryName, New WriteDelegate(AddressOf WriteEntry))

                     zip.Save(zipFileName)

                 End Using

             End Sub

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.WriteDelegate)"/>

        </member>

        <member name="T:Ionic.Zip.OpenDelegate">

             <summary>

               Delegate in which the application opens the stream, just-in-time, for the named entry.

             </summary>

             <param name="entryName">

             The name of the ZipEntry that the application should open the stream for.

             </param>

             <remarks>

               When you add an entry via <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>, the application code provides the logic that

               opens and closes the stream for the given ZipEntry.

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>

        </member>

        <member name="T:Ionic.Zip.CloseDelegate">

             <summary>

               Delegate in which the application closes the stream, just-in-time, for the named entry.

             </summary>

             <param name="entryName">

             The name of the ZipEntry that the application should close the stream for.

             </param>

             <param name="stream">The stream to be closed.</param>

             <remarks>

               When you add an entry via <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>, the application code provides the logic that

               opens and closes the stream for the given ZipEntry.

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>

        </member>

        <member name="T:Ionic.Zip.SetCompressionCallback">

             <summary>

               Delegate for the callback by which the application tells the

               library the CompressionLevel to use for a file.

             </summary>

             <remarks>

             <para>

               Using this callback, the application can, for example, specify that

               previously-compressed files (.mp3, .png, .docx, etc) should use a

               <c>CompressionLevel</c> of <c>None</c>, or can set the compression level based

               on any other factor.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.SetCompression"/>

        </member>

        <member name="T:Ionic.Zip.ZipProgressEventType">

            <summary>

              In an EventArgs type, indicates which sort of progress event is being

              reported.

            </summary>

            <remarks>

              There are events for reading, events for saving, and events for

              extracting. This enumeration allows a single EventArgs type to be sued to

              describe one of multiple subevents. For example, a SaveProgress event is

              invoked before, after, and during the saving of a single entry.  The value

              of an enum with this type, specifies which event is being triggered.  The

              same applies to Extraction, Reading and Adding events.

            </remarks>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Adding_Started">

            <summary>

            Indicates that a Add() operation has started.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Adding_AfterAddEntry">

            <summary>

            Indicates that an individual entry in the archive has been added.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Adding_Completed">

            <summary>

            Indicates that a Add() operation has completed.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Reading_Started">

            <summary>

            Indicates that a Read() operation has started.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Reading_BeforeReadEntry">

            <summary>

            Indicates that an individual entry in the archive is about to be read.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Reading_AfterReadEntry">

            <summary>

            Indicates that an individual entry in the archive has just been read.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Reading_Completed">

            <summary>

            Indicates that a Read() operation has completed.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Reading_ArchiveBytesRead">

            <summary>

            The given event reports the number of bytes read so far

            during a Read() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_Started">

            <summary>

            Indicates that a Save() operation has started.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_BeforeWriteEntry">

            <summary>

            Indicates that an individual entry in the archive is about to be written.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_AfterWriteEntry">

            <summary>

            Indicates that an individual entry in the archive has just been saved.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_Completed">

            <summary>

            Indicates that a Save() operation has completed.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_AfterSaveTempArchive">

            <summary>

            Indicates that the zip archive has been created in a

            temporary location during a Save() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_BeforeRenameTempArchive">

            <summary>

            Indicates that the temporary file is about to be renamed to the final archive

            name during a Save() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_AfterRenameTempArchive">

            <summary>

            Indicates that the temporary file is has just been renamed to the final archive

            name during a Save() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_AfterCompileSelfExtractor">

            <summary>

            Indicates that the self-extracting archive has been compiled

            during a Save() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Saving_EntryBytesRead">

            <summary>

            The given event is reporting the number of source bytes that have run through the compressor so far

            during a Save() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_BeforeExtractEntry">

            <summary>

            Indicates that an entry is about to be extracted.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_AfterExtractEntry">

            <summary>

            Indicates that an entry has just been extracted.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite">

            <summary>

              Indicates that extraction of an entry would overwrite an existing

              filesystem file. You must use

              <see cref="F:Ionic.Zip.ExtractExistingFileAction.InvokeExtractProgressEvent">

              ExtractExistingFileAction.InvokeExtractProgressEvent</see> in the call

              to <c>ZipEntry.Extract()</c> in order to receive this event.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_EntryBytesWritten">

            <summary>

              The given event is reporting the number of bytes written so far for

              the current entry during an Extract() operation.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_BeforeExtractAll">

            <summary>

            Indicates that an ExtractAll operation is about to begin.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Extracting_AfterExtractAll">

            <summary>

            Indicates that an ExtractAll operation has completed.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipProgressEventType.Error_Saving">

            <summary>

            Indicates that an error has occurred while saving a zip file.

            This generally means the file cannot be opened, because it has been

            removed, or because it is locked by another process.  It can also

            mean that the file cannot be Read, because of a range lock conflict.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipProgressEventArgs">

            <summary>

            Provides information about the progress of a save, read, or extract operation.

            This is a base class; you will probably use one of the classes derived from this one.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.EntriesTotal">

            <summary>

            The total number of entries to be saved or extracted.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.CurrentEntry">

            <summary>

            The name of the last entry saved or extracted.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.Cancel">

            <summary>

            In an event handler, set this to cancel the save or extract

            operation that is in progress.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.EventType">

            <summary>

            The type of event being reported.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.ArchiveName">

            <summary>

            Returns the archive name associated to this event.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.BytesTransferred">

            <summary>

            The number of bytes read or written so far for this entry.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipProgressEventArgs.TotalBytesToTransfer">

            <summary>

            Total number of bytes that will be read or written for this entry.

            This number will be -1 if the value cannot be determined.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ReadProgressEventArgs">

            <summary>

            Provides information about the progress of a Read operation.

            </summary>

        </member>

        <member name="T:Ionic.Zip.AddProgressEventArgs">

            <summary>

            Provides information about the progress of a Add operation.

            </summary>

        </member>

        <member name="T:Ionic.Zip.SaveProgressEventArgs">

            <summary>

            Provides information about the progress of a save operation.

            </summary>

        </member>

        <member name="M:Ionic.Zip.SaveProgressEventArgs.#ctor(System.String,System.Boolean,System.Int32,System.Int32,Ionic.Zip.ZipEntry)">

            <summary>

            Constructor for the SaveProgressEventArgs.

            </summary>

            <param name="archiveName">the name of the zip archive.</param>

            <param name="before">whether this is before saving the entry, or after</param>

            <param name="entriesTotal">The total number of entries in the zip archive.</param>

            <param name="entriesSaved">Number of entries that have been saved.</param>

            <param name="entry">The entry involved in the event.</param>

        </member>

        <member name="P:Ionic.Zip.SaveProgressEventArgs.EntriesSaved">

            <summary>

            Number of entries saved so far.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ExtractProgressEventArgs">

            <summary>

            Provides information about the progress of the extract operation.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ExtractProgressEventArgs.#ctor(System.String,System.Boolean,System.Int32,System.Int32,Ionic.Zip.ZipEntry,System.String)">

            <summary>

            Constructor for the ExtractProgressEventArgs.

            </summary>

            <param name="archiveName">the name of the zip archive.</param>

            <param name="before">whether this is before saving the entry, or after</param>

            <param name="entriesTotal">The total number of entries in the zip archive.</param>

            <param name="entriesExtracted">Number of entries that have been extracted.</param>

            <param name="entry">The entry involved in the event.</param>

            <param name="extractLocation">The location to which entries are extracted.</param>

        </member>

        <member name="P:Ionic.Zip.ExtractProgressEventArgs.EntriesExtracted">

            <summary>

            Number of entries extracted so far.  This is set only if the

            EventType is Extracting_BeforeExtractEntry or Extracting_AfterExtractEntry, and

            the Extract() is occurring witin the scope of a call to ExtractAll().

            </summary>

        </member>

        <member name="P:Ionic.Zip.ExtractProgressEventArgs.ExtractLocation">

            <summary>

            Returns the extraction target location, a filesystem path.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipErrorEventArgs">

            <summary>

            Provides information about the an error that occurred while zipping.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipErrorEventArgs.Exception">

            <summary>

            Returns the exception that occurred, if any.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipErrorEventArgs.FileName">

            <summary>

            Returns the name of the file that caused the exception, if any.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipEntry">

            <summary>

            Represents a single entry in a ZipFile. Typically, applications get a ZipEntry

            by enumerating the entries within a ZipFile, or by adding an entry to a ZipFile.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ReadDirEntry(Ionic.Zip.ZipFile,System.Collections.Generic.Dictionary{System.String,System.Object})">

             <summary>

               Reads one entry from the zip directory structure in the zip file.

             </summary>

             <param name="zf">

               The zipfile for which a directory entry will be read.  From this param, the

               method gets the ReadStream and the expected text encoding

               (ProvisionalAlternateEncoding) which is used if the entry is not marked

               UTF-8.

             </param>

             <param name="previouslySeen">

               a list of previously seen entry names; used to prevent duplicates.

             </param>

             <returns>the entry read from the archive.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.IsNotValidZipDirEntrySig(System.Int32)">

            <summary>

            Returns true if the passed-in value is a valid signature for a ZipDirEntry.

            </summary>

            <param name="signature">the candidate 4-byte signature value.</param>

            <returns>true, if the signature is valid according to the PKWare spec.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.#ctor">

            <summary>

            Default constructor.

            </summary>

            <remarks>

            Applications should never need to call this directly.  It is exposed to

            support COM Automation environments.

            </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)">

             <summary>

               Sets the NTFS Creation, Access, and Modified times for the given entry.

             </summary>

             <remarks>

             <para>

               When adding an entry from a file or directory, the Creation, Access, and

               Modified times for the given entry are automatically set from the

               filesystem values. When adding an entry from a stream or string, the

               values are implicitly set to DateTime.Now.  The application may wish to

               set these values to some arbitrary value, before saving the archive, and

               can do so using the various setters.  If you want to set all of the times,

               this method is more efficient.

             </para>

             <para>

               The values you set here will be retrievable with the <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>, <see cref="P:Ionic.Zip.ZipEntry.CreationTime"/> and <see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/> properties.

             </para>

             <para>

               When this method is called, if both <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/> and <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/> are false, then the

               <c>EmitTimesInWindowsFormatWhenSaving</c> flag is automatically set.

             </para>

             <para>

               DateTime values provided here without a DateTimeKind are assumed to be Local Time.

             </para>

             </remarks>

             <param name="created">the creation time of the entry.</param>

             <param name="accessed">the last access time of the entry.</param>

             <param name="modified">the last modified time of the entry.</param>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.CreationTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ToString">

            <summary>Provides a string representation of the instance.</summary>

            <returns>a string representation of the instance.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.Extract">

             <summary>

               Extract the entry to the filesystem, starting at the current

               working directory.

             </summary>

             <overloads>

               This method has a bunch of overloads! One of them is sure to

               be the right one for you... If you don't like these, check

               out the <c>ExtractWithPassword()</c> methods.

             </overloads>

             <seealso cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.Extract(Ionic.Zip.ExtractExistingFileAction)"/>

             <remarks>

             <para>

               This method extracts an entry from a zip file into the current

               working directory.  The path of the entry as extracted is the full

               path as specified in the zip archive, relative to the current

               working directory.  After the file is extracted successfully, the

               file attributes and timestamps are set.

             </para>

             <para>

               The action taken when extraction an entry would overwrite an

               existing file is determined by the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/> property.

             </para>

             <para>

               Within the call to <c>Extract()</c>, the content for the entry is

               written into a filesystem file, and then the last modified time of the

               file is set according to the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property on

               the entry. See the remarks the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property for

               some details about the last modified time.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.Extract(Ionic.Zip.ExtractExistingFileAction)">

             <summary>

               Extract the entry to a file in the filesystem, using the specified

               behavior when extraction would overwrite an existing file.

             </summary>

             <remarks>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the file is set after

               extraction.

             </para>

             </remarks>

             <param name="extractExistingFile">

               The action to take if extraction would overwrite an existing file.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.Extract(System.IO.Stream)">

             <summary>

               Extracts the entry to the specified stream.

             </summary>

             <remarks>

             <para>

               The caller can specify any write-able stream, for example a <see cref="T:System.IO.FileStream"/>, a <see cref="T:System.IO.MemoryStream"/>, or ASP.NET's

               <c>Response.OutputStream</c>.  The content will be decrypted and

               decompressed as necessary. If the entry is encrypted and no password

               is provided, this method will throw.

             </para>

             <para>

               The position on the stream is not reset by this method before it extracts.

               You may want to call stream.Seek() before calling ZipEntry.Extract().

             </para>

             </remarks>

             <param name="stream">

               the stream to which the entry should be extracted.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.Extract(System.String)">

             <summary>

               Extract the entry to the filesystem, starting at the specified base

               directory.

             </summary>

             <param name="baseDirectory">the pathname of the base directory</param>

             <seealso cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.Extract(System.String,Ionic.Zip.ExtractExistingFileAction)"/>

             <example>

             This example extracts only the entries in a zip file that are .txt files,

             into a directory called "textfiles".

             <code lang="C#">

             using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))

             {

               foreach (string s1 in zip.EntryFilenames)

               {

                 if (s1.EndsWith(".txt"))

                 {

                   zip[s1].Extract("textfiles");

                 }

               }

             }

             </code>

             <code lang="VB">

               Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")

                   Dim s1 As String

                   For Each s1 In zip.EntryFilenames

                       If s1.EndsWith(".txt") Then

                           zip(s1).Extract("textfiles")

                       End If

                   Next

               End Using

             </code>

             </example>

             <remarks>

             <para>

               Using this method, existing entries in the filesystem will not be

               overwritten. If you would like to force the overwrite of existing

               files, see the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/> property, or call

               <see cref="M:Ionic.Zip.ZipEntry.Extract(System.String,Ionic.Zip.ExtractExistingFileAction)"/>.

             </para>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the created file is set.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.Extract(System.String,Ionic.Zip.ExtractExistingFileAction)">

             <summary>

               Extract the entry to the filesystem, starting at the specified base

               directory, and using the specified behavior when extraction would

               overwrite an existing file.

             </summary>

             <remarks>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the created file is set.

             </para>

             </remarks>

             <example>

             <code lang="C#">

             String sZipPath = "Airborne.zip";

             String sFilePath = "Readme.txt";

             String sRootFolder = "Digado";

             using (ZipFile zip = ZipFile.Read(sZipPath))

             {

               if (zip.EntryFileNames.Contains(sFilePath))

               {

                 // use the string indexer on the zip file

                 zip[sFileName].Extract(sRootFolder,

                                        ExtractExistingFileAction.OverwriteSilently);

               }

             }

             </code>

             <code lang="VB">

             Dim sZipPath as String = "Airborne.zip"

             Dim sFilePath As String = "Readme.txt"

             Dim sRootFolder As String = "Digado"

             Using zip As ZipFile = ZipFile.Read(sZipPath)

               If zip.EntryFileNames.Contains(sFilePath)

                 ' use the string indexer on the zip file

                 zip(sFilePath).Extract(sRootFolder, _

                                        ExtractExistingFileAction.OverwriteSilently)

               End If

             End Using

             </code>

             </example>

             <param name="baseDirectory">the pathname of the base directory</param>

             <param name="extractExistingFile">

             The action to take if extraction would overwrite an existing file.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ExtractWithPassword(System.String)">

             <summary>

               Extract the entry to the filesystem, using the current working directory

               and the specified password.

             </summary>

             <overloads>

               This method has a bunch of overloads! One of them is sure to be

               the right one for you...

             </overloads>

             <seealso cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.ExtractWithPassword(Ionic.Zip.ExtractExistingFileAction,System.String)"/>

             <remarks>

             <para>

               Existing entries in the filesystem will not be overwritten. If you

               would like to force the overwrite of existing files, see the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>property, or call

               <see cref="M:Ionic.Zip.ZipEntry.ExtractWithPassword(Ionic.Zip.ExtractExistingFileAction,System.String)"/>.

             </para>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property for some

               details about how the "last modified" time of the created file is

               set.

             </para>

             </remarks>

             <example>

               In this example, entries that use encryption are extracted using a

               particular password.

             <code>

             using (var zip = ZipFile.Read(FilePath))

             {

                 foreach (ZipEntry e in zip)

                 {

                     if (e.UsesEncryption)

                         e.ExtractWithPassword("Secret!");

                     else

                         e.Extract();

                 }

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(FilePath)

                 Dim e As ZipEntry

                 For Each e In zip

                     If (e.UsesEncryption)

                       e.ExtractWithPassword("Secret!")

                     Else

                       e.Extract

                     End If

                 Next

             End Using

             </code>

             </example>

             <param name="password">The Password to use for decrypting the entry.</param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ExtractWithPassword(System.String,System.String)">

             <summary>

               Extract the entry to the filesystem, starting at the specified base

               directory, and using the specified password.

             </summary>

             <seealso cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.ExtractWithPassword(System.String,Ionic.Zip.ExtractExistingFileAction,System.String)"/>

             <remarks>

             <para>

               Existing entries in the filesystem will not be overwritten. If you

               would like to force the overwrite of existing files, see the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>property, or call

               <see cref="M:Ionic.Zip.ZipEntry.ExtractWithPassword(Ionic.Zip.ExtractExistingFileAction,System.String)"/>.

             </para>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the created file is set.

             </para>

             </remarks>

             <param name="baseDirectory">The pathname of the base directory.</param>

             <param name="password">The Password to use for decrypting the entry.</param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ExtractWithPassword(Ionic.Zip.ExtractExistingFileAction,System.String)">

             <summary>

               Extract the entry to a file in the filesystem, relative to the

               current directory, using the specified behavior when extraction

               would overwrite an existing file.

             </summary>

             <remarks>

             <para>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the created file is set.

             </para>

             </remarks>

             <param name="password">The Password to use for decrypting the entry.</param>

             <param name="extractExistingFile">

             The action to take if extraction would overwrite an existing file.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ExtractWithPassword(System.String,Ionic.Zip.ExtractExistingFileAction,System.String)">

             <summary>

               Extract the entry to the filesystem, starting at the specified base

               directory, and using the specified behavior when extraction would

               overwrite an existing file.

             </summary>

             <remarks>

               See the remarks on the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property, for some

               details about how the last modified time of the created file is set.

             </remarks>

             <param name="baseDirectory">the pathname of the base directory</param>

             <param name="extractExistingFile">The action to take if extraction would

             overwrite an existing file.</param>

             <param name="password">The Password to use for decrypting the entry.</param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ExtractWithPassword(System.IO.Stream,System.String)">

             <summary>

               Extracts the entry to the specified stream, using the specified

               Password.  For example, the caller could extract to Console.Out, or

               to a MemoryStream.

             </summary>

             <remarks>

             <para>

               The caller can specify any write-able stream, for example a <see cref="T:System.IO.FileStream"/>, a <see cref="T:System.IO.MemoryStream"/>, or ASP.NET's

               <c>Response.OutputStream</c>.  The content will be decrypted and

               decompressed as necessary. If the entry is encrypted and no password

               is provided, this method will throw.

             </para>

             <para>

               The position on the stream is not reset by this method before it extracts.

               You may want to call stream.Seek() before calling ZipEntry.Extract().

             </para>

             </remarks>

             <param name="stream">

               the stream to which the entry should be extracted.

             </param>

             <param name="password">

               The password to use for decrypting the entry.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.OpenReader">

             <summary>

               Opens a readable stream corresponding to the zip entry in the

               archive.  The stream decompresses and decrypts as necessary, as it

               is read.

             </summary>

             <remarks>

             <para>

               DotNetZip offers a variety of ways to extract entries from a zip

               file.  This method allows an application to extract an entry by

               reading a <see cref="T:System.IO.Stream"/>.

             </para>

             <para>

               The return value is of type <see cref="T:Ionic.Crc.CrcCalculatorStream"/>.  Use it as you would any

               stream for reading.  When an application calls <see cref="M:System.IO.Stream.Read(System.Byte[],System.Int32,System.Int32)"/> on that stream, it will

               receive data from the zip entry that is decrypted and decompressed

               as necessary.

             </para>

             <para>

               <c>CrcCalculatorStream</c> adds one additional feature: it keeps a

               CRC32 checksum on the bytes of the stream as it is read.  The CRC

               value is available in the <see cref="P:Ionic.Crc.CrcCalculatorStream.Crc"/> property on the

               <c>CrcCalculatorStream</c>.  When the read is complete, your

               application

               <em>should</em> check this CRC against the <see cref="P:Ionic.Zip.ZipEntry.Crc"/>

               property on the <c>ZipEntry</c> to validate the content of the

               ZipEntry. You don't have to validate the entry using the CRC, but

               you should, to verify integrity. Check the example for how to do

               this.

             </para>

             <para>

               If the entry is protected with a password, then you need to provide

               a password prior to calling <see cref="M:Ionic.Zip.ZipEntry.OpenReader"/>, either by

               setting the <see cref="P:Ionic.Zip.ZipEntry.Password"/> property on the entry, or the

               <see cref="P:Ionic.Zip.ZipFile.Password"/> property on the <c>ZipFile</c>

               itself. Or, you can use <see cref="M:Ionic.Zip.ZipEntry.OpenReader(System.String)"/>, the

               overload of OpenReader that accepts a password parameter.

             </para>

             <para>

               If you want to extract entry data into a write-able stream that is

               already opened, like a <see cref="T:System.IO.FileStream"/>, do not

               use this method. Instead, use <see cref="M:Ionic.Zip.ZipEntry.Extract(System.IO.Stream)"/>.

             </para>

             <para>

               Your application may use only one stream created by OpenReader() at

               a time, and you should not call other Extract methods before

               completing your reads on a stream obtained from OpenReader().  This

               is because there is really only one source stream for the compressed

               content.  A call to OpenReader() seeks in the source stream, to the

               beginning of the compressed content.  A subsequent call to

               OpenReader() on a different entry will seek to a different position

               in the source stream, as will a call to Extract() or one of its

               overloads.  This will corrupt the state for the decompressing stream

               from the original call to OpenReader().

             </para>

             <para>

                The <c>OpenReader()</c> method works only when the ZipEntry is

                obtained from an instance of <c>ZipFile</c>. This method will throw

                an exception if the ZipEntry is obtained from a <see cref="T:Ionic.Zip.ZipInputStream"/>.

             </para>

             </remarks>

             <example>

               This example shows how to open a zip archive, then read in a named

               entry via a stream. After the read loop is complete, the code

               compares the calculated during the read loop with the expected CRC

               on the <c>ZipEntry</c>, to verify the extraction.

             <code>

             using (ZipFile zip = new ZipFile(ZipFileToRead))

             {

               ZipEntry e1= zip["Elevation.mp3"];

               using (Ionic.Zlib.CrcCalculatorStream s = e1.OpenReader())

               {

                 byte[] buffer = new byte[4096];

                 int n, totalBytesRead= 0;

                 do {

                   n = s.Read(buffer,0, buffer.Length);

                   totalBytesRead+=n;

                 } while (n&gt;0);

                  if (s.Crc32 != e1.Crc32)

                   throw new Exception(string.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32));

                  if (totalBytesRead != e1.UncompressedSize)

                   throw new Exception(string.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize));

               }

             }

             </code>

             <code lang="VB">

               Using zip As New ZipFile(ZipFileToRead)

                   Dim e1 As ZipEntry = zip.Item("Elevation.mp3")

                   Using s As Ionic.Zlib.CrcCalculatorStream = e1.OpenReader

                       Dim n As Integer

                       Dim buffer As Byte() = New Byte(4096) {}

                       Dim totalBytesRead As Integer = 0

                       Do

                           n = s.Read(buffer, 0, buffer.Length)

                           totalBytesRead = (totalBytesRead + n)

                       Loop While (n &gt; 0)

                       If (s.Crc32 &lt;&gt; e1.Crc32) Then

                           Throw New Exception(String.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32))

                       End If

                       If (totalBytesRead &lt;&gt; e1.UncompressedSize) Then

                           Throw New Exception(String.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize))

                       End If

                   End Using

               End Using

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipEntry.Extract(System.IO.Stream)"/>

             <returns>The Stream for reading.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.OpenReader(System.String)">

             <summary>

               Opens a readable stream for an encrypted zip entry in the archive.

               The stream decompresses and decrypts as necessary, as it is read.

             </summary>

             <remarks>

             <para>

               See the documentation on the <see cref="M:Ionic.Zip.ZipEntry.OpenReader"/> method for

               full details. This overload allows the application to specify a

               password for the <c>ZipEntry</c> to be read.

             </para>

             </remarks>

             <param name="password">The password to use for decrypting the entry.</param>

             <returns>The Stream for reading.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.InternalExtractToBaseDir(System.String,System.String,Ionic.Zip.ZipContainer,Ionic.Zip.ZipEntrySource,System.String)">

            <summary>

            Pass in either basedir or s, but not both.

            In other words, you can extract to a stream or to a directory (filesystem), but not both!

            The Password param is required for encrypted entries.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.InternalExtractToStream(System.IO.Stream,System.String,Ionic.Zip.ZipContainer,Ionic.Zip.ZipEntrySource,System.String)">

            <summary>

            Extract to a stream

            In other words, you can extract to a stream or to a directory (filesystem), but not both!

            The Password param is required for encrypted entries.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.IsDoneWithOutputToBaseDir(System.String,System.String@)">

            <summary>

            Validates that the args are consistent; returning whether the caller can return

            because it's done, or not (caller should continue)

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.IsDoneWithOutputToStream">

            <summary>

            Validates that the args are consistent; returning whether the caller can return

            because it's done, or not (caller should continue)

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ReadEntry(Ionic.Zip.ZipContainer,System.Boolean)">

            <summary>

              Reads one <c>ZipEntry</c> from the given stream.  The content for

              the entry does not get decompressed or decrypted.  This method

              basically reads metadata, and seeks.

            </summary>

            <param name="zc">the ZipContainer this entry belongs to.</param>

            <param name="first">

              true of this is the first entry being read from the stream.

            </param>

            <returns>the <c>ZipEntry</c> read from the stream.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.FindExtraFieldSegment(System.Byte[],System.Int32,System.UInt16)">

            <summary>

              Finds a particular segment in the given extra field.

              This is used when modifying a previously-generated

              extra field, in particular when removing the AES crypto

              segment in the extra field.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.ProcessExtraField(System.IO.Stream,System.Int16)">

            <summary>

              At current cursor position in the stream, read the extra

              field, and set the properties on the ZipEntry instance

              appropriately.  This can be called when processing the

              Extra field in the Central Directory, or in the local

              header.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.GetEncodedFileNameBytes">

            <summary>

              generate and return a byte array that encodes the filename

              for the entry.

            </summary>

            <remarks>

              <para>

                side effects: generate and store into _CommentBytes the

                byte array for any comment attached to the entry. Also

                sets _actualEncoding to indicate the actual encoding

                used. The same encoding is used for both filename and

                comment.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.PrepSourceStream">

             <summary>

               Stores the position of the entry source stream, or, if the position is

               already stored, seeks to that position.

             </summary>

             <remarks>

             <para>

               This method is called in prep for reading the source stream.  If PKZIP

               encryption is used, then we need to calc the CRC32 before doing the

               encryption, because the CRC is used in the 12th byte of the PKZIP

               encryption header.  So, we need to be able to seek backward in the source

               when saving the ZipEntry. This method is called from the place that

               calculates the CRC, and also from the method that does the encryption of

               the file data.

             </para>

             <para>

               The first time through, this method sets the _sourceStreamOriginalPosition

               field. Subsequent calls to this method seek to that position.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.CopyMetaData(Ionic.Zip.ZipEntry)">

            <summary>

            Copy metadata that may have been changed by the app.  We do this when

            resetting the zipFile instance.  If the app calls Save() on a ZipFile, then

            tries to party on that file some more, we may need to Reset() it , which

            means re-reading the entries and then copying the metadata.  I think.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.SetInputAndFigureFileLength(System.IO.Stream@)">

            <summary>

              Set the input stream and get its length, if possible.  The length is

              used for progress updates, AND, to allow an optimization in case of

              a stream/file of zero length. In that case we skip the Encrypt and

              compression Stream. (like DeflateStream or BZip2OutputStream)

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipEntry.PrepOutputStream(System.IO.Stream,System.Int64,Ionic.Zip.CountingStream@,System.IO.Stream@,System.IO.Stream@,Ionic.Crc.CrcCalculatorStream@)">

            <summary>

              Prepare the given stream for output - wrap it in a CountingStream, and

              then in a CRC stream, and an encryptor and deflator as appropriate.

            </summary>

            <remarks>

              <para>

                Previously this was used in ZipEntry.Write(), but in an effort to

                introduce some efficiencies in that method I've refactored to put the

                code inline.  This method still gets called by ZipOutputStream.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.AttributesIndicateDirectory">

            <summary>

            True if the referenced entry is a directory.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Info">

            <summary>

            Provides a human-readable string with information about the ZipEntry.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.LastModified">

             <summary>

               The time and date at which the file indicated by the <c>ZipEntry</c> was

               last modified.

             </summary>

             <remarks>

             <para>

               The DotNetZip library sets the LastModified value for an entry, equal to

               the Last Modified time of the file in the filesystem.  If an entry is

               added from a stream, the library uses <c>System.DateTime.Now</c> for this

               value, for the given entry.

             </para>

             <para>

               This property allows the application to retrieve and possibly set the

               LastModified value on an entry, to an arbitrary value.  <see cref="T:System.DateTime"/> values with a <see cref="T:System.DateTimeKind"/>

               setting of <c>DateTimeKind.Unspecified</c> are taken to be expressed as

               <c>DateTimeKind.Local</c>.

             </para>

             <para>

               Be aware that because of the way <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWare's

               Zip specification</see> describes how times are stored in the zip file,

               the full precision of the <c>System.DateTime</c> datatype is not stored

               for the last modified time when saving zip files.  For more information on

               how times are formatted, see the PKZip specification.

             </para>

             <para>

               The actual last modified time of a file can be stored in multiple ways in

               the zip file, and they are not mutually exclusive:

             </para>

             <list type="bullet">

               <item>

                 In the so-called "DOS" format, which has a 2-second precision. Values

                 are rounded to the nearest even second. For example, if the time on the

                 file is 12:34:43, then it will be stored as 12:34:44. This first value

                 is accessible via the <c>LastModified</c> property. This value is always

                 present in the metadata for each zip entry.  In some cases the value is

                 invalid, or zero.

               </item>

               <item>

                 In the so-called "Windows" or "NTFS" format, as an 8-byte integer

                 quantity expressed as the number of 1/10 milliseconds (in other words

                 the number of 100 nanosecond units) since January 1, 1601 (UTC).  This

                 format is how Windows represents file times.  This time is accessible

                 via the <c>ModifiedTime</c> property.

               </item>

               <item>

                 In the "Unix" format, a 4-byte quantity specifying the number of seconds since

                 January 1, 1970 UTC.

               </item>

               <item>

                 In an older format, now deprecated but still used by some current

                 tools. This format is also a 4-byte quantity specifying the number of

                 seconds since January 1, 1970 UTC.

               </item>

             </list>

             <para>

               Zip tools and libraries will always at least handle (read or write) the

               DOS time, and may also handle the other time formats.  Keep in mind that

               while the names refer to particular operating systems, there is nothing in

               the time formats themselves that prevents their use on other operating

               systems.

             </para>

             <para>

               When reading ZIP files, the DotNetZip library reads the Windows-formatted

               time, if it is stored in the entry, and sets both <c>LastModified</c> and

               <c>ModifiedTime</c> to that value. When writing ZIP files, the DotNetZip

               library by default will write both time quantities. It can also emit the

               Unix-formatted time if desired (See <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/>.)

             </para>

             <para>

               The last modified time of the file created upon a call to

               <c>ZipEntry.Extract()</c> may be adjusted during extraction to compensate

               for differences in how the .NET Base Class Library deals with daylight

               saving time (DST) versus how the Windows filesystem deals with daylight

               saving time.  Raymond Chen <see href="http://blogs.msdn.com/oldnewthing/archive/2003/10/24/55413.aspx">provides

               some good context</see>.

             </para>

             <para>

               In a nutshell: Daylight savings time rules change regularly.  In 2007, for

               example, the inception week of DST changed.  In 1977, DST was in place all

               year round. In 1945, likewise.  And so on.  Win32 does not attempt to

               guess which time zone rules were in effect at the time in question.  It

               will render a time as "standard time" and allow the app to change to DST

               as necessary.  .NET makes a different choice.

             </para>

             <para>

               Compare the output of FileInfo.LastWriteTime.ToString("f") with what you

               see in the Windows Explorer property sheet for a file that was last

               written to on the other side of the DST transition. For example, suppose

               the file was last modified on October 17, 2003, during DST but DST is not

               currently in effect. Explorer's file properties reports Thursday, October

               17, 2003, 8:45:38 AM, but .NETs FileInfo reports Thursday, October 17,

               2003, 9:45 AM.

             </para>

             <para>

               Win32 says, "Thursday, October 17, 2002 8:45:38 AM PST". Note: Pacific

               STANDARD Time. Even though October 17 of that year occurred during Pacific

               Daylight Time, Win32 displays the time as standard time because that's

               what time it is NOW.

             </para>

             <para>

               .NET BCL assumes that the current DST rules were in place at the time in

               question.  So, .NET says, "Well, if the rules in effect now were also in

               effect on October 17, 2003, then that would be daylight time" so it

               displays "Thursday, October 17, 2003, 9:45 AM PDT" - daylight time.

             </para>

             <para>

               So .NET gives a value which is more intuitively correct, but is also

               potentially incorrect, and which is not invertible. Win32 gives a value

               which is intuitively incorrect, but is strictly correct.

             </para>

             <para>

               Because of this funkiness, this library adds one hour to the LastModified

               time on the extracted file, if necessary.  That is to say, if the time in

               question had occurred in what the .NET Base Class Library assumed to be

               DST. This assumption may be wrong given the constantly changing DST rules,

               but it is the best we can do.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.ModifiedTime">

             <summary>

             Last Modified time for the file represented by the entry.

             </summary>

             <remarks>

             <para>

               This value corresponds to the "last modified" time in the NTFS file times

               as described in <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip

               specification</see>.  When getting this property, the value may be

               different from <see cref="P:Ionic.Zip.ZipEntry.LastModified"/>.  When setting the property,

               the <see cref="P:Ionic.Zip.ZipEntry.LastModified"/> property also gets set, but with a lower

               precision.

             </para>

             <para>

               Let me explain. It's going to take a while, so get

               comfortable. Originally, waaaaay back in 1989 when the ZIP specification

               was originally described by the esteemed Mr. Phil Katz, the dominant

               operating system of the time was MS-DOS. MSDOS stored file times with a

               2-second precision, because, c'mon, <em>who is ever going to need better

               resolution than THAT?</em> And so ZIP files, regardless of the platform on

               which the zip file was created, store file times in exactly <see href="http://www.vsft.com/hal/dostime.htm">the same format that DOS used

               in 1989</see>.

             </para>

             <para>

               Since then, the ZIP spec has evolved, but the internal format for file

               timestamps remains the same.  Despite the fact that the way times are

               stored in a zip file is rooted in DOS heritage, any program on any

               operating system can format a time in this way, and most zip tools and

               libraries DO - they round file times to the nearest even second and store

               it just like DOS did 25+ years ago.

             </para>

             <para>

               PKWare extended the ZIP specification to allow a zip file to store what

               are called "NTFS Times" and "Unix(tm) times" for a file.  These are the

               <em>last write</em>, <em>last access</em>, and <em>file creation</em>

               times of a particular file. These metadata are not actually specific

               to NTFS or Unix. They are tracked for each file by NTFS and by various

               Unix filesystems, but they are also tracked by other filesystems, too.

               The key point is that the times are <em>formatted in the zip file</em>

               in the same way that NTFS formats the time (ticks since win32 epoch),

               or in the same way that Unix formats the time (seconds since Unix

               epoch). As with the DOS time, any tool or library running on any

               operating system is capable of formatting a time in one of these ways

               and embedding it into the zip file.

             </para>

             <para>

               These extended times are higher precision quantities than the DOS time.

               As described above, the (DOS) LastModified has a precision of 2 seconds.

               The Unix time is stored with a precision of 1 second. The NTFS time is

               stored with a precision of 0.0000001 seconds. The quantities are easily

               convertible, except for the loss of precision you may incur.

             </para>

             <para>

               A zip archive can store the {C,A,M} times in NTFS format, in Unix format,

               or not at all.  Often a tool running on Unix or Mac will embed the times

               in Unix format (1 second precision), while WinZip running on Windows might

               embed the times in NTFS format (precision of of 0.0000001 seconds).  When

               reading a zip file with these "extended" times, in either format,

               DotNetZip represents the values with the

               <c>ModifiedTime</c>, <c>AccessedTime</c> and <c>CreationTime</c>

               properties on the <c>ZipEntry</c>.

             </para>

             <para>

               While any zip application or library, regardless of the platform it

               runs on, could use any of the time formats allowed by the ZIP

               specification, not all zip tools or libraries do support all these

               formats.  Storing the higher-precision times for each entry is

               optional for zip files, and many tools and libraries don't use the

               higher precision quantities at all. The old DOS time, represented by

               <see cref="P:Ionic.Zip.ZipEntry.LastModified"/>, is guaranteed to be present, though it

               sometimes unset.

             </para>

             <para>

               Ok, getting back to the question about how the <c>LastModified</c>

               property relates to this <c>ModifiedTime</c>

               property... <c>LastModified</c> is always set, while

               <c>ModifiedTime</c> is not. (The other times stored in the <em>NTFS

               times extension</em>, <c>CreationTime</c> and <c>AccessedTime</c> also

               may not be set on an entry that is read from an existing zip file.)

               When reading a zip file, then <c>LastModified</c> takes the DOS time

               that is stored with the file. If the DOS time has been stored as zero

               in the zipfile, then this library will use <c>DateTime.Now</c> for the

               <c>LastModified</c> value.  If the ZIP file was created by an evolved

               tool, then there will also be higher precision NTFS or Unix times in

               the zip file.  In that case, this library will read those times, and

               set <c>LastModified</c> and <c>ModifiedTime</c> to the same value, the

               one corresponding to the last write time of the file.  If there are no

               higher precision times stored for the entry, then <c>ModifiedTime</c>

               remains unset (likewise <c>AccessedTime</c> and <c>CreationTime</c>),

               and <c>LastModified</c> keeps its DOS time.

             </para>

             <para>

               When creating zip files with this library, by default the extended time

               properties (<c>ModifiedTime</c>, <c>AccessedTime</c>, and

               <c>CreationTime</c>) are set on the ZipEntry instance, and these data are

               stored in the zip archive for each entry, in NTFS format. If you add an

               entry from an actual filesystem file, then the entry gets the actual file

               times for that file, to NTFS-level precision.  If you add an entry from a

               stream, or a string, then the times get the value <c>DateTime.Now</c>.  In

               this case <c>LastModified</c> and <c>ModifiedTime</c> will be identical,

               to 2 seconds of precision.  You can explicitly set the

               <c>CreationTime</c>, <c>AccessedTime</c>, and <c>ModifiedTime</c> of an

               entry using the property setters.  If you want to set all of those

               quantities, it's more efficient to use the <see cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/> method.  Those

               changes are not made permanent in the zip file until you call <see cref="M:Ionic.Zip.ZipFile.Save"/> or one of its cousins.

             </para>

             <para>

               When creating a zip file, you can override the default behavior of

               this library for formatting times in the zip file, disabling the

               embedding of file times in NTFS format or enabling the storage of file

               times in Unix format, or both.  You may want to do this, for example,

               when creating a zip file on Windows, that will be consumed on a Mac,

               by an application that is not hip to the "NTFS times" format. To do

               this, use the <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/> and

               <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/> properties.  A valid zip

               file may store the file times in both formats.  But, there are no

               guarantees that a program running on Mac or Linux will gracefully

               handle the NTFS-formatted times when Unix times are present, or that a

               non-DotNetZip-powered application running on Windows will be able to

               handle file times in Unix format. DotNetZip will always do something

               reasonable; other libraries or tools may not. When in doubt, test.

             </para>

             <para>

               I'll bet you didn't think one person could type so much about time, eh?

               And reading it was so enjoyable, too!  Well, in appreciation, <see href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">maybe you

               should donate</see>?

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.CreationTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.LastModified"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.AccessedTime">

            <summary>

            Last Access time for the file represented by the entry.

            </summary>

            <remarks>

            This value may or may not be meaningful.  If the <c>ZipEntry</c> was read from an existing

            Zip archive, this information may not be available. For an explanation of why, see

            <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>.

            </remarks>

            <seealso cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>

            <seealso cref="P:Ionic.Zip.ZipEntry.CreationTime"/>

            <seealso cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.CreationTime">

             <summary>

             The file creation time for the file represented by the entry.

             </summary>

             <remarks>

             This value may or may not be meaningful.  If the <c>ZipEntry</c> was read

             from an existing zip archive, and the creation time was not set on the entry

             when the zip file was created, then this property may be meaningless. For an

             explanation of why, see <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>.

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>

             <seealso cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving">

             <summary>

               Specifies whether the Creation, Access, and Modified times for the given

               entry will be emitted in "Windows format" when the zip archive is saved.

             </summary>

             <remarks>

             <para>

               An application creating a zip archive can use this flag to explicitly

               specify that the file times for the entry should or should not be stored

               in the zip archive in the format used by Windows. The default value of

               this property is <c>true</c>.

             </para>

             <para>

               When adding an entry from a file or directory, the Creation (<see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>), Access (<see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>), and Modified

               (<see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>) times for the given entry are automatically

               set from the filesystem values. When adding an entry from a stream or

               string, all three values are implicitly set to DateTime.Now.  Applications

               can also explicitly set those times by calling <see cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>.

             </para>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see> describes multiple ways to format these times in a

               zip file. One is the format Windows applications normally use: 100ns ticks

               since Jan 1, 1601 UTC.  The other is a format Unix applications typically

               use: seconds since January 1, 1970 UTC.  Each format can be stored in an

               "extra field" in the zip entry when saving the zip archive. The former

               uses an extra field with a Header Id of 0x000A, while the latter uses a

               header ID of 0x5455.

             </para>

             <para>

               Not all zip tools and libraries can interpret these fields.  Windows

               compressed folders is one that can read the Windows Format timestamps,

               while I believe the <see href="http://www.info-zip.org/">Infozip</see>

               tools can read the Unix format timestamps. Although the time values are

               easily convertible, subject to a loss of precision, some tools and

               libraries may be able to read only one or the other. DotNetZip can read or

               write times in either or both formats.

             </para>

             <para>

               The times stored are taken from <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>, <see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>, and <see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>.

             </para>

             <para>

               This property is not mutually exclusive from the <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/> property.  It is

               possible that a zip entry can embed the timestamps in both forms, one

               form, or neither.  But, there are no guarantees that a program running on

               Mac or Linux will gracefully handle NTFS Formatted times, or that a

               non-DotNetZip-powered application running on Windows will be able to

               handle file times in Unix format. When in doubt, test.

             </para>

             <para>

               Normally you will use the <see cref="P:Ionic.Zip.ZipFile.EmitTimesInWindowsFormatWhenSaving">ZipFile.EmitTimesInWindowsFormatWhenSaving</see>

               property, to specify the behavior for all entries in a zip, rather than

               the property on each individual entry.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.CreationTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving">

             <summary>

               Specifies whether the Creation, Access, and Modified times for the given

               entry will be emitted in "Unix(tm) format" when the zip archive is saved.

             </summary>

             <remarks>

             <para>

               An application creating a zip archive can use this flag to explicitly

               specify that the file times for the entry should or should not be stored

               in the zip archive in the format used by Unix. By default this flag is

               <c>false</c>, meaning the Unix-format times are not stored in the zip

               archive.

             </para>

             <para>

               When adding an entry from a file or directory, the Creation (<see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>), Access (<see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>), and Modified

               (<see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>) times for the given entry are automatically

               set from the filesystem values. When adding an entry from a stream or

               string, all three values are implicitly set to DateTime.Now.  Applications

               can also explicitly set those times by calling <see cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>.

             </para>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see> describes multiple ways to format these times in a

               zip file. One is the format Windows applications normally use: 100ns ticks

               since Jan 1, 1601 UTC.  The other is a format Unix applications typically

               use: seconds since Jan 1, 1970 UTC.  Each format can be stored in an

               "extra field" in the zip entry when saving the zip archive. The former

               uses an extra field with a Header Id of 0x000A, while the latter uses a

               header ID of 0x5455.

             </para>

             <para>

               Not all tools and libraries can interpret these fields.  Windows

               compressed folders is one that can read the Windows Format timestamps,

               while I believe the <see href="http://www.info-zip.org/">Infozip</see>

               tools can read the Unix format timestamps. Although the time values are

               easily convertible, subject to a loss of precision, some tools and

               libraries may be able to read only one or the other. DotNetZip can read or

               write times in either or both formats.

             </para>

             <para>

               The times stored are taken from <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>, <see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>, and <see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>.

             </para>

             <para>

               This property is not mutually exclusive from the <see cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/> property.  It is

               possible that a zip entry can embed the timestamps in both forms, one

               form, or neither.  But, there are no guarantees that a program running on

               Mac or Linux will gracefully handle NTFS Formatted times, or that a

               non-DotNetZip-powered application running on Windows will be able to

               handle file times in Unix format. When in doubt, test.

             </para>

             <para>

               Normally you will use the <see cref="P:Ionic.Zip.ZipFile.EmitTimesInUnixFormatWhenSaving">ZipFile.EmitTimesInUnixFormatWhenSaving</see>

               property, to specify the behavior for all entries, rather than the

               property on each individual entry.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipFile.EmitTimesInUnixFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.CreationTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Timestamp">

             <summary>

             The type of timestamp attached to the ZipEntry.

             </summary>

             <remarks>

             This property is valid only for a ZipEntry that was read from a zip archive.

             It indicates the type of timestamp attached to the entry.

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Attributes">

             <summary>

               The file attributes for the entry.

             </summary>

             <remarks>

             <para>

               The <see cref="T:System.IO.FileAttributes">attributes</see> in NTFS include

               ReadOnly, Archive, Hidden, System, and Indexed.  When adding a

               <c>ZipEntry</c> to a ZipFile, these attributes are set implicitly when

               adding an entry from the filesystem.  When adding an entry from a stream

               or string, the Attributes are not set implicitly.  Regardless of the way

               an entry was added to a <c>ZipFile</c>, you can set the attributes

               explicitly if you like.

             </para>

             <para>

               When reading a <c>ZipEntry</c> from a <c>ZipFile</c>, the attributes are

               set according to the data stored in the <c>ZipFile</c>. If you extract the

               entry from the archive to a filesystem file, DotNetZip will set the

               attributes on the resulting file accordingly.

             </para>

             <para>

               The attributes can be set explicitly by the application.  For example the

               application may wish to set the <c>FileAttributes.ReadOnly</c> bit for all

               entries added to an archive, so that on unpack, this attribute will be set

               on the extracted file.  Any changes you make to this property are made

               permanent only when you call a <c>Save()</c> method on the <c>ZipFile</c>

               instance that contains the ZipEntry.

             </para>

             <para>

               For example, an application may wish to zip up a directory and set the

               ReadOnly bit on every file in the archive, so that upon later extraction,

               the resulting files will be marked as ReadOnly.  Not every extraction tool

               respects these attributes, but if you unpack with DotNetZip, as for

               example in a self-extracting archive, then the attributes will be set as

               they are stored in the <c>ZipFile</c>.

             </para>

             <para>

               These attributes may not be interesting or useful if the resulting archive

               is extracted on a non-Windows platform.  How these attributes get used

               upon extraction depends on the platform and tool used.

             </para>

             <para>

               This property is only partially supported in the Silverlight version

               of the library: applications can read attributes on entries within

               ZipFiles. But extracting entries within Silverlight will not set the

               attributes on the extracted files.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.LocalFileName">

             <summary>

               The name of the filesystem file, referred to by the ZipEntry.

             </summary>

             <remarks>

              <para>

                This property specifies the thing-to-be-zipped on disk, and is set only

                when the <c>ZipEntry</c> is being created from a filesystem file.  If the

                <c>ZipFile</c> is instantiated by reading an existing .zip archive, then

                the LocalFileName will be <c>null</c> (<c>Nothing</c> in VB).

              </para>

              <para>

                When it is set, the value of this property may be different than <see cref="P:Ionic.Zip.ZipEntry.FileName"/>, which is the path used in the archive itself.  If you

                call <c>Zip.AddFile("foop.txt", AlternativeDirectory)</c>, then the path

                used for the <c>ZipEntry</c> within the zip archive will be different

                than this path.

              </para>

              <para>

               If the entry is being added from a stream, then this is null (Nothing in VB).

              </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.FileName"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.FileName">

             <summary>

               The name of the file contained in the ZipEntry.

             </summary>

             <remarks>

             <para>

               This is the name of the entry in the <c>ZipFile</c> itself.  When creating

               a zip archive, if the <c>ZipEntry</c> has been created from a filesystem

               file, via a call to <see cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)"/> or <see cref="M:Ionic.Zip.ZipFile.AddItem(System.String,System.String)"/>, or a related overload, the value

               of this property is derived from the name of that file. The

               <c>FileName</c> property does not include drive letters, and may include a

               different directory path, depending on the value of the

               <c>directoryPathInArchive</c> parameter used when adding the entry into

               the <c>ZipFile</c>.

             </para>

             <para>

               In some cases there is no related filesystem file - for example when a

               <c>ZipEntry</c> is created using <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String)"/> or one of the similar overloads.  In this case, the value of

               this property is derived from the fileName and the directory path passed

               to that method.

             </para>

             <para>

               When reading a zip file, this property takes the value of the entry name

               as stored in the zip file. If you extract such an entry, the extracted

               file will take the name given by this property.

             </para>

             <para>

               Applications can set this property when creating new zip archives or when

               reading existing archives. When setting this property, the actual value

               that is set will replace backslashes with forward slashes, in accordance

               with <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip

               specification</see>, for compatibility with Unix(tm) and ... get

               this.... Amiga!

             </para>

             <para>

               If an application reads a <c>ZipFile</c> via <see cref="M:Ionic.Zip.ZipFile.Read(System.String)"/> or a related overload, and then explicitly

               sets the FileName on an entry contained within the <c>ZipFile</c>, and

               then calls <see cref="M:Ionic.Zip.ZipFile.Save"/>, the application will effectively

               rename the entry within the zip archive.

             </para>

             <para>

               If an application sets the value of <c>FileName</c>, then calls

               <c>Extract()</c> on the entry, the entry is extracted to a file using the

               newly set value as the filename.  The <c>FileName</c> value is made

               permanent in the zip archive only <em>after</em> a call to one of the

               <c>ZipFile.Save()</c> methods on the <c>ZipFile</c> that contains the

               ZipEntry.

             </para>

             <para>

               If an application attempts to set the <c>FileName</c> to a value that

               would result in a duplicate entry in the <c>ZipFile</c>, an exception is

               thrown.

             </para>

             <para>

               When a <c>ZipEntry</c> is contained within a <c>ZipFile</c>, applications

               cannot rename the entry within the context of a <c>foreach</c> (<c>For

               Each</c> in VB) loop, because of the way the <c>ZipFile</c> stores

               entries.  If you need to enumerate through all the entries and rename one

               or more of them, use <see cref="P:Ionic.Zip.ZipFile.EntriesSorted">ZipFile.EntriesSorted</see> as the

               collection.  See also, <see cref="M:Ionic.Zip.ZipFile.GetEnumerator">ZipFile.GetEnumerator()</see>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.InputStream">

             <summary>

             The stream that provides content for the ZipEntry.

             </summary>

             <remarks>

             <para>

               The application can use this property to set the input stream for an

               entry on a just-in-time basis. Imagine a scenario where the application

               creates a <c>ZipFile</c> comprised of content obtained from hundreds of

               files, via calls to <c>AddFile()</c>. The DotNetZip library opens streams

               on these files on a just-in-time basis, only when writing the entry out to

               an external store within the scope of a <c>ZipFile.Save()</c> call.  Only

               one input stream is opened at a time, as each entry is being written out.

             </para>

             <para>

               Now imagine a different application that creates a <c>ZipFile</c>

               with content obtained from hundreds of streams, added through <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)"/>.  Normally the

               application would supply an open stream to that call.  But when large

               numbers of streams are being added, this can mean many open streams at one

               time, unnecessarily.

             </para>

             <para>

               To avoid this, call <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/> and specify delegates that open and close the stream at

               the time of Save.

             </para>

             <para>

               Setting the value of this property when the entry was not added from a

               stream (for example, when the <c>ZipEntry</c> was added with <see cref="M:Ionic.Zip.ZipFile.AddFile(System.String)"/> or <see cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String)"/>, or when the entry was added by

               reading an existing zip archive) will throw an exception.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.InputStreamWasJitProvided">

             <summary>

               A flag indicating whether the InputStream was provided Just-in-time.

             </summary>

             <remarks>

             <para>

               When creating a zip archive, an application can obtain content for one or

               more of the <c>ZipEntry</c> instances from streams, using the <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)"/> method.  At the time

               of calling that method, the application can supply null as the value of

               the stream parameter.  By doing so, the application indicates to the

               library that it will provide a stream for the entry on a just-in-time

               basis, at the time one of the <c>ZipFile.Save()</c> methods is called and

               the data for the various entries are being compressed and written out.

             </para>

             <para>

               In this case, the application can set the <see cref="P:Ionic.Zip.ZipEntry.InputStream"/>

               property, typically within the SaveProgress event (event type: <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_BeforeWriteEntry"/>) for that entry.

             </para>

             <para>

               The application will later want to call Close() and Dispose() on that

               stream.  In the SaveProgress event, when the event type is <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_AfterWriteEntry"/>, the application can

               do so.  This flag indicates that the stream has been provided by the

               application on a just-in-time basis and that it is the application's

               responsibility to call Close/Dispose on that stream.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.InputStream"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Source">

            <summary>

            An enum indicating the source of the ZipEntry.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.VersionNeeded">

             <summary>

             The version of the zip engine needed to read the ZipEntry.

             </summary>

             <remarks>

             <para>

               This is a readonly property, indicating the version of <a

               href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip

               specification</a> that the extracting tool or library must support to

               extract the given entry.  Generally higher versions indicate newer

               features.  Older zip engines obviously won't know about new features, and

               won't be able to extract entries that depend on those newer features.

             </para>

             <list type="table">

             <listheader>

             <term>value</term>

             <description>Features</description>

             </listheader>

             <item>

             <term>20</term>

             <description>a basic Zip Entry, potentially using PKZIP encryption.

             </description>

             </item>

             <item>

             <term>45</term>

             <description>The ZIP64 extension is used on the entry.

             </description>

             </item>

             <item>

             <term>46</term>

             <description> File is compressed using BZIP2 compression*</description>

             </item>

             <item>

             <term>50</term>

             <description> File is encrypted using PkWare's DES, 3DES, (broken) RC2 or RC4</description>

             </item>

             <item>

             <term>51</term>

             <description> File is encrypted using PKWare's AES encryption or corrected RC2 encryption.</description>

             </item>

             <item>

             <term>52</term>

             <description> File is encrypted using corrected RC2-64 encryption**</description>

             </item>

             <item>

             <term>61</term>

             <description> File is encrypted using non-OAEP key wrapping***</description>

             </item>

             <item>

             <term>63</term>

             <description> File is compressed using LZMA, PPMd+, Blowfish, or Twofish</description>

             </item>

             </list>

             <para>

               There are other values possible, not listed here. DotNetZip supports

               regular PKZip encryption, and ZIP64 extensions.  DotNetZip cannot extract

               entries that require a zip engine higher than 45.

             </para>

             <para>

               This value is set upon reading an existing zip file, or after saving a zip

               archive.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Comment">

             <summary>

             The comment attached to the ZipEntry.

             </summary>

             <remarks>

             <para>

               Each entry in a zip file can optionally have a comment associated to

               it. The comment might be displayed by a zip tool during extraction, for

               example.

             </para>

             <para>

               By default, the <c>Comment</c> is encoded in IBM437 code page. You can

               specify an alternative with <see cref="P:Ionic.Zip.ZipEntry.AlternateEncoding"/> and

              <see cref="P:Ionic.Zip.ZipEntry.AlternateEncodingUsage"/>.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.AlternateEncoding"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.AlternateEncodingUsage"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.RequiresZip64">

             <summary>

             Indicates whether the entry requires ZIP64 extensions.

             </summary>

             <remarks>

             <para>

               This property is null (Nothing in VB) until a <c>Save()</c> method on the

               containing <see cref="T:Ionic.Zip.ZipFile"/> instance has been called. The property is

               non-null (<c>HasValue</c> is true) only after a <c>Save()</c> method has

               been called.

             </para>

             <para>

               After the containing <c>ZipFile</c> has been saved, the Value of this

               property is true if any of the following three conditions holds: the

               uncompressed size of the entry is larger than 0xFFFFFFFF; the compressed

               size of the entry is larger than 0xFFFFFFFF; the relative offset of the

               entry within the zip archive is larger than 0xFFFFFFFF.  These quantities

               are not known until a <c>Save()</c> is attempted on the zip archive and

               the compression is applied.

             </para>

             <para>

               If none of the three conditions holds, then the <c>Value</c> is false.

             </para>

             <para>

               A <c>Value</c> of false does not indicate that the entry, as saved in the

               zip archive, does not use ZIP64.  It merely indicates that ZIP64 is

               <em>not required</em>.  An entry may use ZIP64 even when not required if

               the <see cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/> property on the containing

               <c>ZipFile</c> instance is set to <see cref="F:Ionic.Zip.Zip64Option.Always"/>, or if

               the <see cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/> property on the containing

               <c>ZipFile</c> instance is set to <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/>

               and the output stream was not seekable.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.OutputUsedZip64"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.OutputUsedZip64">

             <summary>

               Indicates whether the entry actually used ZIP64 extensions, as it was most

               recently written to the output file or stream.

             </summary>

             <remarks>

             <para>

               This Nullable property is null (Nothing in VB) until a <c>Save()</c>

               method on the containing <see cref="T:Ionic.Zip.ZipFile"/> instance has been

               called. <c>HasValue</c> is true only after a <c>Save()</c> method has been

               called.

             </para>

             <para>

               The value of this property for a particular <c>ZipEntry</c> may change

               over successive calls to <c>Save()</c> methods on the containing ZipFile,

               even if the file that corresponds to the <c>ZipEntry</c> does not. This

               may happen if other entries contained in the <c>ZipFile</c> expand,

               causing the offset for this particular entry to exceed 0xFFFFFFFF.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.RequiresZip64"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.BitField">

             <summary>

               The bitfield for the entry as defined in the zip spec. You probably

               never need to look at this.

             </summary>

             <remarks>

             <para>

               You probably do not need to concern yourself with the contents of this

               property, but in case you do:

             </para>

             <list type="table">

             <listheader>

             <term>bit</term>

             <description>meaning</description>

             </listheader>

             <item>

             <term>0</term>

             <description>set if encryption is used.</description>

             </item>

             <item>

             <term>1-2</term>

             <description>

             set to determine whether normal, max, fast deflation.  DotNetZip library

             always leaves these bits unset when writing (indicating "normal"

             deflation"), but can read an entry with any value here.

             </description>

             </item>

             <item>

             <term>3</term>

             <description>

             Indicates that the Crc32, Compressed and Uncompressed sizes are zero in the

             local header.  This bit gets set on an entry during writing a zip file, when

             it is saved to a non-seekable output stream.

             </description>

             </item>

             <item>

             <term>4</term>

             <description>reserved for "enhanced deflating". This library doesn't do enhanced deflating.</description>

             </item>

             <item>

             <term>5</term>

             <description>set to indicate the zip is compressed patched data.  This library doesn't do that.</description>

             </item>

             <item>

             <term>6</term>

             <description>

             set if PKWare's strong encryption is used (must also set bit 1 if bit 6 is

             set). This bit is not set if WinZip's AES encryption is set.</description>

             </item>

             <item>

             <term>7</term>

             <description>not used</description>

             </item>

             <item>

             <term>8</term>

             <description>not used</description>

             </item>

             <item>

             <term>9</term>

             <description>not used</description>

             </item>

             <item>

             <term>10</term>

             <description>not used</description>

             </item>

             <item>

             <term>11</term>

             <description>

             Language encoding flag (EFS).  If this bit is set, the filename and comment

             fields for this file must be encoded using UTF-8. This library currently

             does not support UTF-8.

             </description>

             </item>

             <item>

             <term>12</term>

             <description>Reserved by PKWARE for enhanced compression.</description>

             </item>

             <item>

             <term>13</term>

             <description>

               Used when encrypting the Central Directory to indicate selected data

               values in the Local Header are masked to hide their actual values.  See

               the section in <a

               href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip

               specification</a> describing the Strong Encryption Specification for

               details.

             </description>

             </item>

             <item>

             <term>14</term>

             <description>Reserved by PKWARE.</description>

             </item>

             <item>

             <term>15</term>

             <description>Reserved by PKWARE.</description>

             </item>

             </list>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.CompressionMethod">

             <summary>

               The compression method employed for this ZipEntry.

             </summary>

             <remarks>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The

               Zip specification</see> allows a variety of compression methods.  This

               library supports just two: 0x08 = Deflate.  0x00 = Store (no compression),

               for reading or writing.

             </para>

             <para>

               When reading an entry from an existing zipfile, the value you retrieve

               here indicates the compression method used on the entry by the original

               creator of the zip.  When writing a zipfile, you can specify either 0x08

               (Deflate) or 0x00 (None).  If you try setting something else, you will get

               an exception.

             </para>

             <para>

               You may wish to set <c>CompressionMethod</c> to <c>CompressionMethod.None</c> (0)

               when zipping already-compressed data like a jpg, png, or mp3 file.

               This can save time and cpu cycles.

             </para>

             <para>

               When setting this property on a <c>ZipEntry</c> that is read from an

               existing zip file, calling <c>ZipFile.Save()</c> will cause the new

               CompressionMethod to be used on the entry in the newly saved zip file.

             </para>

             <para>

               Setting this property may have the side effect of modifying the

               <c>CompressionLevel</c> property. If you set the <c>CompressionMethod</c> to a

               value other than <c>None</c>, and <c>CompressionLevel</c> is previously

               set to <c>None</c>, then <c>CompressionLevel</c> will be set to

               <c>Default</c>.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.CompressionMethod"/>

             <example>

               In this example, the first entry added to the zip archive uses the default

               behavior - compression is used where it makes sense.  The second entry,

               the MP3 file, is added to the archive without being compressed.

             <code>

             using (ZipFile zip = new ZipFile(ZipFileToCreate))

             {

               ZipEntry e1= zip.AddFile(@"notes\Readme.txt");

               ZipEntry e2= zip.AddFile(@"music\StopThisTrain.mp3");

               e2.CompressionMethod = CompressionMethod.None;

               zip.Save();

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile(ZipFileToCreate)

               zip.AddFile("notes\Readme.txt")

               Dim e2 as ZipEntry = zip.AddFile("music\StopThisTrain.mp3")

               e2.CompressionMethod = CompressionMethod.None

               zip.Save

             End Using

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.CompressionLevel">

             <summary>

               Sets the compression level to be used for the entry when saving the zip

               archive. This applies only for CompressionMethod = DEFLATE.

             </summary>

             <remarks>

              <para>

                When using the DEFLATE compression method, Varying the compression

                level used on entries can affect the size-vs-speed tradeoff when

                compression and decompressing data streams or files.

              </para>

              <para>

                If you do not set this property, the default compression level is used,

                which normally gives a good balance of compression efficiency and

                compression speed.  In some tests, using <c>BestCompression</c> can

                double the time it takes to compress, while delivering just a small

                increase in compression efficiency.  This behavior will vary with the

                type of data you compress.  If you are in doubt, just leave this setting

                alone, and accept the default.

              </para>

              <para>

                When setting this property on a <c>ZipEntry</c> that is read from an

                existing zip file, calling <c>ZipFile.Save()</c> will cause the new

                <c>CompressionLevel</c> to be used on the entry in the newly saved zip file.

              </para>

              <para>

                Setting this property may have the side effect of modifying the

                <c>CompressionMethod</c> property. If you set the <c>CompressionLevel</c>

                to a value other than <c>None</c>, <c>CompressionMethod</c> will be set

                to <c>Deflate</c>, if it was previously <c>None</c>.

              </para>

              <para>

                Setting this property has no effect if the <c>CompressionMethod</c> is something

                other than <c>Deflate</c> or <c>None</c>.

              </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.CompressionMethod"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.CompressedSize">

             <summary>

               The compressed size of the file, in bytes, within the zip archive.

             </summary>

             <remarks>

               When reading a <c>ZipFile</c>, this value is read in from the existing

               zip file. When creating or updating a <c>ZipFile</c>, the compressed

               size is computed during compression.  Therefore the value on a

               <c>ZipEntry</c> is valid after a call to <c>Save()</c> (or one of its

               overloads) in that case.

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.UncompressedSize"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.UncompressedSize">

             <summary>

               The size of the file, in bytes, before compression, or after extraction.

             </summary>

             <remarks>

               When reading a <c>ZipFile</c>, this value is read in from the existing

               zip file. When creating or updating a <c>ZipFile</c>, the uncompressed

               size is computed during compression.  Therefore the value on a

               <c>ZipEntry</c> is valid after a call to <c>Save()</c> (or one of its

               overloads) in that case.

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.CompressedSize"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.CompressionRatio">

             <summary>

             The ratio of compressed size to uncompressed size of the ZipEntry.

             </summary>

             <remarks>

             <para>

               This is a ratio of the compressed size to the uncompressed size of the

               entry, expressed as a double in the range of 0 to 100+. A value of 100

               indicates no compression at all.  It could be higher than 100 when the

               compression algorithm actually inflates the data, as may occur for small

               files, or uncompressible data that is encrypted.

             </para>

             <para>

               You could format it for presentation to a user via a format string of

               "{3,5:F0}%" to see it as a percentage.

             </para>

             <para>

               If the size of the original uncompressed file is 0, implying a

               denominator of 0, the return value will be zero.

             </para>

             <para>

               This property is valid after reading in an existing zip file, or after

               saving the <c>ZipFile</c> that contains the ZipEntry. You cannot know the

               effect of a compression transform until you try it.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Crc">

             <summary>

             The 32-bit CRC (Cyclic Redundancy Check) on the contents of the ZipEntry.

             </summary>

             <remarks>

             <para> You probably don't need to concern yourself with this. It is used

             internally by DotNetZip to verify files or streams upon extraction.  </para>

             <para> The value is a <see href="http://en.wikipedia.org/wiki/CRC32">32-bit

             CRC</see> using 0xEDB88320 for the polynomial. This is the same CRC-32 used in

             PNG, MPEG-2, and other protocols and formats.  It is a read-only property; when

             creating a Zip archive, the CRC for each entry is set only after a call to

             <c>Save()</c> on the containing ZipFile. When reading an existing zip file, the value

             of this property reflects the stored CRC for the entry.  </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.IsDirectory">

            <summary>

            True if the entry is a directory (not a file).

            This is a readonly property on the entry.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.UsesEncryption">

             <summary>

             A derived property that is <c>true</c> if the entry uses encryption.

             </summary>

             <remarks>

             <para>

               This is a readonly property on the entry.  When reading a zip file,

               the value for the <c>ZipEntry</c> is determined by the data read

               from the zip file.  After saving a ZipFile, the value of this

               property for each <c>ZipEntry</c> indicates whether encryption was

               actually used (which will have been true if the <see cref="P:Ionic.Zip.ZipEntry.Password"/> was set and the <see cref="P:Ionic.Zip.ZipEntry.Encryption"/> property

               was something other than <see cref="F:Ionic.Zip.EncryptionAlgorithm.None"/>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Encryption">

             <summary>

               Set this to specify which encryption algorithm to use for the entry when

               saving it to a zip archive.

             </summary>

             <remarks>

             <para>

               Set this property in order to encrypt the entry when the <c>ZipFile</c> is

               saved. When setting this property, you must also set a <see cref="P:Ionic.Zip.ZipEntry.Password"/> on the entry.  If you set a value other than <see cref="F:Ionic.Zip.EncryptionAlgorithm.None"/> on this property and do not set a

               <c>Password</c> then the entry will not be encrypted. The <c>ZipEntry</c>

               data is encrypted as the <c>ZipFile</c> is saved, when you call <see cref="M:Ionic.Zip.ZipFile.Save"/> or one of its cousins on the containing

               <c>ZipFile</c> instance. You do not need to specify the <c>Encryption</c>

               when extracting entries from an archive.

             </para>

             <para>

               The Zip specification from PKWare defines a set of encryption algorithms,

               and the data formats for the zip archive that support them, and PKWare

               supports those algorithms in the tools it produces. Other vendors of tools

               and libraries, such as WinZip or Xceed, typically support <em>a

               subset</em> of the algorithms specified by PKWare. These tools can

               sometimes support additional different encryption algorithms and data

               formats, not specified by PKWare. The AES Encryption specified and

               supported by WinZip is the most popular example. This library supports a

               subset of the complete set of algorithms specified by PKWare and other

               vendors.

             </para>

             <para>

               There is no common, ubiquitous multi-vendor standard for strong encryption

               within zip files. There is broad support for so-called "traditional" Zip

               encryption, sometimes called Zip 2.0 encryption, as <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specified

               by PKWare</see>, but this encryption is considered weak and

               breakable. This library currently supports the Zip 2.0 "weak" encryption,

               and also a stronger WinZip-compatible AES encryption, using either 128-bit

               or 256-bit key strength. If you want DotNetZip to support an algorithm

               that is not currently supported, call the author of this library and maybe

               we can talk business.

             </para>

             <para>

               The <see cref="T:Ionic.Zip.ZipFile"/> class also has a <see cref="P:Ionic.Zip.ZipFile.Encryption"/> property.  In most cases you will use

               <em>that</em> property when setting encryption. This property takes

               precedence over any <c>Encryption</c> set on the <c>ZipFile</c> itself.

               Typically, you would use the per-entry Encryption when most entries in the

               zip archive use one encryption algorithm, and a few entries use a

               different one.  If all entries in the zip file use the same Encryption,

               then it is simpler to just set this property on the ZipFile itself, when

               creating a zip archive.

             </para>

             <para>

               Some comments on updating archives: If you read a <c>ZipFile</c>, you can

               modify the Encryption on an encrypted entry: you can remove encryption

               from an entry that was encrypted; you can encrypt an entry that was not

               encrypted previously; or, you can change the encryption algorithm.  The

               changes in encryption are not made permanent until you call Save() on the

               <c>ZipFile</c>.  To effect changes in encryption, the entry content is

               streamed through several transformations, depending on the modification

               the application has requested. For example if the entry is not encrypted

               and the application sets <c>Encryption</c> to <c>PkzipWeak</c>, then at

               the time of <c>Save()</c>, the original entry is read and decompressed,

               then re-compressed and encrypted.  Conversely, if the original entry is

               encrypted with <c>PkzipWeak</c> encryption, and the application sets the

               <c>Encryption</c> property to <c>WinZipAes128</c>, then at the time of

               <c>Save()</c>, the original entry is decrypted via PKZIP encryption and

               decompressed, then re-compressed and re-encrypted with AES.  This all

               happens automatically within the library, but it can be time-consuming for

               large entries.

             </para>

             <para>

               Additionally, when updating archives, it is not possible to change the

               password when changing the encryption algorithm.  To change both the

               algorithm and the password, you need to Save() the zipfile twice.  First

               set the <c>Encryption</c> to None, then call <c>Save()</c>.  Then set the

               <c>Encryption</c> to the new value (not "None"), then call <c>Save()</c>

               once again.

             </para>

             <para>

               The WinZip AES encryption algorithms are not supported on the .NET Compact

               Framework.

             </para>

             </remarks>

             <example>

             <para>

               This example creates a zip archive that uses encryption, and then extracts

               entries from the archive.  When creating the zip archive, the ReadMe.txt

               file is zipped without using a password or encryption.  The other file

               uses encryption.

             </para>

             <code>

             // Create a zip archive with AES Encryption.

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddFile("ReadMe.txt")

                 ZipEntry e1= zip.AddFile("2008-Regional-Sales-Report.pdf");

                 e1.Encryption= EncryptionAlgorithm.WinZipAes256;

                 e1.Password= "Top.Secret.No.Peeking!";

                 zip.Save("EncryptedArchive.zip");

             }

             // Extract a zip archive that uses AES Encryption.

             // You do not need to specify the algorithm during extraction.

             using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))

             {

                 // Specify the password that is used during extraction, for

                 // all entries that require a password:

                 zip.Password= "Top.Secret.No.Peeking!";

                 zip.ExtractAll("extractDirectory");

             }

             </code>

             <code lang="VB">

             ' Create a zip that uses Encryption.

             Using zip As New ZipFile()

                 zip.AddFile("ReadMe.txt")

                 Dim e1 as ZipEntry

                 e1= zip.AddFile("2008-Regional-Sales-Report.pdf")

                 e1.Encryption= EncryptionAlgorithm.WinZipAes256

                 e1.Password= "Top.Secret.No.Peeking!"

                 zip.Save("EncryptedArchive.zip")

             End Using

             ' Extract a zip archive that uses AES Encryption.

             ' You do not need to specify the algorithm during extraction.

             Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))

                 ' Specify the password that is used during extraction, for

                 ' all entries that require a password:

                 zip.Password= "Top.Secret.No.Peeking!"

                 zip.ExtractAll("extractDirectory")

             End Using

             </code>

             </example>

             <exception cref="T:System.InvalidOperationException">

             Thrown in the setter if EncryptionAlgorithm.Unsupported is specified.

             </exception>

             <seealso cref="P:Ionic.Zip.ZipEntry.Password">ZipEntry.Password</seealso>

             <seealso cref="P:Ionic.Zip.ZipFile.Encryption">ZipFile.Encryption</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.Password">

             <summary>

             The Password to be used when encrypting a <c>ZipEntry</c> upon

             <c>ZipFile.Save()</c>, or when decrypting an entry upon Extract().

             </summary>

             <remarks>

             <para>

               This is a write-only property on the entry. Set this to request that the

               entry be encrypted when writing the zip archive, or set it to specify the

               password to be used when extracting an existing entry that is encrypted.

             </para>

             <para>

               The password set here is implicitly used to encrypt the entry during the

               <see cref="M:Ionic.Zip.ZipFile.Save"/> operation, or to decrypt during the <see cref="M:Ionic.Zip.ZipEntry.Extract"/> or <see cref="M:Ionic.Zip.ZipEntry.OpenReader"/> operation.  If you set

               the Password on a <c>ZipEntry</c> after calling <c>Save()</c>, there is no

               effect.

             </para>

             <para>

               Consider setting the <see cref="P:Ionic.Zip.ZipEntry.Encryption"/> property when using a

               password. Answering concerns that the standard password protection

               supported by all zip tools is weak, WinZip has extended the ZIP

               specification with a way to use AES Encryption to protect entries in the

               Zip file. Unlike the "PKZIP 2.0" encryption specified in the PKZIP

               specification, <see href="http://en.wikipedia.org/wiki/Advanced_Encryption_Standard">AES

               Encryption</see> uses a standard, strong, tested, encryption

               algorithm. DotNetZip can create zip archives that use WinZip-compatible

               AES encryption, if you set the <see cref="P:Ionic.Zip.ZipEntry.Encryption"/> property. But,

               archives created that use AES encryption may not be readable by all other

               tools and libraries. For example, Windows Explorer cannot read a

               "compressed folder" (a zip file) that uses AES encryption, though it can

               read a zip file that uses "PKZIP encryption."

             </para>

             <para>

               The <see cref="T:Ionic.Zip.ZipFile"/> class also has a <see cref="P:Ionic.Zip.ZipFile.Password"/>

               property.  This property takes precedence over any password set on the

               ZipFile itself.  Typically, you would use the per-entry Password when most

               entries in the zip archive use one password, and a few entries use a

               different password.  If all entries in the zip file use the same password,

               then it is simpler to just set this property on the ZipFile itself,

               whether creating a zip archive or extracting a zip archive.

             </para>

             <para>

               Some comments on updating archives: If you read a <c>ZipFile</c>, you

               cannot modify the password on any encrypted entry, except by extracting

               the entry with the original password (if any), removing the original entry

               via <see cref="M:Ionic.Zip.ZipFile.RemoveEntry(Ionic.Zip.ZipEntry)"/>, and then adding a new

               entry with a new Password.

             </para>

             <para>

               For example, suppose you read a <c>ZipFile</c>, and there is an encrypted

               entry.  Setting the Password property on that <c>ZipEntry</c> and then

               calling <c>Save()</c> on the <c>ZipFile</c> does not update the password

               on that entry in the archive.  Neither is an exception thrown. Instead,

               what happens during the <c>Save()</c> is the existing entry is copied

               through to the new zip archive, in its original encrypted form. Upon

               re-reading that archive, the entry can be decrypted with its original

               password.

             </para>

             <para>

               If you read a ZipFile, and there is an un-encrypted entry, you can set the

               <c>Password</c> on the entry and then call Save() on the ZipFile, and get

               encryption on that entry.

             </para>

             </remarks>

             <example>

             <para>

               This example creates a zip file with two entries, and then extracts the

               entries from the zip file.  When creating the zip file, the two files are

               added to the zip file using password protection. Each entry uses a

               different password.  During extraction, each file is extracted with the

               appropriate password.

             </para>

             <code>

             // create a file with encryption

             using (ZipFile zip = new ZipFile())

             {

                 ZipEntry entry;

                 entry= zip.AddFile("Declaration.txt");

                 entry.Password= "123456!";

                 entry = zip.AddFile("Report.xls");

                 entry.Password= "1Secret!";

                 zip.Save("EncryptedArchive.zip");

             }

             // extract entries that use encryption

             using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))

             {

                 ZipEntry entry;

                 entry = zip["Declaration.txt"];

                 entry.Password = "123456!";

                 entry.Extract("extractDir");

                 entry = zip["Report.xls"];

                 entry.Password = "1Secret!";

                 entry.Extract("extractDir");

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 Dim entry as ZipEntry

                 entry= zip.AddFile("Declaration.txt")

                 entry.Password= "123456!"

                 entry = zip.AddFile("Report.xls")

                 entry.Password= "1Secret!"

                 zip.Save("EncryptedArchive.zip")

             End Using

             ' extract entries that use encryption

             Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))

                 Dim entry as ZipEntry

                 entry = zip("Declaration.txt")

                 entry.Password = "123456!"

                 entry.Extract("extractDir")

                 entry = zip("Report.xls")

                 entry.Password = "1Secret!"

                 entry.Extract("extractDir")

             End Using

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipEntry.Encryption"/>

             <seealso cref="P:Ionic.Zip.ZipFile.Password">ZipFile.Password</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.ExtractExistingFile">

             <summary>

             The action the library should take when extracting a file that already exists.

             </summary>

             <remarks>

               <para>

                 This property affects the behavior of the Extract methods (one of the

                 <c>Extract()</c> or <c>ExtractWithPassword()</c> overloads), when

                 extraction would would overwrite an existing filesystem file. If you do

                 not set this property, the library throws an exception when extracting

                 an entry would overwrite an existing file.

               </para>

               <para>

                 This property has no effect when extracting to a stream, or when the file to be

                 extracted does not already exist.

               </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>

             <example>

               This example shows how to set the <c>ExtractExistingFile</c> property in

               an <c>ExtractProgress</c> event, in response to user input. The

               <c>ExtractProgress</c> event is invoked if and only if the

               <c>ExtractExistingFile</c> property was previously set to

               <c>ExtractExistingFileAction.InvokeExtractProgressEvent</c>.

             <code lang="C#">

             public static void ExtractProgress(object sender, ExtractProgressEventArgs e)

             {

                 if (e.EventType == ZipProgressEventType.Extracting_BeforeExtractEntry)

                     Console.WriteLine("extract {0} ", e.CurrentEntry.FileName);

                 else if (e.EventType == ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite)

                 {

                     ZipEntry entry = e.CurrentEntry;

                     string response = null;

                     // Ask the user if he wants overwrite the file

                     do

                     {

                         Console.Write("Overwrite {0} in {1} ? (y/n/C) ", entry.FileName, e.ExtractLocation);

                         response = Console.ReadLine();

                         Console.WriteLine();

                     } while (response != null &amp;&amp; response[0]!='Y' &amp;&amp;

                              response[0]!='N' &amp;&amp; response[0]!='C');

                     if  (response[0]=='C')

                         e.Cancel = true;

                     else if (response[0]=='Y')

                         entry.ExtractExistingFile = ExtractExistingFileAction.OverwriteSilently;

                     else

                         entry.ExtractExistingFile= ExtractExistingFileAction.DoNotOverwrite;

                 }

             }

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.ZipErrorAction">

             <summary>

               The action to take when an error is encountered while

               opening or reading files as they are saved into a zip archive.

             </summary>

             <remarks>

              <para>

                 Errors can occur within a call to <see cref="M:Ionic.Zip.ZipFile.Save">ZipFile.Save</see>, as the various files contained

                 in a ZipFile are being saved into the zip archive.  During the

                 <c>Save</c>, DotNetZip will perform a <c>File.Open</c> on the file

                 associated to the ZipEntry, and then will read the entire contents of

                 the file as it is zipped. Either the open or the Read may fail, because

                 of lock conflicts or other reasons.  Using this property, you can

                 specify the action to take when such errors occur.

              </para>

              <para>

                 Typically you will NOT set this property on individual ZipEntry

                 instances.  Instead, you will set the <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction">ZipFile.ZipErrorAction</see> property on

                 the ZipFile instance, before adding any entries to the

                 <c>ZipFile</c>. If you do this, errors encountered on behalf of any of

                 the entries in the ZipFile will be handled the same way.

              </para>

              <para>

                 But, if you use a <see cref="E:Ionic.Zip.ZipFile.ZipError"/> handler, you will want

                 to set this property on the <c>ZipEntry</c> within the handler, to

                 communicate back to DotNetZip what you would like to do with the

                 particular error.

              </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ZipError"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.IncludedInMostRecentSave">

            <summary>

            Indicates whether the entry was included in the most recent save.

            </summary>

            <remarks>

            An entry can be excluded or skipped from a save if there is an error

            opening or reading the entry.

            </remarks>

            <seealso cref="P:Ionic.Zip.ZipEntry.ZipErrorAction"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.SetCompression">

             <summary>

               A callback that allows the application to specify the compression to use

               for a given entry that is about to be added to the zip archive.

             </summary>

             <remarks>

             <para>

               See <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.UseUnicodeAsNecessary">

             <summary>

               Set to indicate whether to use UTF-8 encoding for filenames and comments.

             </summary>

             <remarks>

             <para>

               If this flag is set, the comment and filename for the entry will be

               encoded with UTF-8, as described in <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">the Zip

               specification</see>, if necessary. "Necessary" means, the filename or

               entry comment (if any) cannot be reflexively encoded and decoded using the

               default code page, IBM437.

             </para>

             <para>

               Setting this flag to true is equivalent to setting <see cref="P:Ionic.Zip.ZipEntry.ProvisionalAlternateEncoding"/> to <c>System.Text.Encoding.UTF8</c>.

             </para>

             <para>

               This flag has no effect or relation to the text encoding used within the

               file itself.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.ProvisionalAlternateEncoding">

             <summary>

               The text encoding to use for the FileName and Comment on this ZipEntry,

               when the default encoding is insufficient.

             </summary>

             <remarks>

             <para>

               Don't use this property.  See <see cref="P:Ionic.Zip.ZipEntry.AlternateEncoding"/>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.AlternateEncoding">

            <summary>

              Specifies the alternate text encoding used by this ZipEntry

            </summary>

            <remarks>

              <para>

                The default text encoding used in Zip files for encoding filenames and

                comments is IBM437, which is something like a superset of ASCII.  In

                cases where this is insufficient, applications can specify an

                alternate encoding.

              </para>

              <para>

                When creating a zip file, the usage of the alternate encoding is

                governed by the <see cref="P:Ionic.Zip.ZipEntry.AlternateEncodingUsage"/> property.

                Typically you would set both properties to tell DotNetZip to employ an

                encoding that is not IBM437 in the zipfile you are creating.

              </para>

              <para>

                Keep in mind that because the ZIP specification states that the only

                valid encodings to use are IBM437 and UTF-8, if you use something

                other than that, then zip tools and libraries may not be able to

                successfully read the zip archive you generate.

              </para>

              <para>

                The zip specification states that applications should presume that

                IBM437 is in use, except when a special bit is set, which indicates

                UTF-8. There is no way to specify an arbitrary code page, within the

                zip file itself. When you create a zip file encoded with gb2312 or

                ibm861 or anything other than IBM437 or UTF-8, then the application

                that reads the zip file needs to "know" which code page to use. In

                some cases, the code page used when reading is chosen implicitly. For

                example, WinRar uses the ambient code page for the host desktop

                operating system. The pitfall here is that if you create a zip in

                Copenhagen and send it to Tokyo, the reader of the zipfile may not be

                able to decode successfully.

              </para>

            </remarks>

            <example>

              This example shows how to create a zipfile encoded with a

              language-specific encoding:

            <code>

              using (var zip = new ZipFile())

              {

                 zip.AlternateEnoding = System.Text.Encoding.GetEncoding("ibm861");

                 zip.AlternateEnodingUsage = ZipOption.Always;

                 zip.AddFileS(arrayOfFiles);

                 zip.Save("Myarchive-Encoded-in-IBM861.zip");

              }

            </code>

            </example>

            <seealso cref="P:Ionic.Zip.ZipFile.AlternateEncodingUsage"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.AlternateEncodingUsage">

            <summary>

              Describes if and when this instance should apply

              AlternateEncoding to encode the FileName and Comment, when

              saving.

            </summary>

            <seealso cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/>

        </member>

        <member name="P:Ionic.Zip.ZipEntry.IsText">

             <summary>

               Indicates whether an entry is marked as a text file. Be careful when

               using on this property. Unless you have a good reason, you should

               probably ignore this property.

             </summary>

             <remarks>

             <para>

               The ZIP format includes a provision for specifying whether an entry in

               the zip archive is a text or binary file.  This property exposes that

               metadata item. Be careful when using this property: It's not clear

               that this property as a firm meaning, across tools and libraries.

             </para>

             <para>

               To be clear, when reading a zip file, the property value may or may

               not be set, and its value may or may not be valid.  Not all entries

               that you may think of as "text" entries will be so marked, and entries

               marked as "text" are not guaranteed in any way to be text entries.

               Whether the value is set and set correctly depends entirely on the

               application that produced the zip file.

             </para>

             <para>

               There are many zip tools available, and when creating zip files, some

               of them "respect" the IsText metadata field, and some of them do not.

               Unfortunately, even when an application tries to do "the right thing",

               it's not always clear what "the right thing" is.

             </para>

             <para>

               There's no firm definition of just what it means to be "a text file",

               and the zip specification does not help in this regard. Twenty years

               ago, text was ASCII, each byte was less than 127. IsText meant, all

               bytes in the file were less than 127.  These days, it is not the case

               that all text files have all bytes less than 127.  Any unicode file

               may have bytes that are above 0x7f.  The zip specification has nothing

               to say on this topic. Therefore, it's not clear what IsText really

               means.

             </para>

             <para>

               This property merely tells a reading application what is stored in the

               metadata for an entry, without guaranteeing its validity or its

               meaning.

             </para>

             <para>

               When DotNetZip is used to create a zipfile, it attempts to set this

               field "correctly." For example, if a file ends in ".txt", this field

               will be set. Your application may override that default setting.  When

               writing a zip file, you must set the property before calling

               <c>Save()</c> on the ZipFile.

             </para>

             <para>

               When reading a zip file, a more general way to decide just what kind

               of file is contained in a particular entry is to use the file type

               database stored in the operating system.  The operating system stores

               a table that says, a file with .jpg extension is a JPG image file, a

               file with a .xml extension is an XML document, a file with a .txt is a

               pure ASCII text document, and so on.  To get this information on

               Windows, <see

               href="http://www.codeproject.com/KB/cs/GetFileTypeAndIcon.aspx"> you

               need to read and parse the registry.</see> </para>

             </remarks>

             <example>

             <code>

             using (var zip = new ZipFile())

             {

                 var e = zip.UpdateFile("Descriptions.mme", "");

                 e.IsText = true;

                 zip.Save(zipPath);

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 Dim e2 as ZipEntry = zip.AddFile("Descriptions.mme", "")

                 e.IsText= True

                 zip.Save(zipPath)

             End Using

             </code>

             </example>

        </member>

        <member name="T:Ionic.Zip.ZipEntryTimestamp">

             <summary>

               An enum that specifies the type of timestamp available on the ZipEntry.

             </summary>

             <remarks>

             <para>

               The last modified time of a file can be stored in multiple ways in

               a zip file, and they are not mutually exclusive:

             </para>

             <list type="bullet">

               <item>

                 In the so-called "DOS" format, which has a 2-second precision. Values

                 are rounded to the nearest even second. For example, if the time on the

                 file is 12:34:43, then it will be stored as 12:34:44. This first value

                 is accessible via the <c>LastModified</c> property. This value is always

                 present in the metadata for each zip entry.  In some cases the value is

                 invalid, or zero.

               </item>

               <item>

                 In the so-called "Windows" or "NTFS" format, as an 8-byte integer

                 quantity expressed as the number of 1/10 milliseconds (in other words

                 the number of 100 nanosecond units) since January 1, 1601 (UTC).  This

                 format is how Windows represents file times.  This time is accessible

                 via the <c>ModifiedTime</c> property.

               </item>

               <item>

                 In the "Unix" format, a 4-byte quantity specifying the number of seconds since

                 January 1, 1970 UTC.

               </item>

               <item>

                 In an older format, now deprecated but still used by some current

                 tools. This format is also a 4-byte quantity specifying the number of

                 seconds since January 1, 1970 UTC.

               </item>

             </list>

             <para>

               This bit field describes which of the formats were found in a <c>ZipEntry</c> that was read.

             </para>

             </remarks>

        </member>

        <member name="F:Ionic.Zip.ZipEntryTimestamp.None">

            <summary>

            Default value.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntryTimestamp.DOS">

            <summary>

            A DOS timestamp with 2-second precision.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntryTimestamp.Windows">

            <summary>

            A Windows timestamp with 100-ns precision.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntryTimestamp.Unix">

            <summary>

            A Unix timestamp with 1-second precision.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipEntryTimestamp.InfoZip1">

            <summary>

            A Unix timestamp with 1-second precision, stored in InfoZip v1 format.  This

            format is outdated and is supported for reading archives only.

            </summary>

        </member>

        <member name="T:Ionic.Zip.CompressionMethod">

             <summary>

               The method of compression to use for a particular ZipEntry.

             </summary>

             <remarks>

               <see

               href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWare's

               ZIP Specification</see> describes a number of distinct

               cmopression methods that can be used within a zip

               file. DotNetZip supports a subset of them.

             </remarks>

        </member>

        <member name="F:Ionic.Zip.CompressionMethod.None">

            <summary>

            No compression at all. For COM environments, the value is 0 (zero).

            </summary>

        </member>

        <member name="F:Ionic.Zip.CompressionMethod.Deflate">

            <summary>

              DEFLATE compression, as described in <see

              href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC

              1951</see>.  This is the "normal" compression used in zip

              files. For COM environments, the value is 8.

            </summary>

        </member>

        <member name="F:Ionic.Zip.CompressionMethod.BZip2">

            <summary>

              BZip2 compression, a compression algorithm developed by Julian Seward.

              For COM environments, the value is 12.

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipFile">

             <summary>

               The ZipFile type represents a zip archive file.

             </summary>

             <remarks>

             <para>

               This is the main type in the DotNetZip class library. This class reads and

               writes zip files, as defined in the <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">specification

               for zip files described by PKWare</see>.  The compression for this

               implementation is provided by a managed-code version of Zlib, included with

               DotNetZip in the classes in the Ionic.Zlib namespace.

             </para>

             <para>

               This class provides a general purpose zip file capability.  Use it to read,

               create, or update zip files.  When you want to create zip files using a

               <c>Stream</c> type to write the zip file, you may want to consider the <see cref="T:Ionic.Zip.ZipOutputStream"/> class.

             </para>

             <para>

               Both the <c>ZipOutputStream</c> class and the <c>ZipFile</c> class can

               be used to create zip files. Both of them support many of the common zip

               features, including Unicode, different compression methods and levels,

               and ZIP64. They provide very similar performance when creating zip

               files.

             </para>

             <para>

               The <c>ZipFile</c> class is generally easier to use than

               <c>ZipOutputStream</c> and should be considered a higher-level interface.  For

               example, when creating a zip file via calls to the <c>PutNextEntry()</c> and

               <c>Write()</c> methods on the <c>ZipOutputStream</c> class, the caller is

               responsible for opening the file, reading the bytes from the file, writing

               those bytes into the <c>ZipOutputStream</c>, setting the attributes on the

               <c>ZipEntry</c>, and setting the created, last modified, and last accessed

               timestamps on the zip entry. All of these things are done automatically by a

               call to <see cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)">ZipFile.AddFile()</see>.

               For this reason, the <c>ZipOutputStream</c> is generally recommended for use

               only when your application emits arbitrary data, not necessarily data from a

               filesystem file, directly into a zip file, and does so using a <c>Stream</c>

               metaphor.

             </para>

             <para>

               Aside from the differences in programming model, there are other

               differences in capability between the two classes.

             </para>

             <list type="bullet">

               <item>

                 <c>ZipFile</c> can be used to read and extract zip files, in addition to

                 creating zip files. <c>ZipOutputStream</c> cannot read zip files. If you want

                 to use a stream to read zip files, check out the <see cref="T:Ionic.Zip.ZipInputStream"/> class.

               </item>

               <item>

                 <c>ZipOutputStream</c> does not support the creation of segmented or spanned

                 zip files.

               </item>

               <item>

                 <c>ZipOutputStream</c> cannot produce a self-extracting archive.

               </item>

             </list>

             <para>

               Be aware that the <c>ZipFile</c> class implements the <see cref="T:System.IDisposable"/> interface.  In order for <c>ZipFile</c> to

               produce a valid zip file, you use use it within a using clause (<c>Using</c>

               in VB), or call the <c>Dispose()</c> method explicitly.  See the examples

               for how to employ a using clause.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddItem(System.String)">

             <summary>

               Adds an item, either a file or a directory, to a zip file archive.

             </summary>

             <remarks>

             <para>

               This method is handy if you are adding things to zip archive and don't

               want to bother distinguishing between directories or files.  Any files are

               added as single entries.  A directory added through this method is added

               recursively: all files and subdirectories contained within the directory

               are added to the <c>ZipFile</c>.

             </para>

             <para>

               The name of the item may be a relative path or a fully-qualified

               path. Remember, the items contained in <c>ZipFile</c> instance get written

               to the disk only when you call <see cref="M:Ionic.Zip.ZipFile.Save"/> or a similar

               save method.

             </para>

             <para>

               The directory name used for the file within the archive is the same

               as the directory name (potentially a relative path) specified in the

               <paramref name="fileOrDirectoryName"/>.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String)"/>

             <overloads>This method has two overloads.</overloads>

             <param name="fileOrDirectoryName">

             the name of the file or directory to add.</param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddItem(System.String,System.String)">

             <summary>

               Adds an item, either a file or a directory, to a zip file archive,

               explicitly specifying the directory path to be used in the archive.

             </summary>

             <remarks>

             <para>

               If adding a directory, the add is recursive on all files and

               subdirectories contained within it.

             </para>

             <para>

               The name of the item may be a relative path or a fully-qualified path.

               The item added by this call to the <c>ZipFile</c> is not read from the

               disk nor written to the zip file archive until the application calls

               Save() on the <c>ZipFile</c>.

             </para>

             <para>

               This version of the method allows the caller to explicitly specify the

               directory path to be used in the archive, which would override the

               "natural" path of the filesystem file.

             </para>

             <para>

               Encryption will be used on the file data if the <c>Password</c> has

               been set on the <c>ZipFile</c> object, prior to calling this method.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <exception cref="T:System.IO.FileNotFoundException">

               Thrown if the file or directory passed in does not exist.

             </exception>

             <param name="fileOrDirectoryName">the name of the file or directory to add.

             </param>

             <param name="directoryPathInArchive">

               The name of the directory path to use within the zip archive.  This path

               need not refer to an extant directory in the current filesystem.  If the

               files within the zip are later extracted, this is the path used for the

               extracted file.  Passing <c>null</c> (<c>Nothing</c> in VB) will use the

               path on the fileOrDirectoryName.  Passing the empty string ("") will

               insert the item at the root path within the archive.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String,System.String)"/>

             <example>

               This example shows how to zip up a set of files into a flat hierarchy,

               regardless of where in the filesystem the files originated. The resulting

               zip archive will contain a toplevel directory named "flat", which itself

               will contain files Readme.txt, MyProposal.docx, and Image1.jpg.  A

               subdirectory under "flat" called SupportFiles will contain all the files

               in the "c:\SupportFiles" directory on disk.

             <code>

             String[] itemnames= {

               "c:\\fixedContent\\Readme.txt",

               "MyProposal.docx",

               "c:\\SupportFiles",  // a directory

               "images\\Image1.jpg"

             };

             try

             {

               using (ZipFile zip = new ZipFile())

               {

                 for (int i = 1; i &lt; itemnames.Length; i++)

                 {

                   // will add Files or Dirs, recurses and flattens subdirectories

                   zip.AddItem(itemnames[i],"flat");

                 }

                 zip.Save(ZipToCreate);

               }

             }

             catch (System.Exception ex1)

             {

               System.Console.Error.WriteLine("exception: {0}", ex1);

             }

             </code>

             <code lang="VB">

               Dim itemnames As String() = _

                 New String() { "c:\fixedContent\Readme.txt", _

                                "MyProposal.docx", _

                                "SupportFiles", _

                                "images\Image1.jpg" }

               Try

                   Using zip As New ZipFile

                       Dim i As Integer

                       For i = 1 To itemnames.Length - 1

                           ' will add Files or Dirs, recursing and flattening subdirectories.

                           zip.AddItem(itemnames(i), "flat")

                       Next i

                       zip.Save(ZipToCreate)

                   End Using

               Catch ex1 As Exception

                   Console.Error.WriteLine("exception: {0}", ex1.ToString())

               End Try

             </code>

             </example>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddFile(System.String)">

             <summary>

               Adds a File to a Zip file archive.

             </summary>

             <remarks>

             <para>

               This call collects metadata for the named file in the filesystem,

               including the file attributes and the timestamp, and inserts that metadata

               into the resulting ZipEntry.  Only when the application calls Save() on

               the <c>ZipFile</c>, does DotNetZip read the file from the filesystem and

               then write the content to the zip file archive.

             </para>

             <para>

               This method will throw an exception if an entry with the same name already

               exists in the <c>ZipFile</c>.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <example>

             <para>

               In this example, three files are added to a Zip archive. The ReadMe.txt

               file will be placed in the root of the archive. The .png file will be

               placed in a folder within the zip called photos\personal.  The pdf file

               will be included into a folder within the zip called Desktop.

             </para>

             <code>

                try

                {

                  using (ZipFile zip = new ZipFile())

                  {

                    zip.AddFile("c:\\photos\\personal\\7440-N49th.png");

                    zip.AddFile("c:\\Desktop\\2008-Regional-Sales-Report.pdf");

                    zip.AddFile("ReadMe.txt");

                    zip.Save("Package.zip");

                  }

                }

                catch (System.Exception ex1)

                {

                  System.Console.Error.WriteLine("exception: " + ex1);

                }

             </code>

             <code lang="VB">

              Try

                   Using zip As ZipFile = New ZipFile

                       zip.AddFile("c:\photos\personal\7440-N49th.png")

                       zip.AddFile("c:\Desktop\2008-Regional-Sales-Report.pdf")

                       zip.AddFile("ReadMe.txt")

                       zip.Save("Package.zip")

                   End Using

               Catch ex1 As Exception

                   Console.Error.WriteLine("exception: {0}", ex1.ToString)

               End Try

             </code>

             </example>

             <overloads>This method has two overloads.</overloads>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String)"/>

             <param name="fileName">

               The name of the file to add. It should refer to a file in the filesystem.

               The name of the file may be a relative path or a fully-qualified path.

             </param>

             <returns>The <c>ZipEntry</c> corresponding to the File added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)">

             <summary>

               Adds a File to a Zip file archive, potentially overriding the path to be

               used within the zip archive.

             </summary>

             <remarks>

             <para>

               The file added by this call to the <c>ZipFile</c> is not written to the

               zip file archive until the application calls Save() on the <c>ZipFile</c>.

             </para>

             <para>

               This method will throw an exception if an entry with the same name already

               exists in the <c>ZipFile</c>.

             </para>

             <para>

               This version of the method allows the caller to explicitly specify the

               directory path to be used in the archive.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <example>

             <para>

               In this example, three files are added to a Zip archive. The ReadMe.txt

               file will be placed in the root of the archive. The .png file will be

               placed in a folder within the zip called images.  The pdf file will be

               included into a folder within the zip called files\docs, and will be

               encrypted with the given password.

             </para>

             <code>

             try

             {

               using (ZipFile zip = new ZipFile())

               {

                 // the following entry will be inserted at the root in the archive.

                 zip.AddFile("c:\\datafiles\\ReadMe.txt", "");

                 // this image file will be inserted into the "images" directory in the archive.

                 zip.AddFile("c:\\photos\\personal\\7440-N49th.png", "images");

                 // the following will result in a password-protected file called

                 // files\\docs\\2008-Regional-Sales-Report.pdf  in the archive.

                 zip.Password = "EncryptMe!";

                 zip.AddFile("c:\\Desktop\\2008-Regional-Sales-Report.pdf", "files\\docs");

                 zip.Save("Archive.zip");

               }

             }

             catch (System.Exception ex1)

             {

               System.Console.Error.WriteLine("exception: {0}", ex1);

             }

             </code>

             <code lang="VB">

               Try

                   Using zip As ZipFile = New ZipFile

                       ' the following entry will be inserted at the root in the archive.

                       zip.AddFile("c:\datafiles\ReadMe.txt", "")

                       ' this image file will be inserted into the "images" directory in the archive.

                       zip.AddFile("c:\photos\personal\7440-N49th.png", "images")

                       ' the following will result in a password-protected file called

                       ' files\\docs\\2008-Regional-Sales-Report.pdf  in the archive.

                       zip.Password = "EncryptMe!"

                       zip.AddFile("c:\Desktop\2008-Regional-Sales-Report.pdf", "files\documents")

                       zip.Save("Archive.zip")

                   End Using

               Catch ex1 As Exception

                   Console.Error.WriteLine("exception: {0}", ex1)

               End Try

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String,System.String)"/>

             <param name="fileName">

               The name of the file to add.  The name of the file may be a relative path

               or a fully-qualified path.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the fileName.

               This path may, or may not, correspond to a real directory in the current

               filesystem.  If the files within the zip are later extracted, this is the

               path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in

               VB) will use the path on the fileName, if any.  Passing the empty string

               ("") will insert the item at the root path within the archive.

             </param>

             <returns>The <c>ZipEntry</c> corresponding to the file added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveEntries(System.Collections.Generic.ICollection{Ionic.Zip.ZipEntry})">

             <summary>

               This method removes a collection of entries from the <c>ZipFile</c>.

             </summary>

             <param name="entriesToRemove">

               A collection of ZipEntry instances from this zip file to be removed. For

               example, you can pass in an array of ZipEntry instances; or you can call

               SelectEntries(), and then add or remove entries from that

               ICollection&lt;ZipEntry&gt; (ICollection(Of ZipEntry) in VB), and pass

               that ICollection to this method.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.SelectEntries(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.RemoveSelectedEntries(System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveEntries(System.Collections.Generic.ICollection{System.String})">

             <summary>

               This method removes a collection of entries from the <c>ZipFile</c>, by name.

             </summary>

             <param name="entriesToRemove">

               A collection of strings that refer to names of entries to be removed

               from the <c>ZipFile</c>.  For example, you can pass in an array or a

               List of Strings that provide the names of entries to be removed.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.SelectEntries(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.RemoveSelectedEntries(System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddFiles(System.Collections.Generic.IEnumerable{System.String})">

             <summary>

               This method adds a set of files to the <c>ZipFile</c>.

             </summary>

             <remarks>

             <para>

               Use this method to add a set of files to the zip archive, in one call.

               For example, a list of files received from

               <c>System.IO.Directory.GetFiles()</c> can be added to a zip archive in one

               call.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <param name="fileNames">

               The collection of names of the files to add. Each string should refer to a

               file in the filesystem. The name of the file may be a relative path or a

               fully-qualified path.

             </param>

             <example>

               This example shows how to create a zip file, and add a few files into it.

             <code>

             String ZipFileToCreate = "archive1.zip";

             String DirectoryToZip = "c:\\reports";

             using (ZipFile zip = new ZipFile())

             {

               // Store all files found in the top level directory, into the zip archive.

               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);

               zip.AddFiles(filenames);

               zip.Save(ZipFileToCreate);

             }

             </code>

             <code lang="VB">

             Dim ZipFileToCreate As String = "archive1.zip"

             Dim DirectoryToZip As String = "c:\reports"

             Using zip As ZipFile = New ZipFile

                 ' Store all files found in the top level directory, into the zip archive.

                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)

                 zip.AddFiles(filenames)

                 zip.Save(ZipFileToCreate)

             End Using

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateFiles(System.Collections.Generic.IEnumerable{System.String})">

             <summary>

               Adds or updates a set of files in the <c>ZipFile</c>.

             </summary>

             <remarks>

             <para>

               Any files that already exist in the archive are updated. Any files that

               don't yet exist in the archive are added.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <param name="fileNames">

               The collection of names of the files to update. Each string should refer to a file in

               the filesystem. The name of the file may be a relative path or a fully-qualified path.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddFiles(System.Collections.Generic.IEnumerable{System.String},System.String)">

             <summary>

               Adds a set of files to the <c>ZipFile</c>, using the

               specified directory path in the archive.

             </summary>

             <remarks>

             <para>

               Any directory structure that may be present in the

               filenames contained in the list is "flattened" in the

               archive.  Each file in the list is added to the archive in

               the specified top-level directory.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>, <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their respective values at the

               time of this call will be applied to each ZipEntry added.

             </para>

             </remarks>

             <param name="fileNames">

               The names of the files to add. Each string should refer to

               a file in the filesystem.  The name of the file may be a

               relative path or a fully-qualified path.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the file name.

               Th is path may, or may not, correspond to a real directory in the current

               filesystem.  If the files within the zip are later extracted, this is the

               path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in

               VB) will use the path on each of the <c>fileNames</c>, if any.  Passing

               the empty string ("") will insert the item at the root path within the

               archive.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddFiles(System.Collections.Generic.IEnumerable{System.String},System.Boolean,System.String)">

             <summary>

               Adds a set of files to the <c>ZipFile</c>, using the specified directory

               path in the archive, and preserving the full directory structure in the

               filenames.

             </summary>

             <remarks>

             <para>

               Think of the <paramref name="directoryPathInArchive"/> as a "root" or

               base directory used in the archive for the files that get added.  when

               <paramref name="preserveDirHierarchy"/> is true, the hierarchy of files

               found in the filesystem will be placed, with the hierarchy intact,

               starting at that root in the archive. When <c>preserveDirHierarchy</c>

               is false, the path hierarchy of files is flattned, and the flattened

               set of files gets placed in the root within the archive as specified in

               <c>directoryPathInArchive</c>.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <param name="fileNames">

               The names of the files to add. Each string should refer to a file in the

               filesystem.  The name of the file may be a relative path or a

               fully-qualified path.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use as a prefix for each entry name.

               This path may, or may not, correspond to a real directory in the current

               filesystem.  If the files within the zip are later extracted, this is the

               path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in

               VB) will use the path on each of the <c>fileNames</c>, if any.  Passing

               the empty string ("") will insert the item at the root path within the

               archive.

             </param>

             <param name="preserveDirHierarchy">

               whether the entries in the zip archive will reflect the directory

               hierarchy that is present in the various filenames.  For example, if

               <paramref name="fileNames"/> includes two paths,

               \Animalia\Chordata\Mammalia\Info.txt and

               \Plantae\Magnoliophyta\Dicotyledon\Info.txt, then calling this method

               with <paramref name="preserveDirHierarchy"/> = <c>false</c> will

               result in an exception because of a duplicate entry name, while

               calling this method with <paramref name="preserveDirHierarchy"/> =

               <c>true</c> will result in the full direcory paths being included in

               the entries added to the ZipFile.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateFiles(System.Collections.Generic.IEnumerable{System.String},System.String)">

             <summary>

               Adds or updates a set of files to the <c>ZipFile</c>, using the specified

               directory path in the archive.

             </summary>

             <remarks>

             <para>

               Any files that already exist in the archive are updated. Any files that

               don't yet exist in the archive are added.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <param name="fileNames">

               The names of the files to add or update. Each string should refer to a

               file in the filesystem.  The name of the file may be a relative path or a

               fully-qualified path.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the file name.

               This path may, or may not, correspond to a real directory in the current

               filesystem.  If the files within the zip are later extracted, this is the

               path used for the extracted file.  Passing <c>null</c> (<c>Nothing</c> in

               VB) will use the path on each of the <c>fileNames</c>, if any.  Passing

               the empty string ("") will insert the item at the root path within the

               archive.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateFile(System.String)">

             <summary>

               Adds or Updates a File in a Zip file archive.

             </summary>

             <remarks>

             <para>

               This method adds a file to a zip archive, or, if the file already exists

               in the zip archive, this method Updates the content of that given filename

               in the zip archive.  The <c>UpdateFile</c> method might more accurately be

               called "AddOrUpdateFile".

             </para>

             <para>

               Upon success, there is no way for the application to learn whether the file

               was added versus updated.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <example>

               This example shows how to Update an existing entry in a zipfile. The first

               call to UpdateFile adds the file to the newly-created zip archive.  The

               second call to UpdateFile updates the content for that file in the zip

               archive.

             <code>

             using (ZipFile zip1 = new ZipFile())

             {

               // UpdateFile might more accurately be called "AddOrUpdateFile"

               zip1.UpdateFile("MyDocuments\\Readme.txt");

               zip1.UpdateFile("CustomerList.csv");

               zip1.Comment = "This zip archive has been created.";

               zip1.Save("Content.zip");

             }

             using (ZipFile zip2 = ZipFile.Read("Content.zip"))

             {

               zip2.UpdateFile("Updates\\Readme.txt");

               zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed.";

               zip2.Save();

             }

             </code>

             <code lang="VB">

               Using zip1 As New ZipFile

                   ' UpdateFile might more accurately be called "AddOrUpdateFile"

                   zip1.UpdateFile("MyDocuments\Readme.txt")

                   zip1.UpdateFile("CustomerList.csv")

                   zip1.Comment = "This zip archive has been created."

                   zip1.Save("Content.zip")

               End Using

               Using zip2 As ZipFile = ZipFile.Read("Content.zip")

                   zip2.UpdateFile("Updates\Readme.txt")

                   zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed."

                   zip2.Save

               End Using

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String)"/>

             <param name="fileName">

               The name of the file to add or update. It should refer to a file in the

               filesystem.  The name of the file may be a relative path or a

               fully-qualified path.

             </param>

             <returns>

               The <c>ZipEntry</c> corresponding to the File that was added or updated.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateFile(System.String,System.String)">

             <summary>

               Adds or Updates a File in a Zip file archive.

             </summary>

             <remarks>

             <para>

               This method adds a file to a zip archive, or, if the file already exists

               in the zip archive, this method Updates the content of that given filename

               in the zip archive.

             </para>

             <para>

               This version of the method allows the caller to explicitly specify the

               directory path to be used in the archive.  The entry to be added or

               updated is found by using the specified directory path, combined with the

               basename of the specified filename.

             </para>

             <para>

               Upon success, there is no way for the application to learn if the file was

               added versus updated.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String,System.String)"/>

             <param name="fileName">

               The name of the file to add or update. It should refer to a file in the

               filesystem.  The name of the file may be a relative path or a

               fully-qualified path.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the

               <c>fileName</c>.  This path may, or may not, correspond to a real

               directory in the current filesystem.  If the files within the zip are

               later extracted, this is the path used for the extracted file.  Passing

               <c>null</c> (<c>Nothing</c> in VB) will use the path on the

               <c>fileName</c>, if any.  Passing the empty string ("") will insert the

               item at the root path within the archive.

             </param>

             <returns>

               The <c>ZipEntry</c> corresponding to the File that was added or updated.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String)">

             <summary>

               Add or update a directory in a zip archive.

             </summary>

             <remarks>

               If the specified directory does not exist in the archive, then this method

               is equivalent to calling <c>AddDirectory()</c>.  If the specified

               directory already exists in the archive, then this method updates any

               existing entries, and adds any new entries. Any entries that are in the

               zip archive but not in the specified directory, are left alone.  In other

               words, the contents of the zip file will be a union of the previous

               contents and the new files.

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String)"/>

             <param name="directoryName">

               The path to the directory to be added to the zip archive, or updated in

               the zip archive.

             </param>

             <returns>

             The <c>ZipEntry</c> corresponding to the Directory that was added or updated.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String,System.String)">

             <summary>

               Add or update a directory in the zip archive at the specified root

               directory in the archive.

             </summary>

             <remarks>

               If the specified directory does not exist in the archive, then this method

               is equivalent to calling <c>AddDirectory()</c>.  If the specified

               directory already exists in the archive, then this method updates any

               existing entries, and adds any new entries. Any entries that are in the

               zip archive but not in the specified directory, are left alone.  In other

               words, the contents of the zip file will be a union of the previous

               contents and the new files.

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateItem(System.String,System.String)"/>

             <param name="directoryName">

               The path to the directory to be added to the zip archive, or updated

               in the zip archive.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the

               <c>directoryName</c>.  This path may, or may not, correspond to a real

               directory in the current filesystem.  If the files within the zip are

               later extracted, this is the path used for the extracted file.  Passing

               <c>null</c> (<c>Nothing</c> in VB) will use the path on the

               <c>directoryName</c>, if any.  Passing the empty string ("") will insert

               the item at the root path within the archive.

             </param>

             <returns>

               The <c>ZipEntry</c> corresponding to the Directory that was added or updated.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateItem(System.String)">

             <summary>

               Add or update a file or directory in the zip archive.

             </summary>

             <remarks>

             <para>

               This is useful when the application is not sure or does not care if the

               item to be added is a file or directory, and does not know or does not

               care if the item already exists in the <c>ZipFile</c>. Calling this method

               is equivalent to calling <c>RemoveEntry()</c> if an entry by the same name

               already exists, followed calling by <c>AddItem()</c>.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String)"/>

             <param name="itemName">

              the path to the file or directory to be added or updated.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateItem(System.String,System.String)">

             <summary>

               Add or update a file or directory.

             </summary>

             <remarks>

             <para>

               This method is useful when the application is not sure or does not care if

               the item to be added is a file or directory, and does not know or does not

               care if the item already exists in the <c>ZipFile</c>. Calling this method

               is equivalent to calling <c>RemoveEntry()</c>, if an entry by that name

               exists, and then calling <c>AddItem()</c>.

             </para>

             <para>

               This version of the method allows the caller to explicitly specify the

               directory path to be used for the item being added to the archive.  The

               entry or entries that are added or updated will use the specified

               <c>DirectoryPathInArchive</c>. Extracting the entry from the archive will

               result in a file stored in that directory path.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateFile(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>

             <param name="itemName">

               The path for the File or Directory to be added or updated.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the

               <c>itemName</c>.  This path may, or may not, correspond to a real

               directory in the current filesystem.  If the files within the zip are

               later extracted, this is the path used for the extracted file.  Passing

               <c>null</c> (<c>Nothing</c> in VB) will use the path on the

               <c>itemName</c>, if any.  Passing the empty string ("") will insert the

               item at the root path within the archive.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String)">

             <summary>

               Adds a named entry into the zip archive, taking content for the entry

               from a string.

             </summary>

             <remarks>

               Calling this method creates an entry using the given fileName and

               directory path within the archive.  There is no need for a file by the

               given name to exist in the filesystem; the name is used within the zip

               archive only. The content for the entry is encoded using the default text

               encoding for the machine, or on Silverlight, using UTF-8.

             </remarks>

             <param name="content">

               The content of the file, should it be extracted from the zip.

             </param>

             <param name="entryName">

               The name, including any path, to use for the entry within the archive.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

             <example>

             This example shows how to add an entry to the zipfile, using a string as

             content for that entry.

             <code lang="C#">

             string Content = "This string will be the content of the Readme.txt file in the zip archive.";

             using (ZipFile zip1 = new ZipFile())

             {

               zip1.AddFile("MyDocuments\\Resume.doc", "files");

               zip1.AddEntry("Readme.txt", Content);

               zip1.Comment = "This zip file was created at " + System.DateTime.Now.ToString("G");

               zip1.Save("Content.zip");

             }

             </code>

             <code lang="VB">

             Public Sub Run()

               Dim Content As String = "This string will be the content of the Readme.txt file in the zip archive."

               Using zip1 As ZipFile = New ZipFile

                 zip1.AddEntry("Readme.txt", Content)

                 zip1.AddFile("MyDocuments\Resume.doc", "files")

                 zip1.Comment = ("This zip file was created at " &amp; DateTime.Now.ToString("G"))

                 zip1.Save("Content.zip")

               End Using

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String,System.Text.Encoding)">

             <summary>

               Adds a named entry into the zip archive, taking content for the entry

               from a string, and using the specified text encoding.

             </summary>

             <remarks>

             <para>

               Calling this method creates an entry using the given fileName and

               directory path within the archive.  There is no need for a file by the

               given name to exist in the filesystem; the name is used within the zip

               archive only.

             </para>

             <para>

               The content for the entry, a string value, is encoded using the given

               text encoding. A BOM (byte-order-mark) is emitted into the file, if the

               Encoding parameter is set for that.

             </para>

             <para>

               Most Encoding classes support a constructor that accepts a boolean,

               indicating whether to emit a BOM or not. For example see <see cref="M:System.Text.UTF8Encoding.#ctor(System.Boolean)"/>.

             </para>

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="content">

               The content of the file, should it be extracted from the zip.

             </param>

             <param name="encoding">

               The text encoding to use when encoding the string. Be aware: This is

               distinct from the text encoding used to encode the fileName, as specified

               in <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)">

             <summary>

               Create an entry in the <c>ZipFile</c> using the given <c>Stream</c>

               as input.  The entry will have the given filename.

             </summary>

             <remarks>

             <para>

               The application should provide an open, readable stream; in this case it

               will be read during the call to <see cref="M:Ionic.Zip.ZipFile.Save"/> or one of

               its overloads.

             </para>

             <para>

               The passed stream will be read from its current position. If

               necessary, callers should set the position in the stream before

               calling AddEntry(). This might be appropriate when using this method

               with a MemoryStream, for example.

             </para>

             <para>

               In cases where a large number of streams will be added to the

               <c>ZipFile</c>, the application may wish to avoid maintaining all of the

               streams open simultaneously.  To handle this situation, the application

               should use the <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>

               overload.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <example>

             <para>

               This example adds a single entry to a <c>ZipFile</c> via a <c>Stream</c>.

             </para>

             <code lang="C#">

             String zipToCreate = "Content.zip";

             String fileNameInArchive = "Content-From-Stream.bin";

             using (System.IO.Stream streamToRead = MyStreamOpener())

             {

               using (ZipFile zip = new ZipFile())

               {

                 ZipEntry entry= zip.AddEntry(fileNameInArchive, streamToRead);

                 zip.AddFile("Readme.txt");

                 zip.Save(zipToCreate);  // the stream is read implicitly here

               }

             }

             </code>

             <code lang="VB">

             Dim zipToCreate As String = "Content.zip"

             Dim fileNameInArchive As String = "Content-From-Stream.bin"

             Using streamToRead as System.IO.Stream = MyStreamOpener()

               Using zip As ZipFile = New ZipFile()

                 Dim entry as ZipEntry = zip.AddEntry(fileNameInArchive, streamToRead)

                 zip.AddFile("Readme.txt")

                 zip.Save(zipToCreate)  '' the stream is read implicitly, here

               End Using

             End Using

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,System.IO.Stream)"/>

             <param name="entryName">

               The name, including any path, which is shown in the zip file for the added

               entry.

             </param>

             <param name="stream">

               The input stream from which to grab content for the file

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.WriteDelegate)">

             <summary>

               Add a ZipEntry for which content is written directly by the application.

             </summary>

             <remarks>

             <para>

               When the application needs to write the zip entry data, use this

               method to add the ZipEntry. For example, in the case that the

               application wishes to write the XML representation of a DataSet into

               a ZipEntry, the application can use this method to do so.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             <para>

               About progress events: When using the WriteDelegate, DotNetZip does

               not issue any SaveProgress events with <c>EventType</c> = <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_EntryBytesRead">

               Saving_EntryBytesRead</see>. (This is because it is the

               application's code that runs in WriteDelegate - there's no way for

               DotNetZip to know when to issue a EntryBytesRead event.)

               Applications that want to update a progress bar or similar status

               indicator should do so from within the WriteDelegate

               itself. DotNetZip will issue the other SaveProgress events,

               including <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_Started">

               Saving_Started</see>,

               <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_BeforeWriteEntry">

               Saving_BeforeWriteEntry</see>, and <see cref="F:Ionic.Zip.ZipProgressEventType.Saving_AfterWriteEntry">

               Saving_AfterWriteEntry</see>.

             </para>

             <para>

               Note: When you use PKZip encryption, it's normally necessary to

               compute the CRC of the content to be encrypted, before compressing or

               encrypting it. Therefore, when using PKZip encryption with a

               WriteDelegate, the WriteDelegate CAN BE called twice: once to compute

               the CRC, and the second time to potentially compress and

               encrypt. Surprising, but true. This is because PKWARE specified that

               the encryption initialization data depends on the CRC.

               If this happens, for each call of the delegate, your

               application must stream the same entry data in its entirety. If your

               application writes different data during the second call, it will

               result in a corrupt zip file.

             </para>

             <para>

               The double-read behavior happens with all types of entries, not only

               those that use WriteDelegate. It happens if you add an entry from a

               filesystem file, or using a string, or a stream, or an opener/closer

               pair. But in those cases, DotNetZip takes care of reading twice; in

               the case of the WriteDelegate, the application code gets invoked

               twice. Be aware.

             </para>

             <para>

               As you can imagine, this can cause performance problems for large

               streams, and it can lead to correctness problems when you use a

               <c>WriteDelegate</c>. This is a pretty big pitfall.  There are two

               ways to avoid it.  First, and most preferred: don't use PKZIP

               encryption.  If you use the WinZip AES encryption, this problem

               doesn't occur, because the encryption protocol doesn't require the CRC

               up front. Second: if you do choose to use PKZIP encryption, write out

               to a non-seekable stream (like standard output, or the

               Response.OutputStream in an ASP.NET application).  In this case,

               DotNetZip will use an alternative encryption protocol that does not

               rely on the CRC of the content.  This also implies setting bit 3 in

               the zip entry, which still presents problems for some zip tools.

             </para>

             <para>

               In the future I may modify DotNetZip to *always* use bit 3 when PKZIP

               encryption is in use.  This seems like a win overall, but there will

               be some work involved.  If you feel strongly about it, visit the

               DotNetZip forums and vote up <see href="http://dotnetzip.codeplex.com/workitem/13686">the Workitem

               tracking this issue</see>.

             </para>

             </remarks>

             <param name="entryName">the name of the entry to add</param>

             <param name="writer">the delegate which will write the entry content</param>

             <returns>the ZipEntry added</returns>

             <example>

               This example shows an application filling a DataSet, then saving the

               contents of that DataSet as XML, into a ZipEntry in a ZipFile, using an

               anonymous delegate in C#. The DataSet XML is never saved to a disk file.

             <code lang="C#">

             var c1= new System.Data.SqlClient.SqlConnection(connstring1);

             var da = new System.Data.SqlClient.SqlDataAdapter()

                 {

                     SelectCommand=  new System.Data.SqlClient.SqlCommand(strSelect, c1)

                 };

             DataSet ds1 = new DataSet();

             da.Fill(ds1, "Invoices");

             using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())

             {

                 zip.AddEntry(zipEntryName, (name,stream) =&gt; ds1.WriteXml(stream) );

                 zip.Save(zipFileName);

             }

             </code>

             </example>

             <example>

             This example uses an anonymous method in C# as the WriteDelegate to provide

             the data for the ZipEntry. The example is a bit contrived - the

             <c>AddFile()</c> method is a simpler way to insert the contents of a file

             into an entry in a zip file. On the other hand, if there is some sort of

             processing or transformation of the file contents required before writing,

             the application could use the <c>WriteDelegate</c> to do it, in this way.

             <code lang="C#">

             using (var input = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ))

             {

                 using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())

                 {

                     zip.AddEntry(zipEntryName, (name,output) =&gt;

                         {

                             byte[] buffer = new byte[BufferSize];

                             int n;

                             while ((n = input.Read(buffer, 0, buffer.Length)) != 0)

                             {

                                 // could transform the data here...

                                 output.Write(buffer, 0, n);

                                 // could update a progress bar here

                             }

                         });

                     zip.Save(zipFileName);

                 }

             }

             </code>

             </example>

             <example>

             This example uses a named delegate in VB to write data for the given

             ZipEntry (VB9 does not have anonymous delegates). The example here is a bit

             contrived - a simpler way to add the contents of a file to a ZipEntry is to

             simply use the appropriate <c>AddFile()</c> method.  The key scenario for

             which the <c>WriteDelegate</c> makes sense is saving a DataSet, in XML

             format, to the zip file. The DataSet can write XML to a stream, and the

             WriteDelegate is the perfect place to write into the zip file.  There may be

             other data structures that can write to a stream, but cannot be read as a

             stream.  The <c>WriteDelegate</c> would be appropriate for those cases as

             well.

             <code lang="VB">

             Private Sub WriteEntry (ByVal name As String, ByVal output As Stream)

                 Using input As FileStream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)

                     Dim n As Integer = -1

                     Dim buffer As Byte() = New Byte(BufferSize){}

                     Do While n &lt;&gt; 0

                         n = input.Read(buffer, 0, buffer.Length)

                         output.Write(buffer, 0, n)

                     Loop

                 End Using

             End Sub

             Public Sub Run()

                 Using zip = New ZipFile

                     zip.AddEntry(zipEntryName, New WriteDelegate(AddressOf WriteEntry))

                     zip.Save(zipFileName)

                 End Using

             End Sub

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)">

             <summary>

               Add an entry, for which the application will provide a stream

               containing the entry data, on a just-in-time basis.

             </summary>

             <remarks>

             <para>

               In cases where the application wishes to open the stream that

               holds the content for the ZipEntry, on a just-in-time basis, the

               application can use this method.  The application provides an

               opener delegate that will be called by the DotNetZip library to

               obtain a readable stream that can be read to get the bytes for

               the given entry.  Typically, this delegate opens a stream.

               Optionally, the application can provide a closer delegate as

               well, which will be called by DotNetZip when all bytes have been

               read from the entry.

             </para>

             <para>

               These delegates are called from within the scope of the call to

               ZipFile.Save().

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <example>

               This example uses anonymous methods in C# to open and close the

               source stream for the content for a zip entry.

             <code lang="C#">

             using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())

             {

                 zip.AddEntry(zipEntryName,

                              (name) =&gt;  File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ),

                              (name, stream) =&gt;  stream.Close()

                              );

                 zip.Save(zipFileName);

             }

             </code>

             </example>

             <example>

               This example uses delegates in VB.NET to open and close the

               the source stream for the content for a zip entry.  VB 9.0 lacks

               support for "Sub" lambda expressions, and so the CloseDelegate must

               be an actual, named Sub.

             <code lang="VB">

             Function MyStreamOpener(ByVal entryName As String) As Stream

                 '' This simply opens a file.  You probably want to do somethinig

                 '' more involved here: open a stream to read from a database,

                 '' open a stream on an HTTP connection, and so on.

                 Return File.OpenRead(entryName)

             End Function

             Sub MyStreamCloser(entryName As String, stream As Stream)

                 stream.Close()

             End Sub

             Public Sub Run()

                 Dim dirToZip As String = "fodder"

                 Dim zipFileToCreate As String = "Archive.zip"

                 Dim opener As OpenDelegate = AddressOf MyStreamOpener

                 Dim closer As CloseDelegate = AddressOf MyStreamCloser

                 Dim numFilestoAdd As Int32 = 4

                 Using zip As ZipFile = New ZipFile

                     Dim i As Integer

                     For i = 0 To numFilesToAdd - 1

                         zip.AddEntry(String.Format("content-{0:000}.txt"), opener, closer)

                     Next i

                     zip.Save(zipFileToCreate)

                 End Using

             End Sub

             </code>

             </example>

             <param name="entryName">the name of the entry to add</param>

             <param name="opener">

              the delegate that will be invoked by ZipFile.Save() to get the

              readable stream for the given entry. ZipFile.Save() will call

              read on this stream to obtain the data for the entry. This data

              will then be compressed and written to the newly created zip

              file.

             </param>

             <param name="closer">

              the delegate that will be invoked to close the stream. This may

              be null (Nothing in VB), in which case no call is makde to close

              the stream.

             </param>

             <returns>the ZipEntry added</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,System.String)">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given

               string as content for the <c>ZipEntry</c>.

             </summary>

             <remarks>

             <para>

               Calling this method is equivalent to removing the <c>ZipEntry</c> for

               the given file name and directory path, if it exists, and then calling

               <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String)"/>.  See the documentation for

               that method for further explanation. The string content is encoded

               using the default encoding for the machine, or on Silverlight, using

               UTF-8. This encoding is distinct from the encoding used for the

               filename itself.  See <see cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/>.

             </para>

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="content">

               The content of the file, should it be extracted from the zip.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,System.String,System.Text.Encoding)">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given string as

               content for the <c>ZipEntry</c>.

             </summary>

             <remarks>

               Calling this method is equivalent to removing the <c>ZipEntry</c> for the

               given file name and directory path, if it exists, and then calling <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.String,System.Text.Encoding)"/>.  See the

               documentation for that method for further explanation.

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="content">

               The content of the file, should it be extracted from the zip.

             </param>

             <param name="encoding">

               The text encoding to use when encoding the string. Be aware: This is

               distinct from the text encoding used to encode the filename. See <see cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/>.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,Ionic.Zip.WriteDelegate)">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given delegate

               as the source for content for the <c>ZipEntry</c>.

             </summary>

             <remarks>

               Calling this method is equivalent to removing the <c>ZipEntry</c> for the

               given file name and directory path, if it exists, and then calling <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.WriteDelegate)"/>.  See the

               documentation for that method for further explanation.

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="writer">the delegate which will write the entry content.</param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given delegates

               to open and close the stream that provides the content for the <c>ZipEntry</c>.

             </summary>

             <remarks>

               Calling this method is equivalent to removing the <c>ZipEntry</c> for the

               given file name and directory path, if it exists, and then calling <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,Ionic.Zip.OpenDelegate,Ionic.Zip.CloseDelegate)"/>.  See the

               documentation for that method for further explanation.

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="opener">

              the delegate that will be invoked to open the stream

             </param>

             <param name="closer">

              the delegate that will be invoked to close the stream

             </param>

             <returns>The <c>ZipEntry</c> added or updated.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,System.IO.Stream)">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given stream as

               input, and the given filename and given directory Path.

             </summary>

             <remarks>

             <para>

               Calling the method is equivalent to calling <c>RemoveEntry()</c> if an

               entry by the same name already exists, and then calling <c>AddEntry()</c>

               with the given <c>fileName</c> and stream.

             </para>

             <para>

               The stream must be open and readable during the call to

               <c>ZipFile.Save</c>.  You can dispense the stream on a just-in-time basis

               using the <see cref="P:Ionic.Zip.ZipEntry.InputStream"/> property. Check the

               documentation of that property for more information.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to the

               <c>ZipEntry</c> added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)"/>

             <seealso cref="P:Ionic.Zip.ZipEntry.InputStream"/>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="stream">The input stream from which to read file data.</param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.Byte[])">

             <summary>

               Add an entry into the zip archive using the given filename and

               directory path within the archive, and the given content for the

               file. No file is created in the filesystem.

             </summary>

             <param name="byteContent">The data to use for the entry.</param>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateEntry(System.String,System.Byte[])">

             <summary>

               Updates the given entry in the <c>ZipFile</c>, using the given byte

               array as content for the entry.

             </summary>

             <remarks>

               Calling this method is equivalent to removing the <c>ZipEntry</c>

               for the given filename and directory path, if it exists, and then

               calling <see cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.Byte[])"/>.  See the

               documentation for that method for further explanation.

             </remarks>

             <param name="entryName">

               The name, including any path, to use within the archive for the entry.

             </param>

             <param name="byteContent">The content to use for the <c>ZipEntry</c>.</param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddDirectory(System.String)">

             <summary>

               Adds the contents of a filesystem directory to a Zip file archive.

             </summary>

             <remarks>

             <para>

               The name of the directory may be a relative path or a fully-qualified

               path. Any files within the named directory are added to the archive.  Any

               subdirectories within the named directory are also added to the archive,

               recursively.

             </para>

             <para>

               Top-level entries in the named directory will appear as top-level entries

               in the zip archive.  Entries in subdirectories in the named directory will

               result in entries in subdirectories in the zip archive.

             </para>

             <para>

               If you want the entries to appear in a containing directory in the zip

               archive itself, then you should call the AddDirectory() overload that

               allows you to explicitly specify a directory path for use in the archive.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String,System.String)"/>

             <overloads>This method has 2 overloads.</overloads>

             <param name="directoryName">The name of the directory to add.</param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddDirectory(System.String,System.String)">

             <summary>

               Adds the contents of a filesystem directory to a Zip file archive,

               overriding the path to be used for entries in the archive.

             </summary>

             <remarks>

             <para>

               The name of the directory may be a relative path or a fully-qualified

               path. The add operation is recursive, so that any files or subdirectories

               within the name directory are also added to the archive.

             </para>

             <para>

               Top-level entries in the named directory will appear as top-level entries

               in the zip archive.  Entries in subdirectories in the named directory will

               result in entries in subdirectories in the zip archive.

             </para>

             <para>

               For <c>ZipFile</c> properties including <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.SetCompression"/>, <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>, <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>,

               <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, their

               respective values at the time of this call will be applied to each

               ZipEntry added.

             </para>

             </remarks>

             <example>

             <para>

               In this code, calling the ZipUp() method with a value of "c:\reports" for

               the directory parameter will result in a zip file structure in which all

               entries are contained in a toplevel "reports" directory.

             </para>

             <code lang="C#">

             public void ZipUp(string targetZip, string directory)

             {

               using (var zip = new ZipFile())

               {

                 zip.AddDirectory(directory, System.IO.Path.GetFileName(directory));

                 zip.Save(targetZip);

               }

             }

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.AddItem(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.AddFile(System.String,System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>

             <param name="directoryName">The name of the directory to add.</param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to override any path in the

               DirectoryName.  This path may, or may not, correspond to a real directory

               in the current filesystem.  If the zip is later extracted, this is the

               path used for the extracted file or directory.  Passing <c>null</c>

               (<c>Nothing</c> in VB) or the empty string ("") will insert the items at

               the root path within the archive.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddDirectoryByName(System.String)">

             <summary>

               Creates a directory in the zip archive.

             </summary>

             <remarks>

             <para>

               Use this when you want to create a directory in the archive but there is

               no corresponding filesystem representation for that directory.

             </para>

             <para>

               You will probably not need to do this in your code. One of the only times

               you will want to do this is if you want an empty directory in the zip

               archive.  The reason: if you add a file to a zip archive that is stored

               within a multi-level directory, all of the directory tree is implicitly

               created in the zip archive.

             </para>

             </remarks>

             <param name="directoryNameInArchive">

               The name of the directory to create in the archive.

             </param>

             <returns>The <c>ZipEntry</c> added.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.CheckZip(System.String)">

             <summary>

               Checks a zip file to see if its directory is consistent.

             </summary>

             <remarks>

             <para>

               In cases of data error, the directory within a zip file can get out

               of synch with the entries in the zip file.  This method checks the

               given zip file and returns true if this has occurred.

             </para>

             <para> This method may take a long time to run for large zip files.  </para>

             <para>

               This method is not supported in the Reduced or Compact Framework

               versions of DotNetZip.

             </para>

             <para>

               Developers using COM can use the <see cref="M:Ionic.Zip.ComHelper.CheckZip(System.String)">ComHelper.CheckZip(String)</see>

               method.

             </para>

             </remarks>

             <param name="zipFileName">The filename to of the zip file to check.</param>

             <returns>true if the named zip file checks OK. Otherwise, false. </returns>

             <seealso cref="M:Ionic.Zip.ZipFile.FixZipDirectory(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.CheckZip(System.String,System.Boolean,System.IO.TextWriter)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.CheckZip(System.String,System.Boolean,System.IO.TextWriter)">

             <summary>

               Checks a zip file to see if its directory is consistent,

               and optionally fixes the directory if necessary.

             </summary>

             <remarks>

             <para>

               In cases of data error, the directory within a zip file can get out of

               synch with the entries in the zip file.  This method checks the given

               zip file, and returns true if this has occurred. It also optionally

               fixes the zipfile, saving the fixed copy in <em>Name</em>_Fixed.zip.

             </para>

             <para>

               This method may take a long time to run for large zip files.  It

               will take even longer if the file actually needs to be fixed, and if

               <c>fixIfNecessary</c> is true.

             </para>

             <para>

               This method is not supported in the Reduced or Compact

               Framework versions of DotNetZip.

             </para>

             </remarks>

             <param name="zipFileName">The filename to of the zip file to check.</param>

             <param name="fixIfNecessary">If true, the method will fix the zip file if

                 necessary.</param>

             <param name="writer">

             a TextWriter in which messages generated while checking will be written.

             </param>

             <returns>true if the named zip is OK; false if the file needs to be fixed.</returns>

             <seealso cref="M:Ionic.Zip.ZipFile.CheckZip(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.FixZipDirectory(System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.FixZipDirectory(System.String)">

             <summary>

               Rewrite the directory within a zipfile.

             </summary>

             <remarks>

             <para>

               In cases of data error, the directory in a zip file can get out of

               synch with the entries in the zip file.  This method attempts to fix

               the zip file if this has occurred.

             </para>

             <para> This can take a long time for large zip files. </para>

             <para> This won't work if the zip file uses a non-standard

             code page - neither IBM437 nor UTF-8. </para>

             <para>

               This method is not supported in the Reduced or Compact Framework

               versions of DotNetZip.

             </para>

             <para>

               Developers using COM can use the <see cref="M:Ionic.Zip.ComHelper.FixZipDirectory(System.String)">ComHelper.FixZipDirectory(String)</see>

               method.

             </para>

             </remarks>

             <param name="zipFileName">The filename to of the zip file to fix.</param>

             <seealso cref="M:Ionic.Zip.ZipFile.CheckZip(System.String)"/>

             <seealso cref="M:Ionic.Zip.ZipFile.CheckZip(System.String,System.Boolean,System.IO.TextWriter)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.CheckZipPassword(System.String,System.String)">

             <summary>

               Verify the password on a zip file.

             </summary>

             <remarks>

               <para>

                 Keep in mind that passwords in zipfiles are applied to

                 zip entries, not to the entire zip file. So testing a

                 zipfile for a particular password doesn't work in the

                 general case. On the other hand, it's often the case

                 that a single password will be used on all entries in a

                 zip file. This method works for that case.

               </para>

               <para>

                 There is no way to check a password without doing the

                 decryption. So this code decrypts and extracts the given

                 zipfile into <see cref="F:System.IO.Stream.Null"/>

               </para>

             </remarks>

             <param name="zipFileName">The filename to of the zip file to fix.</param>

             <param name="password">The password to check.</param>

             <returns>a bool indicating whether the password matches.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ContainsEntry(System.String)">

             <summary>

               Returns true if an entry by the given name exists in the ZipFile.

             </summary>

             <param name='name'>the name of the entry to find</param>

             <returns>true if an entry with the given name exists; otherwise false.

             </returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ToString">

            <summary>Provides a string representation of the instance.</summary>

            <returns>a string representation of the instance.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor(System.String)">

             <summary>

               Creates a new <c>ZipFile</c> instance, using the specified filename.

             </summary>

             <remarks>

             <para>

               Applications can use this constructor to create a new ZipFile for writing,

               or to slurp in an existing zip archive for read and update purposes.

             </para>

             <para>

               To create a new zip archive, an application can call this constructor,

               passing the name of a file that does not exist.  The name may be a fully

               qualified path. Then the application can add directories or files to the

               <c>ZipFile</c> via <c>AddDirectory()</c>, <c>AddFile()</c>, <c>AddItem()</c>

               and then write the zip archive to the disk by calling <c>Save()</c>. The

               zip file is not actually opened and written to the disk until the

               application calls <c>ZipFile.Save()</c>.  At that point the new zip file

               with the given name is created.

             </para>

             <para>

               If you won't know the name of the <c>Zipfile</c> until the time you call

               <c>ZipFile.Save()</c>, or if you plan to save to a stream (which has no

               name), then you should use the no-argument constructor.

             </para>

             <para>

               The application can also call this constructor to read an existing zip

               archive.  passing the name of a valid zip file that does exist. But, it's

               better form to use the static <see cref="M:Ionic.Zip.ZipFile.Read(System.String)"/> method,

               passing the name of the zip file, because using <c>ZipFile.Read()</c> in

               your code communicates very clearly what you are doing.  In either case,

               the file is then read into the <c>ZipFile</c> instance.  The app can then

               enumerate the entries or can modify the zip file, for example adding

               entries, removing entries, changing comments, and so on.

             </para>

             <para>

               One advantage to this parameterized constructor: it allows applications to

               use the same code to add items to a zip archive, regardless of whether the

               zip file exists.

             </para>

             <para>

               Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may

               not party on a single instance with multiple threads.  You may have

               multiple threads that each use a distinct <c>ZipFile</c> instance, or you

               can synchronize multi-thread access to a single instance.

             </para>

             <para>

               By the way, since DotNetZip is so easy to use, don't you think <see href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">you should

               donate $5 or $10</see>?

             </para>

             </remarks>

             <exception cref="T:Ionic.Zip.ZipException">

             Thrown if name refers to an existing file that is not a valid zip file.

             </exception>

             <example>

             This example shows how to create a zipfile, and add a few files into it.

             <code>

             String ZipFileToCreate = "archive1.zip";

             String DirectoryToZip  = "c:\\reports";

             using (ZipFile zip = new ZipFile())

             {

               // Store all files found in the top level directory, into the zip archive.

               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);

               zip.AddFiles(filenames, "files");

               zip.Save(ZipFileToCreate);

             }

             </code>

             <code lang="VB">

             Dim ZipFileToCreate As String = "archive1.zip"

             Dim DirectoryToZip As String = "c:\reports"

             Using zip As ZipFile = New ZipFile()

                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)

                 zip.AddFiles(filenames, "files")

                 zip.Save(ZipFileToCreate)

             End Using

             </code>

             </example>

             <param name="fileName">The filename to use for the new zip archive.</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor(System.String,System.Text.Encoding)">

             <summary>

               Creates a new <c>ZipFile</c> instance, using the specified name for the

               filename, and the specified Encoding.

             </summary>

             <remarks>

             <para>

               See the documentation on the <see cref="M:Ionic.Zip.ZipFile.#ctor(System.String)">ZipFile

               constructor that accepts a single string argument</see> for basic

               information on all the <c>ZipFile</c> constructors.

             </para>

             <para>

               The Encoding is used as the default alternate encoding for entries with

               filenames or comments that cannot be encoded with the IBM437 code page.

               This is equivalent to setting the <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> property on the <c>ZipFile</c>

               instance after construction.

             </para>

             <para>

               Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may

               not party on a single instance with multiple threads.  You may have

               multiple threads that each use a distinct <c>ZipFile</c> instance, or you

               can synchronize multi-thread access to a single instance.

             </para>

             </remarks>

             <exception cref="T:Ionic.Zip.ZipException">

             Thrown if name refers to an existing file that is not a valid zip file.

             </exception>

             <param name="fileName">The filename to use for the new zip archive.</param>

             <param name="encoding">The Encoding is used as the default alternate

             encoding for entries with filenames or comments that cannot be encoded

             with the IBM437 code page. </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor">

             <summary>

               Create a zip file, without specifying a target filename or stream to save to.

             </summary>

             <remarks>

             <para>

               See the documentation on the <see cref="M:Ionic.Zip.ZipFile.#ctor(System.String)">ZipFile

               constructor that accepts a single string argument</see> for basic

               information on all the <c>ZipFile</c> constructors.

             </para>

             <para>

               After instantiating with this constructor and adding entries to the

               archive, the application should call <see cref="M:Ionic.Zip.ZipFile.Save(System.String)"/> or

               <see cref="M:Ionic.Zip.ZipFile.Save(System.IO.Stream)"/> to save to a file or a

               stream, respectively.  The application can also set the <see cref="P:Ionic.Zip.ZipFile.Name"/>

               property and then call the no-argument <see cref="M:Ionic.Zip.ZipFile.Save"/> method.  (This

               is the preferred approach for applications that use the library through

               COM interop.)  If you call the no-argument <see cref="M:Ionic.Zip.ZipFile.Save"/> method

               without having set the <c>Name</c> of the <c>ZipFile</c>, either through

               the parameterized constructor or through the explicit property , the

               Save() will throw, because there is no place to save the file.  </para>

             <para>

               Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may

               have multiple threads that each use a distinct <c>ZipFile</c> instance, or

               you can synchronize multi-thread access to a single instance.  </para>

             </remarks>

             <example>

             This example creates a Zip archive called Backup.zip, containing all the files

             in the directory DirectoryToZip. Files within subdirectories are not zipped up.

             <code>

             using (ZipFile zip = new ZipFile())

             {

               // Store all files found in the top level directory, into the zip archive.

               // note: this code does not recurse subdirectories!

               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);

               zip.AddFiles(filenames, "files");

               zip.Save("Backup.zip");

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 ' Store all files found in the top level directory, into the zip archive.

                 ' note: this code does not recurse subdirectories!

                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)

                 zip.AddFiles(filenames, "files")

                 zip.Save("Backup.zip")

             End Using

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor(System.Text.Encoding)">

             <summary>

               Create a zip file, specifying a text Encoding, but without specifying a

               target filename or stream to save to.

             </summary>

             <remarks>

             <para>

               See the documentation on the <see cref="M:Ionic.Zip.ZipFile.#ctor(System.String)">ZipFile

               constructor that accepts a single string argument</see> for basic

               information on all the <c>ZipFile</c> constructors.

             </para>

             </remarks>

             <param name="encoding">

             The Encoding is used as the default alternate encoding for entries with

             filenames or comments that cannot be encoded with the IBM437 code page.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor(System.String,System.IO.TextWriter)">

             <summary>

               Creates a new <c>ZipFile</c> instance, using the specified name for the

               filename, and the specified status message writer.

             </summary>

             <remarks>

             <para>

               See the documentation on the <see cref="M:Ionic.Zip.ZipFile.#ctor(System.String)">ZipFile

               constructor that accepts a single string argument</see> for basic

               information on all the <c>ZipFile</c> constructors.

             </para>

             <para>

               This version of the constructor allows the caller to pass in a TextWriter,

               to which verbose messages will be written during extraction or creation of

               the zip archive.  A console application may wish to pass

               System.Console.Out to get messages on the Console. A graphical or headless

               application may wish to capture the messages in a different

               <c>TextWriter</c>, for example, a <c>StringWriter</c>, and then display

               the messages in a TextBox, or generate an audit log of ZipFile operations.

             </para>

             <para>

               To encrypt the data for the files added to the <c>ZipFile</c> instance,

               set the Password property after creating the <c>ZipFile</c> instance.

             </para>

             <para>

               Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may

               not party on a single instance with multiple threads.  You may have

               multiple threads that each use a distinct <c>ZipFile</c> instance, or you

               can synchronize multi-thread access to a single instance.

             </para>

             </remarks>

             <exception cref="T:Ionic.Zip.ZipException">

             Thrown if name refers to an existing file that is not a valid zip file.

             </exception>

             <example>

             <code>

             using (ZipFile zip = new ZipFile("Backup.zip", Console.Out))

             {

               // Store all files found in the top level directory, into the zip archive.

               // note: this code does not recurse subdirectories!

               // Status messages will be written to Console.Out

               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);

               zip.AddFiles(filenames);

               zip.Save();

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile("Backup.zip", Console.Out)

                 ' Store all files found in the top level directory, into the zip archive.

                 ' note: this code does not recurse subdirectories!

                 ' Status messages will be written to Console.Out

                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)

                 zip.AddFiles(filenames)

                 zip.Save()

             End Using

             </code>

             </example>

             <param name="fileName">The filename to use for the new zip archive.</param>

             <param name="statusMessageWriter">A TextWriter to use for writing

             verbose status messages.</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.#ctor(System.String,System.IO.TextWriter,System.Text.Encoding)">

             <summary>

               Creates a new <c>ZipFile</c> instance, using the specified name for the

               filename, the specified status message writer, and the specified Encoding.

             </summary>

             <remarks>

             <para>

               This constructor works like the <see cref="M:Ionic.Zip.ZipFile.#ctor(System.String)">ZipFile

               constructor that accepts a single string argument.</see> See that

               reference for detail on what this constructor does.

             </para>

             <para>

               This version of the constructor allows the caller to pass in a

               <c>TextWriter</c>, and an Encoding.  The <c>TextWriter</c> will collect

               verbose messages that are generated by the library during extraction or

               creation of the zip archive.  A console application may wish to pass

               <c>System.Console.Out</c> to get messages on the Console. A graphical or

               headless application may wish to capture the messages in a different

               <c>TextWriter</c>, for example, a <c>StringWriter</c>, and then display

               the messages in a <c>TextBox</c>, or generate an audit log of

               <c>ZipFile</c> operations.

             </para>

             <para>

               The <c>Encoding</c> is used as the default alternate encoding for entries

               with filenames or comments that cannot be encoded with the IBM437 code

               page.  This is a equivalent to setting the <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> property on the <c>ZipFile</c>

               instance after construction.

             </para>

             <para>

               To encrypt the data for the files added to the <c>ZipFile</c> instance,

               set the <c>Password</c> property after creating the <c>ZipFile</c>

               instance.

             </para>

             <para>

               Instances of the <c>ZipFile</c> class are not multi-thread safe.  You may

               not party on a single instance with multiple threads.  You may have

               multiple threads that each use a distinct <c>ZipFile</c> instance, or you

               can synchronize multi-thread access to a single instance.

             </para>

             </remarks>

             <exception cref="T:Ionic.Zip.ZipException">

             Thrown if <c>fileName</c> refers to an existing file that is not a valid zip file.

             </exception>

             <param name="fileName">The filename to use for the new zip archive.</param>

             <param name="statusMessageWriter">A TextWriter to use for writing verbose

             status messages.</param>

             <param name="encoding">

             The Encoding is used as the default alternate encoding for entries with

             filenames or comments that cannot be encoded with the IBM437 code page.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Initialize(System.String)">

             <summary>

               Initialize a <c>ZipFile</c> instance by reading in a zip file.

             </summary>

             <remarks>

             <para>

               This method is primarily useful from COM Automation environments, when

               reading or extracting zip files. In COM, it is not possible to invoke

               parameterized constructors for a class. A COM Automation application can

               update a zip file by using the <see cref="M:Ionic.Zip.ZipFile.#ctor">default (no argument)

               constructor</see>, then calling <c>Initialize()</c> to read the contents

               of an on-disk zip archive into the <c>ZipFile</c> instance.

             </para>

             <para>

               .NET applications are encouraged to use the <c>ZipFile.Read()</c> methods

               for better clarity.

             </para>

             </remarks>

             <param name="fileName">the name of the existing zip file to read in.</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveEntry(Ionic.Zip.ZipEntry)">

             <summary>

               Removes the given <c>ZipEntry</c> from the zip archive.

             </summary>

             <remarks>

             <para>

               After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to

               make the changes permanent.

             </para>

             </remarks>

             <exception cref="T:System.ArgumentException">

               Thrown if the specified <c>ZipEntry</c> does not exist in the <c>ZipFile</c>.

             </exception>

             <example>

               In this example, all entries in the zip archive dating from before

               December 31st, 2007, are removed from the archive.  This is actually much

               easier if you use the RemoveSelectedEntries method.  But I needed an

               example for RemoveEntry, so here it is.

             <code>

             String ZipFileToRead = "ArchiveToModify.zip";

             System.DateTime Threshold = new System.DateTime(2007,12,31);

             using (ZipFile zip = ZipFile.Read(ZipFileToRead))

             {

               var EntriesToRemove = new System.Collections.Generic.List&lt;ZipEntry&gt;();

               foreach (ZipEntry e in zip)

               {

                 if (e.LastModified &lt; Threshold)

                 {

                   // We cannot remove the entry from the list, within the context of

                   // an enumeration of said list.

                   // So we add the doomed entry to a list to be removed later.

                   EntriesToRemove.Add(e);

                 }

               }

               // actually remove the doomed entries.

               foreach (ZipEntry zombie in EntriesToRemove)

                 zip.RemoveEntry(zombie);

               zip.Comment= String.Format("This zip archive was updated at {0}.",

                                          System.DateTime.Now.ToString("G"));

               // save with a different name

               zip.Save("Archive-Updated.zip");

             }

             </code>

             <code lang="VB">

               Dim ZipFileToRead As String = "ArchiveToModify.zip"

               Dim Threshold As New DateTime(2007, 12, 31)

               Using zip As ZipFile = ZipFile.Read(ZipFileToRead)

                   Dim EntriesToRemove As New System.Collections.Generic.List(Of ZipEntry)

                   Dim e As ZipEntry

                   For Each e In zip

                       If (e.LastModified &lt; Threshold) Then

                           ' We cannot remove the entry from the list, within the context of

                           ' an enumeration of said list.

                           ' So we add the doomed entry to a list to be removed later.

                           EntriesToRemove.Add(e)

                       End If

                   Next

                   ' actually remove the doomed entries.

                   Dim zombie As ZipEntry

                   For Each zombie In EntriesToRemove

                       zip.RemoveEntry(zombie)

                   Next

                   zip.Comment = String.Format("This zip archive was updated at {0}.", DateTime.Now.ToString("G"))

                   'save as a different name

                   zip.Save("Archive-Updated.zip")

               End Using

             </code>

             </example>

             <param name="entry">

             The <c>ZipEntry</c> to remove from the zip.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.RemoveSelectedEntries(System.String)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveEntry(System.String)">

             <summary>

             Removes the <c>ZipEntry</c> with the given filename from the zip archive.

             </summary>

             <remarks>

             <para>

               After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to

               make the changes permanent.

             </para>

             </remarks>

             <exception cref="T:System.InvalidOperationException">

               Thrown if the <c>ZipFile</c> is not updatable.

             </exception>

             <exception cref="T:System.ArgumentException">

               Thrown if a <c>ZipEntry</c> with the specified filename does not exist in

               the <c>ZipFile</c>.

             </exception>

             <example>

               This example shows one way to remove an entry with a given filename from

               an existing zip archive.

             <code>

             String zipFileToRead= "PackedDocuments.zip";

             string candidate = "DatedMaterial.xps";

             using (ZipFile zip = ZipFile.Read(zipFileToRead))

             {

               if (zip.EntryFilenames.Contains(candidate))

               {

                 zip.RemoveEntry(candidate);

                 zip.Comment= String.Format("The file '{0}' has been removed from this archive.",

                                            Candidate);

                 zip.Save();

               }

             }

             </code>

             <code lang="VB">

               Dim zipFileToRead As String = "PackedDocuments.zip"

               Dim candidate As String = "DatedMaterial.xps"

               Using zip As ZipFile = ZipFile.Read(zipFileToRead)

                   If zip.EntryFilenames.Contains(candidate) Then

                       zip.RemoveEntry(candidate)

                       zip.Comment = String.Format("The file '{0}' has been removed from this archive.", Candidate)

                       zip.Save

                   End If

               End Using

             </code>

             </example>

             <param name="fileName">

             The name of the file, including any directory path, to remove from the zip.

             The filename match is not case-sensitive by default; you can use the

             <c>CaseSensitiveRetrieval</c> property to change this behavior. The

             pathname can use forward-slashes or backward slashes.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Dispose">

             <summary>

               Closes the read and write streams associated

               to the <c>ZipFile</c>, if necessary.

             </summary>

             <remarks>

               The Dispose() method is generally employed implicitly, via a <c>using(..) {..}</c>

               statement. (<c>Using...End Using</c> in VB) If you do not employ a using

               statement, insure that your application calls Dispose() explicitly.  For

               example, in a Powershell application, or an application that uses the COM

               interop interface, you must call Dispose() explicitly.

             </remarks>

             <example>

             This example extracts an entry selected by name, from the Zip file to the

             Console.

             <code>

             using (ZipFile zip = ZipFile.Read(zipfile))

             {

               foreach (ZipEntry e in zip)

               {

                 if (WantThisEntry(e.FileName))

                   zip.Extract(e.FileName, Console.OpenStandardOutput());

               }

             } // Dispose() is called implicitly here.

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(zipfile)

                 Dim e As ZipEntry

                 For Each e In zip

                   If WantThisEntry(e.FileName) Then

                       zip.Extract(e.FileName, Console.OpenStandardOutput())

                   End If

                 Next

             End Using ' Dispose is implicity called here

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Dispose(System.Boolean)">

             <summary>

               Disposes any managed resources, if the flag is set, then marks the

               instance disposed.  This method is typically not called explicitly from

               application code.

             </summary>

             <remarks>

               Applications should call <see cref="M:Ionic.Zip.ZipFile.Dispose">the no-arg Dispose method</see>.

             </remarks>

             <param name="disposeManagedResources">

               indicates whether the method should dispose streams or not.

             </param>

        </member>

        <member name="F:Ionic.Zip.ZipFile.BufferSizeDefault">

            <summary>

              Default size of the buffer used for IO.

            </summary>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractAll(System.String)">

             <summary>

             Extracts all of the items in the zip archive, to the specified path in the

             filesystem.  The path can be relative or fully-qualified.

             </summary>

             <remarks>

             <para>

               This method will extract all entries in the <c>ZipFile</c> to the

               specified path.

             </para>

             <para>

               If an extraction of a file from the zip archive would overwrite an

               existing file in the filesystem, the action taken is dictated by the

               ExtractExistingFile property, which overrides any setting you may have

               made on individual ZipEntry instances.  By default, if you have not

               set that property on the <c>ZipFile</c> instance, the entry will not

               be extracted, the existing file will not be overwritten and an

               exception will be thrown. To change this, set the property, or use the

               <see cref="M:Ionic.Zip.ZipFile.ExtractAll(System.String,Ionic.Zip.ExtractExistingFileAction)"/> overload that allows you to

               specify an ExtractExistingFileAction parameter.

             </para>

             <para>

               The action to take when an extract would overwrite an existing file

               applies to all entries.  If you want to set this on a per-entry basis,

               then you must use one of the <see cref="M:Ionic.Zip.ZipEntry.Extract">ZipEntry.Extract</see> methods.

             </para>

             <para>

               This method will send verbose output messages to the <see cref="P:Ionic.Zip.ZipFile.StatusMessageTextWriter"/>, if it is set on the <c>ZipFile</c>

               instance.

             </para>

             <para>

             You may wish to take advantage of the <c>ExtractProgress</c> event.

             </para>

             <para>

               About timestamps: When extracting a file entry from a zip archive, the

               extracted file gets the last modified time of the entry as stored in

               the archive. The archive may also store extended file timestamp

               information, including last accessed and created times. If these are

               present in the <c>ZipEntry</c>, then the extracted file will also get

               these times.

             </para>

             <para>

               A Directory entry is somewhat different. It will get the times as

               described for a file entry, but, if there are file entries in the zip

               archive that, when extracted, appear in the just-created directory,

               then when those file entries are extracted, the last modified and last

               accessed times of the directory will change, as a side effect.  The

               result is that after an extraction of a directory and a number of

               files within the directory, the last modified and last accessed

               timestamps on the directory will reflect the time that the last file

               was extracted into the directory, rather than the time stored in the

               zip archive for the directory.

             </para>

             <para>

               To compensate, when extracting an archive with <c>ExtractAll</c>,

               DotNetZip will extract all the file and directory entries as described

               above, but it will then make a second pass on the directories, and

               reset the times on the directories to reflect what is stored in the

               zip archive.

             </para>

             <para>

               This compensation is performed only within the context of an

               <c>ExtractAll</c>. If you call <c>ZipEntry.Extract</c> on a directory

               entry, the timestamps on directory in the filesystem will reflect the

               times stored in the zip.  If you then call <c>ZipEntry.Extract</c> on

               a file entry, which is extracted into the directory, the timestamps on

               the directory will be updated to the current time.

             </para>

             </remarks>

             <example>

               This example extracts all the entries in a zip archive file, to the

               specified target directory.  The extraction will overwrite any

               existing files silently.

             <code>

             String TargetDirectory= "unpack";

             using(ZipFile zip= ZipFile.Read(ZipFileToExtract))

             {

                 zip.ExtractExistingFile= ExtractExistingFileAction.OverwriteSilently;

                 zip.ExtractAll(TargetDirectory);

             }

             </code>

             <code lang="VB">

             Dim TargetDirectory As String = "unpack"

             Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)

                 zip.ExtractExistingFile= ExtractExistingFileAction.OverwriteSilently

                 zip.ExtractAll(TargetDirectory)

             End Using

             </code>

             </example>

             <seealso cref="E:Ionic.Zip.ZipFile.ExtractProgress"/>

             <seealso cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/>

             <param name="path">

               The path to which the contents of the zipfile will be extracted.

               The path can be relative or fully-qualified.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractAll(System.String,Ionic.Zip.ExtractExistingFileAction)">

             <summary>

             Extracts all of the items in the zip archive, to the specified path in the

             filesystem, using the specified behavior when extraction would overwrite an

             existing file.

             </summary>

             <remarks>

             <para>

             This method will extract all entries in the <c>ZipFile</c> to the specified

             path.  For an extraction that would overwrite an existing file, the behavior

             is dictated by <paramref name="extractExistingFile"/>, which overrides any

             setting you may have made on individual ZipEntry instances.

             </para>

             <para>

             The action to take when an extract would overwrite an existing file

             applies to all entries.  If you want to set this on a per-entry basis,

             then you must use <see cref="M:Ionic.Zip.ZipEntry.Extract(System.String,Ionic.Zip.ExtractExistingFileAction)"/> or one of the similar methods.

             </para>

             <para>

             Calling this method is equivalent to setting the <see cref="P:Ionic.Zip.ZipFile.ExtractExistingFile"/> property and then calling <see cref="M:Ionic.Zip.ZipFile.ExtractAll(System.String)"/>.

             </para>

             <para>

             This method will send verbose output messages to the

             <see cref="P:Ionic.Zip.ZipFile.StatusMessageTextWriter"/>, if it is set on the <c>ZipFile</c> instance.

             </para>

             </remarks>

             <example>

             This example extracts all the entries in a zip archive file, to the

             specified target directory.  It does not overwrite any existing files.

             <code>

             String TargetDirectory= "c:\\unpack";

             using(ZipFile zip= ZipFile.Read(ZipFileToExtract))

             {

               zip.ExtractAll(TargetDirectory, ExtractExistingFileAction.DontOverwrite);

             }

             </code>

             <code lang="VB">

             Dim TargetDirectory As String = "c:\unpack"

             Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)

                 zip.ExtractAll(TargetDirectory, ExtractExistingFileAction.DontOverwrite)

             End Using

             </code>

             </example>

             <param name="path">

             The path to which the contents of the zipfile will be extracted.

             The path can be relative or fully-qualified.

             </param>

             <param name="extractExistingFile">

             The action to take if extraction would overwrite an existing file.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,Ionic.Zip.ExtractExistingFileAction)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.String)">

             <summary>

             Reads a zip file archive and returns the instance.

             </summary>

             <remarks>

             <para>

             The stream is read using the default <c>System.Text.Encoding</c>, which is the

             <c>IBM437</c> codepage.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

             Thrown if the <c>ZipFile</c> cannot be read. The implementation of this method

             relies on <c>System.IO.File.OpenRead</c>, which can throw a variety of exceptions,

             including specific exceptions if a file is not found, an unauthorized access

             exception, exceptions for poorly formatted filenames, and so on.

             </exception>

             <param name="fileName">

             The name of the zip archive to open.  This can be a fully-qualified or relative

             pathname.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)"/>.

             <returns>The instance read from the zip archive.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)">

             <summary>

               Reads a zip file archive from the named filesystem file using the

               specified options.

             </summary>

             <remarks>

             <para>

               This version of the <c>Read()</c> method allows the caller to pass

               in a <c>TextWriter</c> an <c>Encoding</c>, via an instance of the

               <c>ReadOptions</c> class.  The <c>ZipFile</c> is read in using the

               specified encoding for entries where UTF-8 encoding is not

               explicitly specified.

             </para>

             </remarks>

             <example>

             <para>

               This example shows how to read a zip file using the Big-5 Chinese

               code page (950), and extract each entry in the zip file, while

               sending status messages out to the Console.

             </para>

             <para>

               For this code to work as intended, the zipfile must have been

               created using the big5 code page (CP950). This is typical, for

               example, when using WinRar on a machine with CP950 set as the

               default code page.  In that case, the names of entries within the

               Zip archive will be stored in that code page, and reading the zip

               archive must be done using that code page.  If the application did

               not use the correct code page in ZipFile.Read(), then names of

               entries within the zip archive would not be correctly retrieved.

             </para>

             <code lang="C#">

             string zipToExtract = "MyArchive.zip";

             string extractDirectory = "extract";

             var options = new ReadOptions

             {

               StatusMessageWriter = System.Console.Out,

               Encoding = System.Text.Encoding.GetEncoding(950)

             };

             using (ZipFile zip = ZipFile.Read(zipToExtract, options))

             {

               foreach (ZipEntry e in zip)

               {

                  e.Extract(extractDirectory);

               }

             }

             </code>

             <code lang="VB">

             Dim zipToExtract as String = "MyArchive.zip"

             Dim extractDirectory as String = "extract"

             Dim options as New ReadOptions

             options.Encoding = System.Text.Encoding.GetEncoding(950)

             options.StatusMessageWriter = System.Console.Out

             Using zip As ZipFile = ZipFile.Read(zipToExtract, options)

                 Dim e As ZipEntry

                 For Each e In zip

                  e.Extract(extractDirectory)

                 Next

             End Using

             </code>

             </example>

             <example>

             <para>

               This example shows how to read a zip file using the default

               code page, to remove entries that have a modified date before a given threshold,

               sending status messages out to a <c>StringWriter</c>.

             </para>

             <code lang="C#">

             var options = new ReadOptions

             {

               StatusMessageWriter = new System.IO.StringWriter()

             };

             using (ZipFile zip =  ZipFile.Read("PackedDocuments.zip", options))

             {

               var Threshold = new DateTime(2007,7,4);

               // We cannot remove the entry from the list, within the context of

               // an enumeration of said list.

               // So we add the doomed entry to a list to be removed later.

               // pass 1: mark the entries for removal

               var MarkedEntries = new System.Collections.Generic.List&lt;ZipEntry&gt;();

               foreach (ZipEntry e in zip)

               {

                 if (e.LastModified &lt; Threshold)

                   MarkedEntries.Add(e);

               }

               // pass 2: actually remove the entry.

               foreach (ZipEntry zombie in MarkedEntries)

                  zip.RemoveEntry(zombie);

               zip.Comment = "This archive has been updated.";

               zip.Save();

             }

             // can now use contents of sw, eg store in an audit log

             </code>

             <code lang="VB">

             Dim options as New ReadOptions

             options.StatusMessageWriter = New System.IO.StringWriter

             Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip", options)

                 Dim Threshold As New DateTime(2007, 7, 4)

                 ' We cannot remove the entry from the list, within the context of

                 ' an enumeration of said list.

                 ' So we add the doomed entry to a list to be removed later.

                 ' pass 1: mark the entries for removal

                 Dim MarkedEntries As New System.Collections.Generic.List(Of ZipEntry)

                 Dim e As ZipEntry

                 For Each e In zip

                     If (e.LastModified &lt; Threshold) Then

                         MarkedEntries.Add(e)

                     End If

                 Next

                 ' pass 2: actually remove the entry.

                 Dim zombie As ZipEntry

                 For Each zombie In MarkedEntries

                     zip.RemoveEntry(zombie)

                 Next

                 zip.Comment = "This archive has been updated."

                 zip.Save

             End Using

             ' can now use contents of sw, eg store in an audit log

             </code>

             </example>

             <exception cref="T:System.Exception">

               Thrown if the zipfile cannot be read. The implementation of

               this method relies on <c>System.IO.File.OpenRead</c>, which

               can throw a variety of exceptions, including specific

               exceptions if a file is not found, an unauthorized access

               exception, exceptions for poorly formatted filenames, and so

               on.

             </exception>

             <param name="fileName">

             The name of the zip archive to open.

             This can be a fully-qualified or relative pathname.

             </param>

             <param name="options">

             The set of options to use when reading the zip file.

             </param>

             <returns>The ZipFile instance read from the zip archive.</returns>

             <seealso cref="M:Ionic.Zip.ZipFile.Read(System.IO.Stream,Ionic.Zip.ReadOptions)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.String,System.IO.TextWriter,System.Text.Encoding,System.EventHandler{Ionic.Zip.ReadProgressEventArgs})">

             <summary>

             Reads a zip file archive using the specified text encoding,  the specified

             TextWriter for status messages, and the specified ReadProgress event handler,

             and returns the instance.

             </summary>

             <param name="fileName">

             The name of the zip archive to open.

             This can be a fully-qualified or relative pathname.

             </param>

             <param name="readProgress">

             An event handler for Read operations.

             </param>

             <param name="statusMessageWriter">

             The <c>System.IO.TextWriter</c> to use for writing verbose status messages

             during operations on the zip archive.  A console application may wish to

             pass <c>System.Console.Out</c> to get messages on the Console. A graphical

             or headless application may wish to capture the messages in a different

             <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>.

             </param>

             <param name="encoding">

             The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be

             careful specifying the encoding.  If the value you use here is not the same

             as the Encoding used when the zip archive was created (possibly by a

             different archiver) you will get unexpected results and possibly exceptions.

             </param>

             <returns>The instance read from the zip archive.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.IO.Stream)">

             <summary>

               Reads a zip archive from a stream.

             </summary>

             <remarks>

             <para>

               When reading from a file, it's probably easier to just use

               <see cref="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)">ZipFile.Read(String, ReadOptions)</see>.  This

               overload is useful when when the zip archive content is

               available from an already-open stream. The stream must be

               open and readable and seekable when calling this method.  The

               stream is left open when the reading is completed.

             </para>

             <para>

               Using this overload, the stream is read using the default

               <c>System.Text.Encoding</c>, which is the <c>IBM437</c>

               codepage. If you want to specify the encoding to use when

               reading the zipfile content, see

               <see cref="M:Ionic.Zip.ZipFile.Read(System.IO.Stream,Ionic.Zip.ReadOptions)">ZipFile.Read(Stream, ReadOptions)</see>.  This

             </para>

             <para>

               Reading of zip content begins at the current position in the

               stream.  This means if you have a stream that concatenates

               regular data and zip data, if you position the open, readable

               stream at the start of the zip data, you will be able to read

               the zip archive using this constructor, or any of the ZipFile

               constructors that accept a <see cref="T:System.IO.Stream"/> as

               input. Some examples of where this might be useful: the zip

               content is concatenated at the end of a regular EXE file, as

               some self-extracting archives do.  (Note: SFX files produced

               by DotNetZip do not work this way; they can be read as normal

               ZIP files). Another example might be a stream being read from

               a database, where the zip content is embedded within an

               aggregate stream of data.

             </para>

             </remarks>

             <example>

             <para>

               This example shows how to Read zip content from a stream, and

               extract one entry into a different stream. In this example,

               the filename "NameOfEntryInArchive.doc", refers only to the

               name of the entry within the zip archive.  A file by that

               name is not created in the filesystem.  The I/O is done

               strictly with the given streams.

             </para>

             <code>

             using (ZipFile zip = ZipFile.Read(InputStream))

             {

                zip.Extract("NameOfEntryInArchive.doc", OutputStream);

             }

             </code>

             <code lang="VB">

             Using zip as ZipFile = ZipFile.Read(InputStream)

                zip.Extract("NameOfEntryInArchive.doc", OutputStream)

             End Using

             </code>

             </example>

             <param name="zipStream">the stream containing the zip data.</param>

             <returns>The ZipFile instance read from the stream</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.IO.Stream,Ionic.Zip.ReadOptions)">

             <summary>

               Reads a zip file archive from the given stream using the

               specified options.

             </summary>

             <remarks>

             <para>

               When reading from a file, it's probably easier to just use

               <see cref="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)">ZipFile.Read(String, ReadOptions)</see>.  This

               overload is useful when when the zip archive content is

               available from an already-open stream. The stream must be

               open and readable and seekable when calling this method.  The

               stream is left open when the reading is completed.

             </para>

             <para>

               Reading of zip content begins at the current position in the

               stream.  This means if you have a stream that concatenates

               regular data and zip data, if you position the open, readable

               stream at the start of the zip data, you will be able to read

               the zip archive using this constructor, or any of the ZipFile

               constructors that accept a <see cref="T:System.IO.Stream"/> as

               input. Some examples of where this might be useful: the zip

               content is concatenated at the end of a regular EXE file, as

               some self-extracting archives do.  (Note: SFX files produced

               by DotNetZip do not work this way; they can be read as normal

               ZIP files). Another example might be a stream being read from

               a database, where the zip content is embedded within an

               aggregate stream of data.

             </para>

             </remarks>

             <param name="zipStream">the stream containing the zip data.</param>

             <param name="options">

               The set of options to use when reading the zip file.

             </param>

             <exception cref="T:System.Exception">

               Thrown if the zip archive cannot be read.

             </exception>

             <returns>The ZipFile instance read from the stream.</returns>

             <seealso cref="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Read(System.IO.Stream,System.IO.TextWriter,System.Text.Encoding,System.EventHandler{Ionic.Zip.ReadProgressEventArgs})">

             <summary>

             Reads a zip archive from a stream, using the specified text Encoding, the

             specified TextWriter for status messages,

             and the specified ReadProgress event handler.

             </summary>

             <remarks>

             <para>

             Reading of zip content begins at the current position in the stream.  This

             means if you have a stream that concatenates regular data and zip data, if

             you position the open, readable stream at the start of the zip data, you

             will be able to read the zip archive using this constructor, or any of the

             ZipFile constructors that accept a <see cref="T:System.IO.Stream"/> as

             input. Some examples of where this might be useful: the zip content is

             concatenated at the end of a regular EXE file, as some self-extracting

             archives do.  (Note: SFX files produced by DotNetZip do not work this

             way). Another example might be a stream being read from a database, where

             the zip content is embedded within an aggregate stream of data.

             </para>

             </remarks>

             <param name="zipStream">the stream containing the zip data.</param>

             <param name="statusMessageWriter">

             The <c>System.IO.TextWriter</c> to which verbose status messages are written

             during operations on the <c>ZipFile</c>.  For example, in a console

             application, System.Console.Out works, and will get a message for each entry

             added to the ZipFile.  If the TextWriter is <c>null</c>, no verbose messages

             are written.

             </param>

             <param name="encoding">

             The text encoding to use when reading entries that do not have the UTF-8

             encoding bit set.  Be careful specifying the encoding.  If the value you use

             here is not the same as the Encoding used when the zip archive was created

             (possibly by a different archiver) you will get unexpected results and

             possibly exceptions.  See the <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>

             property for more information.

             </param>

             <param name="readProgress">

             An event handler for Read operations.

             </param>

             <returns>an instance of ZipFile</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.IsZipFile(System.String)">

             <summary>

             Checks the given file to see if it appears to be a valid zip file.

             </summary>

             <remarks>

             <para>

               Calling this method is equivalent to calling <see cref="M:Ionic.Zip.ZipFile.IsZipFile(System.String,System.Boolean)"/> with the testExtract parameter set to false.

             </para>

             </remarks>

             <param name="fileName">The file to check.</param>

             <returns>true if the file appears to be a zip file.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.IsZipFile(System.String,System.Boolean)">

             <summary>

             Checks a file to see if it is a valid zip file.

             </summary>

             <remarks>

             <para>

               This method opens the specified zip file, reads in the zip archive,

               verifying the ZIP metadata as it reads.

             </para>

             <para>

               If everything succeeds, then the method returns true.  If anything fails -

               for example if an incorrect signature or CRC is found, indicating a

               corrupt file, the the method returns false.  This method also returns

               false for a file that does not exist.

             </para>

             <para>

               If <paramref name="testExtract"/> is true, as part of its check, this

               method reads in the content for each entry, expands it, and checks CRCs.

               This provides an additional check beyond verifying the zip header and

               directory data.

             </para>

             <para>

               If <paramref name="testExtract"/> is true, and if any of the zip entries

               are protected with a password, this method will return false.  If you want

               to verify a <c>ZipFile</c> that has entries which are protected with a

               password, you will need to do that manually.

             </para>

             </remarks>

             <param name="fileName">The zip file to check.</param>

             <param name="testExtract">true if the caller wants to extract each entry.</param>

             <returns>true if the file contains a valid zip file.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.IsZipFile(System.IO.Stream,System.Boolean)">

             <summary>

             Checks a stream to see if it contains a valid zip archive.

             </summary>

             <remarks>

             <para>

             This method reads the zip archive contained in the specified stream, verifying

             the ZIP metadata as it reads.  If testExtract is true, this method also extracts

             each entry in the archive, dumping all the bits into <see cref="F:System.IO.Stream.Null"/>.

             </para>

             <para>

             If everything succeeds, then the method returns true.  If anything fails -

             for example if an incorrect signature or CRC is found, indicating a corrupt

             file, the the method returns false.  This method also returns false for a

             file that does not exist.

             </para>

             <para>

             If <c>testExtract</c> is true, this method reads in the content for each

             entry, expands it, and checks CRCs.  This provides an additional check

             beyond verifying the zip header data.

             </para>

             <para>

             If <c>testExtract</c> is true, and if any of the zip entries are protected

             with a password, this method will return false.  If you want to verify a

             ZipFile that has entries which are protected with a password, you will need

             to do that manually.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.IsZipFile(System.String,System.Boolean)"/>

             <param name="stream">The stream to check.</param>

             <param name="testExtract">true if the caller wants to extract each entry.</param>

             <returns>true if the stream contains a valid zip archive.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.DeleteFileWithRetry(System.String)">

             <summary>

               Delete file with retry on UnauthorizedAccessException.

             </summary>

             <remarks>

               <para>

                 When calling File.Delete() on a file that has been "recently"

                 created, the call sometimes fails with

                 UnauthorizedAccessException. This method simply retries the Delete 3

                 times with a sleep between tries.

               </para>

             </remarks>

             <param name='filename'>the name of the file to be deleted</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Save">

             <summary>

               Saves the Zip archive to a file, specified by the Name property of the

               <c>ZipFile</c>.

             </summary>

             <remarks>

             <para>

               The <c>ZipFile</c> instance is written to storage, typically a zip file

               in a filesystem, only when the caller calls <c>Save</c>.  In the typical

               case, the Save operation writes the zip content to a temporary file, and

               then renames the temporary file to the desired name. If necessary, this

               method will delete a pre-existing file before the rename.

             </para>

             <para>

               The <see cref="P:Ionic.Zip.ZipFile.Name"/> property is specified either explicitly,

               or implicitly using one of the parameterized ZipFile constructors.  For

               COM Automation clients, the <c>Name</c> property must be set explicitly,

               because COM Automation clients cannot call parameterized constructors.

             </para>

             <para>

               When using a filesystem file for the Zip output, it is possible to call

               <c>Save</c> multiple times on the <c>ZipFile</c> instance. With each

               call the zip content is re-written to the same output file.

             </para>

             <para>

               Data for entries that have been added to the <c>ZipFile</c> instance is

               written to the output when the <c>Save</c> method is called. This means

               that the input streams for those entries must be available at the time

               the application calls <c>Save</c>.  If, for example, the application

               adds entries with <c>AddEntry</c> using a dynamically-allocated

               <c>MemoryStream</c>, the memory stream must not have been disposed

               before the call to <c>Save</c>. See the <see cref="P:Ionic.Zip.ZipEntry.InputStream"/> property for more discussion of the

               availability requirements of the input stream for an entry, and an

               approach for providing just-in-time stream lifecycle management.

             </para>

             </remarks>

             <seealso cref="M:Ionic.Zip.ZipFile.AddEntry(System.String,System.IO.Stream)"/>

             <exception cref="T:Ionic.Zip.BadStateException">

               Thrown if you haven't specified a location or stream for saving the zip,

               either in the constructor or by setting the Name property, or if you try

               to save a regular zip archive to a filename with a .exe extension.

             </exception>

             <exception cref="T:System.OverflowException">

               Thrown if <see cref="P:Ionic.Zip.ZipFile.MaxOutputSegmentSize"/> is non-zero, and the number

               of segments that would be generated for the spanned zip file during the

               save operation exceeds 99.  If this happens, you need to increase the

               segment size.

             </exception>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Save(System.String)">

             <summary>

             Save the file to a new zipfile, with the given name.

             </summary>

             <remarks>

             <para>

             This method allows the application to explicitly specify the name of the zip

             file when saving. Use this when creating a new zip file, or when

             updating a zip archive.

             </para>

             <para>

             An application can also save a zip archive in several places by calling this

             method multiple times in succession, with different filenames.

             </para>

             <para>

             The <c>ZipFile</c> instance is written to storage, typically a zip file in a

             filesystem, only when the caller calls <c>Save</c>.  The Save operation writes

             the zip content to a temporary file, and then renames the temporary file

             to the desired name. If necessary, this method will delete a pre-existing file

             before the rename.

             </para>

             </remarks>

             <exception cref="T:System.ArgumentException">

             Thrown if you specify a directory for the filename.

             </exception>

             <param name="fileName">

             The name of the zip archive to save to. Existing files will

             be overwritten with great prejudice.

             </param>

             <example>

             This example shows how to create and Save a zip file.

             <code>

             using (ZipFile zip = new ZipFile())

             {

               zip.AddDirectory(@"c:\reports\January");

               zip.Save("January.zip");

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile()

               zip.AddDirectory("c:\reports\January")

               zip.Save("January.zip")

             End Using

             </code>

             </example>

             <example>

             This example shows how to update a zip file.

             <code>

             using (ZipFile zip = ZipFile.Read("ExistingArchive.zip"))

             {

               zip.AddFile("NewData.csv");

               zip.Save("UpdatedArchive.zip");

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read("ExistingArchive.zip")

               zip.AddFile("NewData.csv")

               zip.Save("UpdatedArchive.zip")

             End Using

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zip.ZipFile.Save(System.IO.Stream)">

             <summary>

               Save the zip archive to the specified stream.

             </summary>

             <remarks>

             <para>

               The <c>ZipFile</c> instance is written to storage - typically a zip file

               in a filesystem, but using this overload, the storage can be anything

               accessible via a writable stream - only when the caller calls <c>Save</c>.

             </para>

             <para>

               Use this method to save the zip content to a stream directly.  A common

               scenario is an ASP.NET application that dynamically generates a zip file

               and allows the browser to download it. The application can call

               <c>Save(Response.OutputStream)</c> to write a zipfile directly to the

               output stream, without creating a zip file on the disk on the ASP.NET

               server.

             </para>

             <para>

               Be careful when saving a file to a non-seekable stream, including

               <c>Response.OutputStream</c>. When DotNetZip writes to a non-seekable

               stream, the zip archive is formatted in such a way that may not be

               compatible with all zip tools on all platforms.  It's a perfectly legal

               and compliant zip file, but some people have reported problems opening

               files produced this way using the Mac OS archive utility.

             </para>

             </remarks>

             <example>

               This example saves the zipfile content into a MemoryStream, and

               then gets the array of bytes from that MemoryStream.

             <code lang="C#">

             using (var zip = new Ionic.Zip.ZipFile())

             {

                 zip.CompressionLevel= Ionic.Zlib.CompressionLevel.BestCompression;

                 zip.Password = "VerySecret.";

                 zip.Encryption = EncryptionAlgorithm.WinZipAes128;

                 zip.AddFile(sourceFileName);

                 MemoryStream output = new MemoryStream();

                 zip.Save(output);

                 byte[] zipbytes = output.ToArray();

             }

             </code>

             </example>

             <example>

             <para>

               This example shows a pitfall you should avoid. DO NOT read

               from a stream, then try to save to the same stream.  DO

               NOT DO THIS:

             </para>

             <code lang="C#">

             using (var fs = new FileSteeam(filename, FileMode.Open))

             {

               using (var zip = Ionic.Zip.ZipFile.Read(inputStream))

               {

                 zip.AddEntry("Name1.txt", "this is the content");

                 zip.Save(inputStream);  // NO NO NO!!

               }

             }

             </code>

             <para>

               Better like this:

             </para>

             <code lang="C#">

             using (var zip = Ionic.Zip.ZipFile.Read(filename))

             {

                 zip.AddEntry("Name1.txt", "this is the content");

                 zip.Save();  // YES!

             }

             </code>

             </example>

             <param name="outputStream">

               The <c>System.IO.Stream</c> to write to. It must be

               writable. If you created the ZipFile instanct by calling

               ZipFile.Read(), this stream must not be the same stream

               you passed to ZipFile.Read().

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)">

             <summary>

               Adds to the ZipFile a set of files from the current working directory on

               disk, that conform to the specified criteria.

             </summary>

             <remarks>

             <para>

               This method selects files from the the current working directory matching

               the specified criteria, and adds them to the ZipFile.

             </para>

             <para>

               Specify the criteria in statements of 3 elements: a noun, an operator, and

               a value.  Consider the string "name != *.doc" .  The noun is "name".  The

               operator is "!=", implying "Not Equal".  The value is "*.doc".  That

               criterion, in English, says "all files with a name that does not end in

               the .doc extension."

             </para>

             <para>

               Supported nouns include "name" (or "filename") for the filename; "atime",

               "mtime", and "ctime" for last access time, last modfied time, and created

               time of the file, respectively; "attributes" (or "attrs") for the file

               attributes; "size" (or "length") for the file length (uncompressed), and

               "type" for the type of object, either a file or a directory.  The

               "attributes", "name" and "type" nouns both support = and != as operators.

               The "size", "atime", "mtime", and "ctime" nouns support = and !=, and

               &gt;, &gt;=, &lt;, &lt;= as well. The times are taken to be expressed in

               local time.

             </para>

             <para>

             Specify values for the file attributes as a string with one or more of the

             characters H,R,S,A,I,L in any order, implying file attributes of Hidden,

             ReadOnly, System, Archive, NotContextIndexed, and ReparsePoint (symbolic

             link) respectively.

             </para>

             <para>

             To specify a time, use YYYY-MM-DD-HH:mm:ss or YYYY/MM/DD-HH:mm:ss as the

             format.  If you omit the HH:mm:ss portion, it is assumed to be 00:00:00

             (midnight).

             </para>

             <para>

             The value for a size criterion is expressed in integer quantities of bytes,

             kilobytes (use k or kb after the number), megabytes (m or mb), or gigabytes

             (g or gb).

             </para>

             <para>

             The value for a name is a pattern to match against the filename, potentially

             including wildcards.  The pattern follows CMD.exe glob rules: * implies one

             or more of any character, while ?  implies one character.  If the name

             pattern contains any slashes, it is matched to the entire filename,

             including the path; otherwise, it is matched against only the filename

             without the path.  This means a pattern of "*\*.*" matches all files one

             directory level deep, while a pattern of "*.*" matches all files in all

             directories.

             </para>

             <para>

             To specify a name pattern that includes spaces, use single quotes around the

             pattern.  A pattern of "'* *.*'" will match all files that have spaces in

             the filename.  The full criteria string for that would be "name = '* *.*'" .

             </para>

             <para>

             The value for a type criterion is either F (implying a file) or D (implying

             a directory).

             </para>

             <para>

             Some examples:

             </para>

             <list type="table">

               <listheader>

                 <term>criteria</term>

                 <description>Files retrieved</description>

               </listheader>

               <item>

                 <term>name != *.xls </term>

                 <description>any file with an extension that is not .xls

                 </description>

               </item>

               <item>

                 <term>name = *.mp3 </term>

                 <description>any file with a .mp3 extension.

                 </description>

               </item>

               <item>

                 <term>*.mp3</term>

                 <description>(same as above) any file with a .mp3 extension.

                 </description>

               </item>

               <item>

                 <term>attributes = A </term>

                 <description>all files whose attributes include the Archive bit.

                 </description>

               </item>

               <item>

                 <term>attributes != H </term>

                 <description>all files whose attributes do not include the Hidden bit.

                 </description>

               </item>

               <item>

                 <term>mtime > 2009-01-01</term>

                 <description>all files with a last modified time after January 1st, 2009.

                 </description>

               </item>

               <item>

                 <term>size > 2gb</term>

                 <description>all files whose uncompressed size is greater than 2gb.

                 </description>

               </item>

               <item>

                 <term>type = D</term>

                 <description>all directories in the filesystem. </description>

               </item>

             </list>

             <para>

             You can combine criteria with the conjunctions AND or OR. Using a string

             like "name = *.txt AND size &gt;= 100k" for the selectionCriteria retrieves

             entries whose names end in .txt, and whose uncompressed size is greater than

             or equal to 100 kilobytes.

             </para>

             <para>

             For more complex combinations of criteria, you can use parenthesis to group

             clauses in the boolean logic.  Without parenthesis, the precedence of the

             criterion atoms is determined by order of appearance.  Unlike the C#

             language, the AND conjunction does not take precendence over the logical OR.

             This is important only in strings that contain 3 or more criterion atoms.

             In other words, "name = *.txt and size &gt; 1000 or attributes = H" implies

             "((name = *.txt AND size &gt; 1000) OR attributes = H)" while "attributes =

             H OR name = *.txt and size &gt; 1000" evaluates to "((attributes = H OR name

             = *.txt) AND size &gt; 1000)".  When in doubt, use parenthesis.

             </para>

             <para>

             Using time properties requires some extra care. If you want to retrieve all

             entries that were last updated on 2009 February 14, specify a time range

             like so:"mtime &gt;= 2009-02-14 AND mtime &lt; 2009-02-15".  Read this to

             say: all files updated after 12:00am on February 14th, until 12:00am on

             February 15th.  You can use the same bracketing approach to specify any time

             period - a year, a month, a week, and so on.

             </para>

             <para>

             The syntax allows one special case: if you provide a string with no spaces, it is

             treated as a pattern to match for the filename.  Therefore a string like "*.xls"

             will be equivalent to specifying "name = *.xls".

             </para>

             <para>

             There is no logic in this method that insures that the file inclusion

             criteria are internally consistent.  For example, it's possible to specify

             criteria that says the file must have a size of less than 100 bytes, as well

             as a size that is greater than 1000 bytes. Obviously no file will ever

             satisfy such criteria, but this method does not detect such logical

             inconsistencies. The caller is responsible for insuring the criteria are

             sensible.

             </para>

             <para>

               Using this method, the file selection does not recurse into

               subdirectories, and the full path of the selected files is included in the

               entries added into the zip archive.  If you don't like these behaviors,

               see the other overloads of this method.

             </para>

             </remarks>

             <example>

             This example zips up all *.csv files in the current working directory.

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 // To just match on filename wildcards,

                 // use the shorthand form of the selectionCriteria string.

                 zip.AddSelectedFiles("*.csv");

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile()

                 zip.AddSelectedFiles("*.csv")

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <param name="selectionCriteria">The criteria for file selection</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.Boolean)">

             <summary>

               Adds to the ZipFile a set of files from the disk that conform to the

               specified criteria, optionally recursing into subdirectories.

             </summary>

             <remarks>

             <para>

               This method selects files from the the current working directory matching

               the specified criteria, and adds them to the ZipFile.  If

               <c>recurseDirectories</c> is true, files are also selected from

               subdirectories, and the directory structure in the filesystem is

               reproduced in the zip archive, rooted at the current working directory.

             </para>

             <para>

               Using this method, the full path of the selected files is included in the

               entries added into the zip archive.  If you don't want this behavior, use

               one of the overloads of this method that allows the specification of a

               <c>directoryInArchive</c>.

             </para>

             <para>

               For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

               This example zips up all *.xml files in the current working directory, or any

               subdirectory, that are larger than 1mb.

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 // Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.xml  and  size &gt; 1024kb", true);

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile()

                 ' Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.xml  and  size &gt; 1024kb", true)

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <param name="selectionCriteria">The criteria for file selection</param>

             <param name="recurseDirectories">

               If true, the file selection will recurse into subdirectories.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String)">

             <summary>

               Adds to the ZipFile a set of files from a specified directory in the

               filesystem, that conform to the specified criteria.

             </summary>

             <remarks>

             <para>

               This method selects files that conform to the specified criteria, from the

               the specified directory on disk, and adds them to the ZipFile.  The search

               does not recurse into subdirectores.

             </para>

             <para>

               Using this method, the full filesystem path of the files on disk is

               reproduced on the entries added to the zip file.  If you don't want this

               behavior, use one of the other overloads of this method.

             </para>

             <para>

               For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

               This example zips up all *.xml files larger than 1mb in the directory

               given by "d:\rawdata".

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 // Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.xml  and  size &gt; 1024kb", "d:\\rawdata");

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile()

                 ' Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.xml  and  size &gt; 1024kb", "d:\rawdata)

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <param name="selectionCriteria">The criteria for file selection</param>

             <param name="directoryOnDisk">

             The name of the directory on the disk from which to select files.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String,System.Boolean)">

             <summary>

               Adds to the ZipFile a set of files from the specified directory on disk,

               that conform to the specified criteria.

             </summary>

             <remarks>

             <para>

               This method selects files from the the specified disk directory matching

               the specified selection criteria, and adds them to the ZipFile.  If

               <c>recurseDirectories</c> is true, files are also selected from

               subdirectories.

             </para>

             <para>

               The full directory structure in the filesystem is reproduced on the

               entries added to the zip archive.  If you don't want this behavior, use

               one of the overloads of this method that allows the specification of a

               <c>directoryInArchive</c>.

             </para>

             <para>

               For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

               This example zips up all *.csv files in the "files" directory, or any

               subdirectory, that have been saved since 2009 February 14th.

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 // Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.csv  and  mtime &gt; 2009-02-14", "files", true);

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile()

                 ' Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.csv  and  mtime &gt; 2009-02-14", "files", true)

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <example>

               This example zips up all files in the current working

               directory, and all its child directories, except those in

               the <c>excludethis</c> subdirectory.

             <code lang="VB">

             Using Zip As ZipFile = New ZipFile(zipfile)

               Zip.AddSelectedFfiles("name != 'excludethis\*.*'", datapath, True)

               Zip.Save()

             End Using

             </code>

             </example>

             <param name="selectionCriteria">The criteria for file selection</param>

             <param name="directoryOnDisk">

               The filesystem path from which to select files.

             </param>

             <param name="recurseDirectories">

               If true, the file selection will recurse into subdirectories.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String,System.String)">

             <summary>

               Adds to the ZipFile a selection of files from the specified directory on

               disk, that conform to the specified criteria, and using a specified root

               path for entries added to the zip archive.

             </summary>

             <remarks>

             <para>

               This method selects files from the specified disk directory matching the

               specified selection criteria, and adds those files to the ZipFile, using

               the specified directory path in the archive.  The search does not recurse

               into subdirectories.  For details on the syntax for the selectionCriteria

               parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

               This example zips up all *.psd files in the "photos" directory that have

               been saved since 2009 February 14th, and puts them all in a zip file,

               using the directory name of "content" in the zip archive itself. When the

               zip archive is unzipped, the folder containing the .psd files will be

               named "content".

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 // Use a compound expression in the selectionCriteria string.

                 zip.AddSelectedFiles("name = *.psd  and  mtime &gt; 2009-02-14", "photos", "content");

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile

                 zip.AddSelectedFiles("name = *.psd  and  mtime &gt; 2009-02-14", "photos", "content")

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <param name="selectionCriteria">

               The criteria for selection of files to add to the <c>ZipFile</c>.

             </param>

             <param name="directoryOnDisk">

               The path to the directory in the filesystem from which to select files.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to in place of the

               <c>directoryOnDisk</c>.  This path may, or may not, correspond to a real

               directory in the current filesystem.  If the files within the zip are

               later extracted, this is the path used for the extracted file.  Passing

               null (nothing in VB) will use the path on the file name, if any; in other

               words it would use <c>directoryOnDisk</c>, plus any subdirectory.  Passing

               the empty string ("") will insert the item at the root path within the

               archive.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String,System.String,System.Boolean)">

             <summary>

               Adds to the ZipFile a selection of files from the specified directory on

               disk, that conform to the specified criteria, optionally recursing through

               subdirectories, and using a specified root path for entries added to the

               zip archive.

             </summary>

             <remarks>

               This method selects files from the specified disk directory that match the

               specified selection criteria, and adds those files to the ZipFile, using

               the specified directory path in the archive. If <c>recurseDirectories</c>

               is true, files are also selected from subdirectories, and the directory

               structure in the filesystem is reproduced in the zip archive, rooted at

               the directory specified by <c>directoryOnDisk</c>.  For details on the

               syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </remarks>

             <example>

               This example zips up all files that are NOT *.pst files, in the current

               working directory and any subdirectories.

             <code>

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddSelectedFiles("name != *.pst", SourceDirectory, "backup", true);

                 zip.Save(PathToZipArchive);

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = New ZipFile

                 zip.AddSelectedFiles("name != *.pst", SourceDirectory, "backup", true)

                 zip.Save(PathToZipArchive)

             End Using

             </code>

             </example>

             <param name="selectionCriteria">

               The criteria for selection of files to add to the <c>ZipFile</c>.

             </param>

             <param name="directoryOnDisk">

               The path to the directory in the filesystem from which to select files.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to in place of the

               <c>directoryOnDisk</c>.  This path may, or may not, correspond to a real

               directory in the current filesystem.  If the files within the zip are

               later extracted, this is the path used for the extracted file.  Passing

               null (nothing in VB) will use the path on the file name, if any; in other

               words it would use <c>directoryOnDisk</c>, plus any subdirectory.  Passing

               the empty string ("") will insert the item at the root path within the

               archive.

             </param>

             <param name="recurseDirectories">

               If true, the method also scans subdirectories for files matching the

               criteria.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.UpdateSelectedFiles(System.String,System.String,System.String,System.Boolean)">

             <summary>

               Updates the ZipFile with a selection of files from the disk that conform

               to the specified criteria.

             </summary>

             <remarks>

               This method selects files from the specified disk directory that match the

               specified selection criteria, and Updates the <c>ZipFile</c> with those

               files, using the specified directory path in the archive. If

               <c>recurseDirectories</c> is true, files are also selected from

               subdirectories, and the directory structure in the filesystem is

               reproduced in the zip archive, rooted at the directory specified by

               <c>directoryOnDisk</c>.  For details on the syntax for the

               selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </remarks>

             <param name="selectionCriteria">

               The criteria for selection of files to add to the <c>ZipFile</c>.

             </param>

             <param name="directoryOnDisk">

               The path to the directory in the filesystem from which to select files.

             </param>

             <param name="directoryPathInArchive">

               Specifies a directory path to use to in place of the

               <c>directoryOnDisk</c>. This path may, or may not, correspond to a

               real directory in the current filesystem. If the files within the zip

               are later extracted, this is the path used for the extracted file.

               Passing null (nothing in VB) will use the path on the file name, if

               any; in other words it would use <c>directoryOnDisk</c>, plus any

               subdirectory.  Passing the empty string ("") will insert the item at

               the root path within the archive.

             </param>

             <param name="recurseDirectories">

               If true, the method also scans subdirectories for files matching the criteria.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String,System.String,System.String,System.Boolean)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.SelectEntries(System.String)">

             <summary>

             Retrieve entries from the zipfile by specified criteria.

             </summary>

             <remarks>

             <para>

             This method allows callers to retrieve the collection of entries from the zipfile

             that fit the specified criteria.  The criteria are described in a string format, and

             can include patterns for the filename; constraints on the size of the entry;

             constraints on the last modified, created, or last accessed time for the file

             described by the entry; or the attributes of the entry.

             </para>

             <para>

             For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             <para>

             This method is intended for use with a ZipFile that has been read from storage.

             When creating a new ZipFile, this method will work only after the ZipArchive has

             been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip

             archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been

             saved will deliver undefined results.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

             Thrown if selectionCriteria has an invalid syntax.

             </exception>

             <example>

             This example selects all the PhotoShop files from within an archive, and extracts them

             to the current working directory.

             <code>

             using (ZipFile zip1 = ZipFile.Read(ZipFileName))

             {

                 var PhotoShopFiles = zip1.SelectEntries("*.psd");

                 foreach (ZipEntry psd in PhotoShopFiles)

                 {

                     psd.Extract();

                 }

             }

             </code>

             <code lang="VB">

             Using zip1 As ZipFile = ZipFile.Read(ZipFileName)

                 Dim PhotoShopFiles as ICollection(Of ZipEntry)

                 PhotoShopFiles = zip1.SelectEntries("*.psd")

                 Dim psd As ZipEntry

                 For Each psd In PhotoShopFiles

                     psd.Extract

                 Next

             End Using

             </code>

             </example>

             <param name="selectionCriteria">the string that specifies which entries to select</param>

             <returns>a collection of ZipEntry objects that conform to the inclusion spec</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.SelectEntries(System.String,System.String)">

             <summary>

             Retrieve entries from the zipfile by specified criteria.

             </summary>

             <remarks>

             <para>

             This method allows callers to retrieve the collection of entries from the zipfile

             that fit the specified criteria.  The criteria are described in a string format, and

             can include patterns for the filename; constraints on the size of the entry;

             constraints on the last modified, created, or last accessed time for the file

             described by the entry; or the attributes of the entry.

             </para>

             <para>

             For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             <para>

             This method is intended for use with a ZipFile that has been read from storage.

             When creating a new ZipFile, this method will work only after the ZipArchive has

             been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip

             archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been

             saved will deliver undefined results.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

             Thrown if selectionCriteria has an invalid syntax.

             </exception>

             <example>

             <code>

             using (ZipFile zip1 = ZipFile.Read(ZipFileName))

             {

                 var UpdatedPhotoShopFiles = zip1.SelectEntries("*.psd", "UpdatedFiles");

                 foreach (ZipEntry e in UpdatedPhotoShopFiles)

                 {

                     // prompt for extract here

                     if (WantExtract(e.FileName))

                         e.Extract();

                 }

             }

             </code>

             <code lang="VB">

             Using zip1 As ZipFile = ZipFile.Read(ZipFileName)

                 Dim UpdatedPhotoShopFiles As ICollection(Of ZipEntry) = zip1.SelectEntries("*.psd", "UpdatedFiles")

                 Dim e As ZipEntry

                 For Each e In UpdatedPhotoShopFiles

                     ' prompt for extract here

                     If Me.WantExtract(e.FileName) Then

                         e.Extract

                     End If

                 Next

             End Using

             </code>

             </example>

             <param name="selectionCriteria">the string that specifies which entries to select</param>

             <param name="directoryPathInArchive">

             the directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <returns>a collection of ZipEntry objects that conform to the inclusion spec</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveSelectedEntries(System.String)">

             <summary>

             Remove entries from the zipfile by specified criteria.

             </summary>

             <remarks>

             <para>

             This method allows callers to remove the collection of entries from the zipfile

             that fit the specified criteria.  The criteria are described in a string format, and

             can include patterns for the filename; constraints on the size of the entry;

             constraints on the last modified, created, or last accessed time for the file

             described by the entry; or the attributes of the entry.

             </para>

             <para>

             For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             <para>

             This method is intended for use with a ZipFile that has been read from storage.

             When creating a new ZipFile, this method will work only after the ZipArchive has

             been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip

             archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been

             saved will deliver undefined results.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

             Thrown if selectionCriteria has an invalid syntax.

             </exception>

             <example>

             This example removes all entries in a zip file that were modified prior to January 1st, 2008.

             <code>

             using (ZipFile zip1 = ZipFile.Read(ZipFileName))

             {

                 // remove all entries from prior to Jan 1, 2008

                 zip1.RemoveEntries("mtime &lt; 2008-01-01");

                 // don't forget to save the archive!

                 zip1.Save();

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(ZipFileName)

                 ' remove all entries from prior to Jan 1, 2008

                 zip1.RemoveEntries("mtime &lt; 2008-01-01")

                 ' do not forget to save the archive!

                 zip1.Save

             End Using

             </code>

             </example>

             <param name="selectionCriteria">the string that specifies which entries to select</param>

             <returns>the number of entries removed</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.RemoveSelectedEntries(System.String,System.String)">

             <summary>

             Remove entries from the zipfile by specified criteria, and within the specified

             path in the archive.

             </summary>

             <remarks>

             <para>

             This method allows callers to remove the collection of entries from the zipfile

             that fit the specified criteria.  The criteria are described in a string format, and

             can include patterns for the filename; constraints on the size of the entry;

             constraints on the last modified, created, or last accessed time for the file

             described by the entry; or the attributes of the entry.

             </para>

             <para>

             For details on the syntax for the selectionCriteria parameter, see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             <para>

             This method is intended for use with a ZipFile that has been read from storage.

             When creating a new ZipFile, this method will work only after the ZipArchive has

             been Saved to the disk (the ZipFile class subsequently and implicitly reads the Zip

             archive from storage.)  Calling SelectEntries on a ZipFile that has not yet been

             saved will deliver undefined results.

             </para>

             </remarks>

             <exception cref="T:System.Exception">

             Thrown if selectionCriteria has an invalid syntax.

             </exception>

             <example>

             <code>

             using (ZipFile zip1 = ZipFile.Read(ZipFileName))

             {

                 // remove all entries from prior to Jan 1, 2008

                 zip1.RemoveEntries("mtime &lt; 2008-01-01", "documents");

                 // a call to ZipFile.Save will make the modifications permanent

                 zip1.Save();

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(ZipFileName)

                 ' remove all entries from prior to Jan 1, 2008

                 zip1.RemoveEntries("mtime &lt; 2008-01-01", "documents")

                 ' a call to ZipFile.Save will make the modifications permanent

                 zip1.Save

             End Using

             </code>

             </example>

             <param name="selectionCriteria">the string that specifies which entries to select</param>

             <param name="directoryPathInArchive">

             the directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <returns>the number of entries removed</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String)">

             <summary>

             Selects and Extracts a set of Entries from the ZipFile.

             </summary>

             <remarks>

             <para>

             The entries are extracted into the current working directory.

             </para>

             <para>

             If any of the files to be extracted already exist, then the action taken is as

             specified in the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/> property on the

             corresponding ZipEntry instance.  By default, the action taken in this case is to

             throw an exception.

             </para>

             <para>

             For information on the syntax of the selectionCriteria string,

             see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

             This example shows how extract all XML files modified after 15 January 2009.

             <code>

             using (ZipFile zip = ZipFile.Read(zipArchiveName))

             {

               zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15");

             }

             </code>

             </example>

             <param name="selectionCriteria">the selection criteria for entries to extract.</param>

             <seealso cref="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,Ionic.Zip.ExtractExistingFileAction)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,Ionic.Zip.ExtractExistingFileAction)">

             <summary>

             Selects and Extracts a set of Entries from the ZipFile.

             </summary>

             <remarks>

             <para>

             The entries are extracted into the current working directory. When extraction would would

             overwrite an existing filesystem file, the action taken is as specified in the

             <paramref name="extractExistingFile"/> parameter.

             </para>

             <para>

             For information on the syntax of the string describing the entry selection criteria,

             see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

             This example shows how extract all XML files modified after 15 January 2009,

             overwriting any existing files.

             <code>

             using (ZipFile zip = ZipFile.Read(zipArchiveName))

             {

               zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15",

                                          ExtractExistingFileAction.OverwriteSilently);

             }

             </code>

             </example>

             <param name="selectionCriteria">the selection criteria for entries to extract.</param>

             <param name="extractExistingFile">

             The action to take if extraction would overwrite an existing file.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,System.String)">

             <summary>

             Selects and Extracts a set of Entries from the ZipFile.

             </summary>

             <remarks>

             <para>

             The entries are selected from the specified directory within the archive, and then

             extracted into the current working directory.

             </para>

             <para>

             If any of the files to be extracted already exist, then the action taken is as

             specified in the <see cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/> property on the

             corresponding ZipEntry instance.  By default, the action taken in this case is to

             throw an exception.

             </para>

             <para>

             For information on the syntax of the string describing the entry selection criteria,

             see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

             This example shows how extract all XML files modified after 15 January 2009,

             and writes them to the "unpack" directory.

             <code>

             using (ZipFile zip = ZipFile.Read(zipArchiveName))

             {

               zip.ExtractSelectedEntries("name = *.xml  and  mtime &gt; 2009-01-15","unpack");

             }

             </code>

             </example>

             <param name="selectionCriteria">the selection criteria for entries to extract.</param>

             <param name="directoryPathInArchive">

             the directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <seealso cref="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,System.String,System.String,Ionic.Zip.ExtractExistingFileAction)"/>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,System.String,System.String)">

             <summary>

             Selects and Extracts a set of Entries from the ZipFile.

             </summary>

             <remarks>

             <para>

             The entries are extracted into the specified directory. If any of the files to be

             extracted already exist, an exception will be thrown.

             </para>

             <para>

             For information on the syntax of the string describing the entry selection criteria,

             see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <param name="selectionCriteria">the selection criteria for entries to extract.</param>

             <param name="directoryInArchive">

             the directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <param name="extractDirectory">

             the directory on the disk into which to extract. It will be created

             if it does not exist.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.ExtractSelectedEntries(System.String,System.String,System.String,Ionic.Zip.ExtractExistingFileAction)">

             <summary>

             Selects and Extracts a set of Entries from the ZipFile.

             </summary>

             <remarks>

             <para>

             The entries are extracted into the specified directory. When extraction would would

             overwrite an existing filesystem file, the action taken is as specified in the

             <paramref name="extractExistingFile"/> parameter.

             </para>

             <para>

             For information on the syntax of the string describing the entry selection criteria,

             see <see cref="M:Ionic.Zip.ZipFile.AddSelectedFiles(System.String)"/>.

             </para>

             </remarks>

             <example>

             This example shows how extract all files  with an XML extension or with  a size larger than 100,000 bytes,

             and puts them in the unpack directory.  For any files that already exist in

             that destination directory, they will not be overwritten.

             <code>

             using (ZipFile zip = ZipFile.Read(zipArchiveName))

             {

               zip.ExtractSelectedEntries("name = *.xml  or  size &gt; 100000",

                                          null,

                                          "unpack",

                                          ExtractExistingFileAction.DontOverwrite);

             }

             </code>

             </example>

             <param name="selectionCriteria">the selection criteria for entries to extract.</param>

             <param name="extractDirectory">

             The directory on the disk into which to extract. It will be created if it does not exist.

             </param>

             <param name="directoryPathInArchive">

             The directory in the archive from which to select entries. If null, then

             all directories in the archive are used.

             </param>

             <param name="extractExistingFile">

             The action to take if extraction would overwrite an existing file.

             </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.SaveSelfExtractor(System.String,Ionic.Zip.SelfExtractorFlavor)">

             <summary>

             Saves the ZipFile instance to a self-extracting zip archive.

             </summary>

             <remarks>

             <para>

             The generated exe image will execute on any machine that has the .NET

             Framework 2.0 installed on it.  The generated exe image is also a

             valid ZIP file, readable with DotNetZip or another Zip library or tool

             such as WinZip.

             </para>

             <para>

             There are two "flavors" of self-extracting archive.  The

             <c>WinFormsApplication</c> version will pop up a GUI and allow the

             user to select a target directory into which to extract. There's also

             a checkbox allowing the user to specify to overwrite existing files,

             and another checkbox to allow the user to request that Explorer be

             opened to see the extracted files after extraction.  The other flavor

             is <c>ConsoleApplication</c>.  A self-extractor generated with that

             flavor setting will run from the command line. It accepts command-line

             options to set the overwrite behavior, and to specify the target

             extraction directory.

             </para>

             <para>

             There are a few temporary files created during the saving to a

             self-extracting zip.  These files are created in the directory pointed

             to by <see cref="P:Ionic.Zip.ZipFile.TempFileFolder"/>, which defaults to <see cref="M:System.IO.Path.GetTempPath"/>.  These temporary files are

             removed upon successful completion of this method.

             </para>

             <para>

             When a user runs the WinForms SFX, the user's personal directory (<see cref="F:System.Environment.SpecialFolder.Personal">Environment.SpecialFolder.Personal</see>)

             will be used as the default extract location.  If you want to set the

             default extract location, you should use the other overload of

             <c>SaveSelfExtractor()</c>/ The user who runs the SFX will have the

             opportunity to change the extract directory before extracting. When

             the user runs the Command-Line SFX, the user must explicitly specify

             the directory to which to extract.  The .NET Framework 2.0 is required

             on the computer when the self-extracting archive is run.

             </para>

             <para>

             NB: This method is not available in the version of DotNetZip build for

             the .NET Compact Framework, nor in the "Reduced" DotNetZip library.

             </para>

             </remarks>

             <example>

             <code>

             string DirectoryPath = "c:\\Documents\\Project7";

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath));

                 zip.Comment = "This will be embedded into a self-extracting console-based exe";

                 zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication);

             }

             </code>

             <code lang="VB">

             Dim DirectoryPath As String = "c:\Documents\Project7"

             Using zip As New ZipFile()

                 zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath))

                 zip.Comment = "This will be embedded into a self-extracting console-based exe"

                 zip.SaveSelfExtractor("archive.exe", SelfExtractorFlavor.ConsoleApplication)

             End Using

             </code>

             </example>

             <param name="exeToGenerate">

               a pathname, possibly fully qualified, to be created. Typically it

               will end in an .exe extension.</param>

             <param name="flavor">

               Indicates whether a Winforms or Console self-extractor is

               desired. </param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.SaveSelfExtractor(System.String,Ionic.Zip.SelfExtractorSaveOptions)">

             <summary>

               Saves the ZipFile instance to a self-extracting zip archive, using

               the specified save options.

             </summary>

             <remarks>

             <para>

               This method saves a self extracting archive, using the specified save

               options. These options include the flavor of the SFX, the default extract

               directory, the icon file, and so on.  See the documentation

               for <see cref="M:Ionic.Zip.ZipFile.SaveSelfExtractor(System.String,Ionic.Zip.SelfExtractorFlavor)"/> for more

               details.

             </para>

             <para>

               The user who runs the SFX will have the opportunity to change the extract

               directory before extracting. If at the time of extraction, the specified

               directory does not exist, the SFX will create the directory before

               extracting the files.

             </para>

             </remarks>

             <example>

               This example saves a WinForms-based self-extracting archive EXE that

               will use c:\ExtractHere as the default extract location. The C# code

               shows syntax for .NET 3.0, which uses an object initializer for

               the SelfExtractorOptions object.

             <code>

             string DirectoryPath = "c:\\Documents\\Project7";

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath));

                 zip.Comment = "This will be embedded into a self-extracting WinForms-based exe";

                 var options = new SelfExtractorOptions

                 {

                   Flavor = SelfExtractorFlavor.WinFormsApplication,

                   DefaultExtractDirectory = "%USERPROFILE%\\ExtractHere",

                   PostExtractCommandLine = ExeToRunAfterExtract,

                   SfxExeWindowTitle = "My Custom Window Title",

                   RemoveUnpackedFilesAfterExecute = true

                 };

                 zip.SaveSelfExtractor("archive.exe", options);

             }

             </code>

             <code lang="VB">

             Dim DirectoryPath As String = "c:\Documents\Project7"

             Using zip As New ZipFile()

                 zip.AddDirectory(DirectoryPath, System.IO.Path.GetFileName(DirectoryPath))

                 zip.Comment = "This will be embedded into a self-extracting console-based exe"

                 Dim options As New SelfExtractorOptions()

                 options.Flavor = SelfExtractorFlavor.WinFormsApplication

                 options.DefaultExtractDirectory = "%USERPROFILE%\\ExtractHere"

                 options.PostExtractCommandLine = ExeToRunAfterExtract

                 options.SfxExeWindowTitle = "My Custom Window Title"

                 options.RemoveUnpackedFilesAfterExecute = True

                 zip.SaveSelfExtractor("archive.exe", options)

             End Using

             </code>

             </example>

             <param name="exeToGenerate">The name of the EXE to generate.</param>

             <param name="options">provides the options for creating the

             Self-extracting archive.</param>

        </member>

        <member name="M:Ionic.Zip.ZipFile.GetEnumerator">

             <summary>

             Generic IEnumerator support, for use of a ZipFile in an enumeration.

             </summary>

             <remarks>

             You probably do not want to call <c>GetEnumerator</c> explicitly. Instead

             it is implicitly called when you use a <see langword="foreach"/> loop in C#, or a

             <c>For Each</c> loop in VB.NET.

             </remarks>

             <example>

             This example reads a zipfile of a given name, then enumerates the

             entries in that zip file, and displays the information about each

             entry on the Console.

             <code>

             using (ZipFile zip = ZipFile.Read(zipfile))

             {

               bool header = true;

               foreach (ZipEntry e in zip)

               {

                 if (header)

                 {

                    System.Console.WriteLine("Zipfile: {0}", zip.Name);

                    System.Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded);

                    System.Console.WriteLine("BitField: 0x{0:X2}", e.BitField);

                    System.Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod);

                    System.Console.WriteLine("\n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",

                                 "Filename", "Modified", "Size", "Ratio", "Packed");

                    System.Console.WriteLine(new System.String('-', 72));

                    header = false;

                 }

                 System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}",

                             e.FileName,

                             e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),

                             e.UncompressedSize,

                             e.CompressionRatio,

                             e.CompressedSize);

                 e.Extract();

               }

             }

             </code>

             <code lang="VB">

               Dim ZipFileToExtract As String = "c:\foo.zip"

               Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)

                   Dim header As Boolean = True

                   Dim e As ZipEntry

                   For Each e In zip

                       If header Then

                           Console.WriteLine("Zipfile: {0}", zip.Name)

                           Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded)

                           Console.WriteLine("BitField: 0x{0:X2}", e.BitField)

                           Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod)

                           Console.WriteLine(ChrW(10) &amp; "{1,-22} {2,-6} {3,4}   {4,-8}  {0}", _

                             "Filename", "Modified", "Size", "Ratio", "Packed" )

                           Console.WriteLine(New String("-"c, 72))

                           header = False

                       End If

                       Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}", _

                         e.FileName, _

                         e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"), _

                         e.UncompressedSize, _

                         e.CompressionRatio, _

                         e.CompressedSize )

                       e.Extract

                   Next

               End Using

             </code>

             </example>

             <returns>A generic enumerator suitable for use  within a foreach loop.</returns>

        </member>

        <member name="M:Ionic.Zip.ZipFile.GetNewEnum">

             <summary>

             An IEnumerator, for use of a ZipFile in a foreach construct.

             </summary>

             <remarks>

             This method is included for COM support.  An application generally does not call

             this method directly.  It is called implicitly by COM clients when enumerating

             the entries in the ZipFile instance.  In VBScript, this is done with a <c>For Each</c>

             statement.  In Javascript, this is done with <c>new Enumerator(zipfile)</c>.

             </remarks>

             <returns>

             The IEnumerator over the entries in the ZipFile.

             </returns>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Info">

             <summary>

               Provides a human-readable string with information about the ZipFile.

             </summary>

             <remarks>

               <para>

                 The information string contains 10 lines or so, about each ZipEntry,

                 describing whether encryption is in use, the compressed and uncompressed

                 length of the entry, the offset of the entry, and so on. As a result the

                 information string can be very long for zip files that contain many

                 entries.

               </para>

               <para>

                 This information is mostly useful for diagnostic purposes.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.FullScan">

             <summary>

             Indicates whether to perform a full scan of the zip file when reading it.

             </summary>

             <remarks>

             <para>

               You almost never want to use this property.

             </para>

             <para>

               When reading a zip file, if this flag is <c>true</c> (<c>True</c> in

               VB), the entire zip archive will be scanned and searched for entries.

               For large archives, this can take a very, long time. The much more

               efficient default behavior is to read the zip directory, which is

               stored at the end of the zip file. But, in some cases the directory is

               corrupted and you need to perform a full scan of the zip file to

               determine the contents of the zip file. This property lets you do

               that, when necessary.

             </para>

             <para>

               This flag is effective only when calling <see cref="M:Ionic.Zip.ZipFile.Initialize(System.String)"/>. Normally you would read a ZipFile with the

               static <see cref="M:Ionic.Zip.ZipFile.Read(System.String)">ZipFile.Read</see>

               method. But you can't set the <c>FullScan</c> property on the

               <c>ZipFile</c> instance when you use a static factory method like

               <c>ZipFile.Read</c>.

             </para>

             </remarks>

             <example>

               This example shows how to read a zip file using the full scan approach,

               and then save it, thereby producing a corrected zip file.

             <code lang="C#">

             using (var zip = new ZipFile())

             {

                 zip.FullScan = true;

                 zip.Initialize(zipFileName);

                 zip.Save(newName);

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 zip.FullScan = True

                 zip.Initialize(zipFileName)

                 zip.Save(newName)

             End Using

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipFile.SortEntriesBeforeSaving">

             <summary>

               Whether to sort the ZipEntries before saving the file.

             </summary>

             <remarks>

               The default is false.  If you have a large number of zip entries, the sort

               alone can consume significant time.

             </remarks>

             <example>

             <code lang="C#">

             using (var zip = new ZipFile())

             {

                 zip.AddFiles(filesToAdd);

                 zip.SortEntriesBeforeSaving = true;

                 zip.Save(name);

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 zip.AddFiles(filesToAdd)

                 zip.SortEntriesBeforeSaving = True

                 zip.Save(name)

             End Using

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipFile.AddDirectoryWillTraverseReparsePoints">

             <summary>

               Indicates whether NTFS Reparse Points, like junctions, should be

               traversed during calls to <c>AddDirectory()</c>.

             </summary>

             <remarks>

               By default, calls to AddDirectory() will traverse NTFS reparse

               points, like mounted volumes, and directory junctions.  An example

               of a junction is the "My Music" directory in Windows Vista.  In some

               cases you may not want DotNetZip to traverse those directories.  In

               that case, set this property to false.

             </remarks>

             <example>

             <code lang="C#">

             using (var zip = new ZipFile())

             {

                 zip.AddDirectoryWillTraverseReparsePoints = false;

                 zip.AddDirectory(dirToZip,"fodder");

                 zip.Save(zipFileToCreate);

             }

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipFile.BufferSize">

             <summary>

               Size of the IO buffer used while saving.

             </summary>

             <remarks>

             <para>

               First, let me say that you really don't need to bother with this.  It is

               here to allow for optimizations that you probably won't make! It will work

               fine if you don't set or get this property at all. Ok?

             </para>

             <para>

               Now that we have <em>that</em> out of the way, the fine print: This

               property affects the size of the buffer that is used for I/O for each

               entry contained in the zip file. When a file is read in to be compressed,

               it uses a buffer given by the size here.  When you update a zip file, the

               data for unmodified entries is copied from the first zip file to the

               other, through a buffer given by the size here.

             </para>

             <para>

               Changing the buffer size affects a few things: first, for larger buffer

               sizes, the memory used by the <c>ZipFile</c>, obviously, will be larger

               during I/O operations.  This may make operations faster for very much

               larger files.  Last, for any given entry, when you use a larger buffer

               there will be fewer progress events during I/O operations, because there's

               one progress event generated for each time the buffer is filled and then

               emptied.

             </para>

             <para>

               The default buffer size is 8k.  Increasing the buffer size may speed

               things up as you compress larger files.  But there are no hard-and-fast

               rules here, eh?  You won't know til you test it.  And there will be a

               limit where ever larger buffers actually slow things down.  So as I said

               in the beginning, it's probably best if you don't set or get this property

               at all.

             </para>

             </remarks>

             <example>

             This example shows how you might set a large buffer size for efficiency when

             dealing with zip entries that are larger than 1gb.

             <code lang="C#">

             using (ZipFile zip = new ZipFile())

             {

                 zip.SaveProgress += this.zip1_SaveProgress;

                 zip.AddDirectory(directoryToZip, "");

                 zip.UseZip64WhenSaving = Zip64Option.Always;

                 zip.BufferSize = 65536*8; // 65536 * 8 = 512k

                 zip.Save(ZipFileToCreate);

             }

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipFile.CodecBufferSize">

             <summary>

               Size of the work buffer to use for the ZLIB codec during compression.

             </summary>

             <remarks>

               <para>

                 When doing ZLIB or Deflate compression, the library fills a buffer,

                 then passes it to the compressor for compression. Then the library

                 reads out the compressed bytes. This happens repeatedly until there

                 is no more uncompressed data to compress. This property sets the

                 size of the buffer that will be used for chunk-wise compression. In

                 order for the setting to take effect, your application needs to set

                 this property before calling one of the <c>ZipFile.Save()</c>

                 overloads.

               </para>

               <para>

                 Setting this affects the performance and memory efficiency of

                 compression and decompression. For larger files, setting this to a

                 larger size may improve compression performance, but the exact

                 numbers vary depending on available memory, the size of the streams

                 you are compressing, and a bunch of other variables. I don't have

                 good firm recommendations on how to set it.  You'll have to test it

                 yourself. Or just leave it alone and accept the default.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.FlattenFoldersOnExtract">

             <summary>

               Indicates whether extracted files should keep their paths as

               stored in the zip archive.

             </summary>

             <remarks>

              <para>

                This property affects Extraction.  It is not used when creating zip

                archives.

              </para>

              <para>

                With this property set to <c>false</c>, the default, extracting entries

                from a zip file will create files in the filesystem that have the full

                path associated to the entry within the zip file.  With this property set

                to <c>true</c>, extracting entries from the zip file results in files

                with no path: the folders are "flattened."

              </para>

              <para>

                An example: suppose the zip file contains entries /directory1/file1.txt and

                /directory2/file2.txt.  With <c>FlattenFoldersOnExtract</c> set to false,

                the files created will be \directory1\file1.txt and \directory2\file2.txt.

                With the property set to true, the files created are file1.txt and file2.txt.

              </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Strategy">

             <summary>

               The compression strategy to use for all entries.

             </summary>

             <remarks>

               Set the Strategy used by the ZLIB-compatible compressor, when

               compressing entries using the DEFLATE method. Different compression

               strategies work better on different sorts of data. The strategy

               parameter can affect the compression ratio and the speed of

               compression but not the correctness of the compresssion.  For more

               information see <see cref="T:Ionic.Zlib.CompressionStrategy">Ionic.Zlib.CompressionStrategy</see>.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Name">

             <summary>

               The name of the <c>ZipFile</c>, on disk.

             </summary>

             <remarks>

             <para>

               When the <c>ZipFile</c> instance was created by reading an archive using

               one of the <c>ZipFile.Read</c> methods, this property represents the name

               of the zip file that was read.  When the <c>ZipFile</c> instance was

               created by using the no-argument constructor, this value is <c>null</c>

               (<c>Nothing</c> in VB).

             </para>

             <para>

               If you use the no-argument constructor, and you then explicitly set this

               property, when you call <see cref="M:Ionic.Zip.ZipFile.Save"/>, this name will

               specify the name of the zip file created.  Doing so is equivalent to

               calling <see cref="M:Ionic.Zip.ZipFile.Save(System.String)"/>.  When instantiating a

               <c>ZipFile</c> by reading from a stream or byte array, the <c>Name</c>

               property remains <c>null</c>.  When saving to a stream, the <c>Name</c>

               property is implicitly set to <c>null</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.CompressionLevel">

             <summary>

               Sets the compression level to be used for entries subsequently added to

               the zip archive.

             </summary>

             <remarks>

              <para>

                Varying the compression level used on entries can affect the

                size-vs-speed tradeoff when compression and decompressing data streams

                or files.

              </para>

              <para>

                As with some other properties on the <c>ZipFile</c> class, like <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, and <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>, setting this property on a <c>ZipFile</c>

                instance will cause the specified <c>CompressionLevel</c> to be used on all

                <see cref="T:Ionic.Zip.ZipEntry"/> items that are subsequently added to the

                <c>ZipFile</c> instance. If you set this property after you have added

                items to the <c>ZipFile</c>, but before you have called <c>Save()</c>,

                those items will not use the specified compression level.

              </para>

              <para>

                If you do not set this property, the default compression level is used,

                which normally gives a good balance of compression efficiency and

                compression speed.  In some tests, using <c>BestCompression</c> can

                double the time it takes to compress, while delivering just a small

                increase in compression efficiency.  This behavior will vary with the

                type of data you compress.  If you are in doubt, just leave this setting

                alone, and accept the default.

              </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.CompressionMethod">

            <summary>

              The compression method for the zipfile.

            </summary>

            <remarks>

              <para>

                By default, the compression method is <c>CompressionMethod.Deflate.</c>

              </para>

            </remarks>

            <seealso cref="T:Ionic.Zip.CompressionMethod"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Comment">

             <summary>

               A comment attached to the zip archive.

             </summary>

             <remarks>

             <para>

               This property is read/write. It allows the application to specify a

               comment for the <c>ZipFile</c>, or read the comment for the

               <c>ZipFile</c>.  After setting this property, changes are only made

               permanent when you call a <c>Save()</c> method.

             </para>

             <para>

               According to <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see>, the comment is not encrypted, even if there is a

               password set on the zip file.

             </para>

             <para>

               The specification does not describe how to indicate the encoding used

               on a comment string. Many "compliant" zip tools and libraries use

               IBM437 as the code page for comments; DotNetZip, too, follows that

               practice.  On the other hand, there are situations where you want a

               Comment to be encoded with something else, for example using code page

               950 "Big-5 Chinese". To fill that need, DotNetZip will encode the

               comment following the same procedure it follows for encoding

               filenames: (a) if <see cref="P:Ionic.Zip.ZipFile.AlternateEncodingUsage"/> is

               <c>Never</c>, it uses the default encoding (IBM437). (b) if <see cref="P:Ionic.Zip.ZipFile.AlternateEncodingUsage"/> is <c>Always</c>, it always uses the

               alternate encoding (<see cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/>). (c) if <see cref="P:Ionic.Zip.ZipFile.AlternateEncodingUsage"/> is <c>AsNecessary</c>, it uses the

               alternate encoding only if the default encoding is not sufficient for

               encoding the comment - in other words if decoding the result does not

               produce the original string.  This decision is taken at the time of

               the call to <c>ZipFile.Save()</c>.

             </para>

             <para>

               When creating a zip archive using this library, it is possible to change

               the value of <see cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/> between each

               entry you add, and between adding entries and the call to

               <c>Save()</c>. Don't do this.  It will likely result in a zip file that is

               not readable by any tool or application.  For best interoperability, leave

               <see cref="P:Ionic.Zip.ZipFile.AlternateEncoding"/> alone, or specify it only

               once, before adding any entries to the <c>ZipFile</c> instance.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.EmitTimesInWindowsFormatWhenSaving">

             <summary>

               Specifies whether the Creation, Access, and Modified times for entries

               added to the zip file will be emitted in Windows format

               when the zip archive is saved.

             </summary>

             <remarks>

             <para>

               An application creating a zip archive can use this flag to explicitly

               specify that the file times for the entries should or should not be stored

               in the zip archive in the format used by Windows. By default this flag is

               <c>true</c>, meaning the Windows-format times are stored in the zip

               archive.

             </para>

             <para>

               When adding an entry from a file or directory, the Creation (<see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>), Access (<see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>), and Modified (<see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>) times for the given entry are

               automatically set from the filesystem values. When adding an entry from a

               stream or string, all three values are implicitly set to

               <c>DateTime.Now</c>.  Applications can also explicitly set those times by

               calling <see cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>.

             </para>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see> describes multiple ways to format these times in a

               zip file. One is the format Windows applications normally use: 100ns ticks

               since January 1, 1601 UTC.  The other is a format Unix applications typically

               use: seconds since January 1, 1970 UTC.  Each format can be stored in an

               "extra field" in the zip entry when saving the zip archive. The former

               uses an extra field with a Header Id of 0x000A, while the latter uses a

               header ID of 0x5455, although you probably don't need to know that.

             </para>

             <para>

               Not all tools and libraries can interpret these fields.  Windows

               compressed folders is one that can read the Windows Format timestamps,

               while I believe <see href="http://www.info-zip.org/">the Infozip

               tools</see> can read the Unix format timestamps. Some tools and libraries

               may be able to read only one or the other. DotNetZip can read or write

               times in either or both formats.

             </para>

             <para>

               The times stored are taken from <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>, <see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>, and <see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>.

             </para>

             <para>

               The value set here applies to all entries subsequently added to the

               <c>ZipFile</c>.

             </para>

             <para>

               This property is not mutually exclusive of the <see cref="P:Ionic.Zip.ZipFile.EmitTimesInUnixFormatWhenSaving"/> property. It is possible and

               legal and valid to produce a zip file that contains timestamps encoded in

               the Unix format as well as in the Windows format, in addition to the <see cref="P:Ionic.Zip.ZipEntry.LastModified">LastModified</see> time attached to each

               entry in the archive, a time that is always stored in "DOS format". And,

               notwithstanding the names PKWare uses for these time formats, any of them

               can be read and written by any computer, on any operating system.  But,

               there are no guarantees that a program running on Mac or Linux will

               gracefully handle a zip file with "Windows" formatted times, or that an

               application that does not use DotNetZip but runs on Windows will be able to

               handle file times in Unix format.

             </para>

             <para>

               When in doubt, test.  Sorry, I haven't got a complete list of tools and

               which sort of timestamps they can use and will tolerate.  If you get any

               good information and would like to pass it on, please do so and I will

               include that information in this documentation.

             </para>

             </remarks>

             <example>

               This example shows how to save a zip file that contains file timestamps

               in a format normally used by Unix.

             <code lang="C#">

             using (var zip = new ZipFile())

             {

                 // produce a zip file the Mac will like

                 zip.EmitTimesInWindowsFormatWhenSaving = false;

                 zip.EmitTimesInUnixFormatWhenSaving = true;

                 zip.AddDirectory(directoryToZip, "files");

                 zip.Save(outputFile);

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 '' produce a zip file the Mac will like

                 zip.EmitTimesInWindowsFormatWhenSaving = False

                 zip.EmitTimesInUnixFormatWhenSaving = True

                 zip.AddDirectory(directoryToZip, "files")

                 zip.Save(outputFile)

             End Using

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInWindowsFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipFile.EmitTimesInUnixFormatWhenSaving"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.EmitTimesInUnixFormatWhenSaving">

             <summary>

             Specifies whether the Creation, Access, and Modified times

             for entries added to the zip file will be emitted in "Unix(tm)

             format" when the zip archive is saved.

             </summary>

             <remarks>

             <para>

               An application creating a zip archive can use this flag to explicitly

               specify that the file times for the entries should or should not be stored

               in the zip archive in the format used by Unix. By default this flag is

               <c>false</c>, meaning the Unix-format times are not stored in the zip

               archive.

             </para>

             <para>

               When adding an entry from a file or directory, the Creation (<see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>), Access (<see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>), and Modified (<see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>) times for the given entry are

               automatically set from the filesystem values. When adding an entry from a

               stream or string, all three values are implicitly set to DateTime.Now.

               Applications can also explicitly set those times by calling <see cref="M:Ionic.Zip.ZipEntry.SetEntryTimes(System.DateTime,System.DateTime,System.DateTime)"/>.

             </para>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">PKWARE's

               zip specification</see> describes multiple ways to format these times in a

               zip file. One is the format Windows applications normally use: 100ns ticks

               since January 1, 1601 UTC.  The other is a format Unix applications

               typically use: seconds since January 1, 1970 UTC.  Each format can be

               stored in an "extra field" in the zip entry when saving the zip

               archive. The former uses an extra field with a Header Id of 0x000A, while

               the latter uses a header ID of 0x5455, although you probably don't need to

               know that.

             </para>

             <para>

               Not all tools and libraries can interpret these fields.  Windows

               compressed folders is one that can read the Windows Format timestamps,

               while I believe the <see href="http://www.info-zip.org/">Infozip</see>

               tools can read the Unix format timestamps. Some tools and libraries may be

               able to read only one or the other.  DotNetZip can read or write times in

               either or both formats.

             </para>

             <para>

               The times stored are taken from <see cref="P:Ionic.Zip.ZipEntry.ModifiedTime"/>, <see cref="P:Ionic.Zip.ZipEntry.AccessedTime"/>, and <see cref="P:Ionic.Zip.ZipEntry.CreationTime"/>.

             </para>

             <para>

               This property is not mutually exclusive of the <see cref="P:Ionic.Zip.ZipFile.EmitTimesInWindowsFormatWhenSaving"/> property. It is possible and

               legal and valid to produce a zip file that contains timestamps encoded in

               the Unix format as well as in the Windows format, in addition to the <see cref="P:Ionic.Zip.ZipEntry.LastModified">LastModified</see> time attached to each

               entry in the zip archive, a time that is always stored in "DOS

               format". And, notwithstanding the names PKWare uses for these time

               formats, any of them can be read and written by any computer, on any

               operating system.  But, there are no guarantees that a program running on

               Mac or Linux will gracefully handle a zip file with "Windows" formatted

               times, or that an application that does not use DotNetZip but runs on

               Windows will be able to handle file times in Unix format.

             </para>

             <para>

               When in doubt, test.  Sorry, I haven't got a complete list of tools and

               which sort of timestamps they can use and will tolerate.  If you get any

               good information and would like to pass it on, please do so and I will

               include that information in this documentation.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.EmitTimesInUnixFormatWhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipFile.EmitTimesInWindowsFormatWhenSaving"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Verbose">

             <summary>

               Indicates whether verbose output is sent to the <see cref="P:Ionic.Zip.ZipFile.StatusMessageTextWriter"/> during <c>AddXxx()</c> and

               <c>ReadXxx()</c> operations.

             </summary>

             <remarks>

               This is a <em>synthetic</em> property.  It returns true if the <see cref="P:Ionic.Zip.ZipFile.StatusMessageTextWriter"/> is non-null.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.CaseSensitiveRetrieval">

             <summary>

               Indicates whether to perform case-sensitive matching on the filename when

               retrieving entries in the zipfile via the string-based indexer.

             </summary>

             <remarks>

               The default value is <c>false</c>, which means don't do case-sensitive

               matching. In other words, retrieving zip["ReadMe.Txt"] is the same as

               zip["readme.txt"].  It really makes sense to set this to <c>true</c> only

               if you are not running on Windows, which has case-insensitive

               filenames. But since this library is not built for non-Windows platforms,

               in most cases you should just leave this property alone.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.UseUnicodeAsNecessary">

             <summary>

               Indicates whether to encode entry filenames and entry comments using Unicode

               (UTF-8).

             </summary>

             <remarks>

             <para>

               <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">The

               PKWare zip specification</see> provides for encoding file names and file

               comments in either the IBM437 code page, or in UTF-8.  This flag selects

               the encoding according to that specification.  By default, this flag is

               false, and filenames and comments are encoded into the zip file in the

               IBM437 codepage.  Setting this flag to true will specify that filenames

               and comments that cannot be encoded with IBM437 will be encoded with

               UTF-8.

             </para>

             <para>

               Zip files created with strict adherence to the PKWare specification with

               respect to UTF-8 encoding can contain entries with filenames containing

               any combination of Unicode characters, including the full range of

               characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many other

               alphabets.  However, because at this time, the UTF-8 portion of the PKWare

               specification is not broadly supported by other zip libraries and

               utilities, such zip files may not be readable by your favorite zip tool or

               archiver. In other words, interoperability will decrease if you set this

               flag to true.

             </para>

             <para>

               In particular, Zip files created with strict adherence to the PKWare

               specification with respect to UTF-8 encoding will not work well with

               Explorer in Windows XP or Windows Vista, because Windows compressed

               folders, as far as I know, do not support UTF-8 in zip files.  Vista can

               read the zip files, but shows the filenames incorrectly. Unpacking from

               Windows Vista Explorer will result in filenames that have rubbish

               characters in place of the high-order UTF-8 bytes.

             </para>

             <para>

               Also, zip files that use UTF-8 encoding will not work well with Java

               applications that use the java.util.zip classes, as of v5.0 of the Java

               runtime. The Java runtime does not correctly implement the PKWare

               specification in this regard.

             </para>

             <para>

               As a result, we have the unfortunate situation that "correct" behavior by

               the DotNetZip library with regard to Unicode encoding of filenames during

               zip creation will result in zip files that are readable by strictly

               compliant and current tools (for example the most recent release of the

               commercial WinZip tool); but these zip files will not be readable by

               various other tools or libraries, including Windows Explorer.

             </para>

             <para>

               The DotNetZip library can read and write zip files with UTF8-encoded

               entries, according to the PKware spec.  If you use DotNetZip for both

               creating and reading the zip file, and you use UTF-8, there will be no

               loss of information in the filenames. For example, using a self-extractor

               created by this library will allow you to unpack files correctly with no

               loss of information in the filenames.

             </para>

             <para>

               If you do not set this flag, it will remain false.  If this flag is false,

               your <c>ZipFile</c> will encode all filenames and comments using the

               IBM437 codepage.  This can cause "loss of information" on some filenames,

               but the resulting zipfile will be more interoperable with other

               utilities. As an example of the loss of information, diacritics can be

               lost.  The o-tilde character will be down-coded to plain o.  The c with a

               cedilla (Unicode 0xE7) used in Portugese will be downcoded to a c.

               Likewise, the O-stroke character (Unicode 248), used in Danish and

               Norwegian, will be down-coded to plain o. Chinese characters cannot be

               represented in codepage IBM437; when using the default encoding, Chinese

               characters in filenames will be represented as ?. These are all examples

               of "information loss".

             </para>

             <para>

               The loss of information associated to the use of the IBM437 encoding is

               inconvenient, and can also lead to runtime errors. For example, using

               IBM437, any sequence of 4 Chinese characters will be encoded as ????.  If

               your application creates a <c>ZipFile</c>, then adds two files, each with

               names of four Chinese characters each, this will result in a duplicate

               filename exception.  In the case where you add a single file with a name

               containing four Chinese characters, calling Extract() on the entry that

               has question marks in the filename will result in an exception, because

               the question mark is not legal for use within filenames on Windows.  These

               are just a few examples of the problems associated to loss of information.

             </para>

             <para>

               This flag is independent of the encoding of the content within the entries

               in the zip file. Think of the zip file as a container - it supports an

               encoding.  Within the container are other "containers" - the file entries

               themselves.  The encoding within those entries is independent of the

               encoding of the zip archive container for those entries.

             </para>

             <para>

               Rather than specify the encoding in a binary fashion using this flag, an

               application can specify an arbitrary encoding via the <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> property.  Setting the encoding

               explicitly when creating zip archives will result in non-compliant zip

               files that, curiously, are fairly interoperable.  The challenge is, the

               PKWare specification does not provide for a way to specify that an entry

               in a zip archive uses a code page that is neither IBM437 nor UTF-8.

               Therefore if you set the encoding explicitly when creating a zip archive,

               you must take care upon reading the zip archive to use the same code page.

               If you get it wrong, the behavior is undefined and may result in incorrect

               filenames, exceptions, stomach upset, hair loss, and acne.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.UseZip64WhenSaving">

             <summary>

               Specify whether to use ZIP64 extensions when saving a zip archive.

             </summary>

             <remarks>

             <para>

               When creating a zip file, the default value for the property is <see cref="F:Ionic.Zip.Zip64Option.Never"/>. <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> is

               safest, in the sense that you will not get an Exception if a pre-ZIP64

               limit is exceeded.

             </para>

             <para>

               You may set the property at any time before calling Save().

             </para>

             <para>

               When reading a zip file via the <c>Zipfile.Read()</c> method, DotNetZip

               will properly read ZIP64-endowed zip archives, regardless of the value of

               this property.  DotNetZip will always read ZIP64 archives.  This property

               governs only whether DotNetZip will write them. Therefore, when updating

               archives, be careful about setting this property after reading an archive

               that may use ZIP64 extensions.

             </para>

             <para>

               An interesting question is, if you have set this property to

               <c>AsNecessary</c>, and then successfully saved, does the resulting

               archive use ZIP64 extensions or not?  To learn this, check the <see cref="P:Ionic.Zip.ZipFile.OutputUsedZip64"/> property, after calling <c>Save()</c>.

             </para>

             <para>

               Have you thought about

               <see href="http://cheeso.members.winisp.net/DotNetZipDonate.aspx">donating</see>?

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.RequiresZip64"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.RequiresZip64">

             <summary>

               Indicates whether the archive requires ZIP64 extensions.

             </summary>

             <remarks>

             <para>

               This property is <c>null</c> (or <c>Nothing</c> in VB) if the archive has

               not been saved, and there are fewer than 65334 <c>ZipEntry</c> items

               contained in the archive.

             </para>

             <para>

               The <c>Value</c> is true if any of the following four conditions holds:

               the uncompressed size of any entry is larger than 0xFFFFFFFF; the

               compressed size of any entry is larger than 0xFFFFFFFF; the relative

               offset of any entry within the zip archive is larger than 0xFFFFFFFF; or

               there are more than 65534 entries in the archive.  (0xFFFFFFFF =

               4,294,967,295).  The result may not be known until a <c>Save()</c> is attempted

               on the zip archive.  The Value of this <see cref="T:System.Nullable"/>

               property may be set only AFTER one of the Save() methods has been called.

             </para>

             <para>

               If none of the four conditions holds, and the archive has been saved, then

               the <c>Value</c> is false.

             </para>

             <para>

               A <c>Value</c> of false does not indicate that the zip archive, as saved,

               does not use ZIP64.  It merely indicates that ZIP64 is not required.  An

               archive may use ZIP64 even when not required if the <see cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/> property is set to <see cref="F:Ionic.Zip.Zip64Option.Always"/>, or if the <see cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/> property is set to <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> and the output stream was not

               seekable. Use the <see cref="P:Ionic.Zip.ZipFile.OutputUsedZip64"/> property to determine if

               the most recent <c>Save()</c> method resulted in an archive that utilized

               the ZIP64 extensions.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipFile.OutputUsedZip64"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.OutputUsedZip64">

             <summary>

               Indicates whether the most recent <c>Save()</c> operation used ZIP64 extensions.

             </summary>

             <remarks>

             <para>

               The use of ZIP64 extensions within an archive is not always necessary, and

               for interoperability concerns, it may be desired to NOT use ZIP64 if

               possible.  The <see cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/> property can be

               set to use ZIP64 extensions only when necessary.  In those cases,

               Sometimes applications want to know whether a Save() actually used ZIP64

               extensions.  Applications can query this read-only property to learn

               whether ZIP64 has been used in a just-saved <c>ZipFile</c>.

             </para>

             <para>

               The value is <c>null</c> (or <c>Nothing</c> in VB) if the archive has not

               been saved.

             </para>

             <para>

               Non-null values (<c>HasValue</c> is true) indicate whether ZIP64

               extensions were used during the most recent <c>Save()</c> operation.  The

               ZIP64 extensions may have been used as required by any particular entry

               because of its uncompressed or compressed size, or because the archive is

               larger than 4294967295 bytes, or because there are more than 65534 entries

               in the archive, or because the <c>UseZip64WhenSaving</c> property was set

               to <see cref="F:Ionic.Zip.Zip64Option.Always"/>, or because the

               <c>UseZip64WhenSaving</c> property was set to <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> and the output stream was not seekable.

               The value of this property does not indicate the reason the ZIP64

               extensions were used.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.UseZip64WhenSaving"/>

             <seealso cref="P:Ionic.Zip.ZipFile.RequiresZip64"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.InputUsesZip64">

             <summary>

               Indicates whether the most recent <c>Read()</c> operation read a zip file that uses

               ZIP64 extensions.

             </summary>

             <remarks>

               This property will return null (Nothing in VB) if you've added an entry after reading

               the zip file.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding">

             <summary>

               The text encoding to use when writing new entries to the <c>ZipFile</c>,

               for those entries that cannot be encoded with the default (IBM437)

               encoding; or, the text encoding that was used when reading the entries

               from the <c>ZipFile</c>.

             </summary>

             <remarks>

             <para>

               In <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">its

               zip specification</see>, PKWare describes two options for encoding

               filenames and comments: using IBM437 or UTF-8.  But, some archiving tools

               or libraries do not follow the specification, and instead encode

               characters using the system default code page.  For example, WinRAR when

               run on a machine in Shanghai may encode filenames with the Big-5 Chinese

               (950) code page.  This behavior is contrary to the Zip specification, but

               it occurs anyway.

             </para>

             <para>

               When using DotNetZip to write zip archives that will be read by one of

               these other archivers, set this property to specify the code page to use

               when encoding the <see cref="P:Ionic.Zip.ZipEntry.FileName"/> and <see cref="P:Ionic.Zip.ZipEntry.Comment"/> for each <c>ZipEntry</c> in the zip file, for

               values that cannot be encoded with the default codepage for zip files,

               IBM437.  This is why this property is "provisional".  In all cases, IBM437

               is used where possible, in other words, where no loss of data would

               result. It is possible, therefore, to have a given entry with a

               <c>Comment</c> encoded in IBM437 and a <c>FileName</c> encoded with the

               specified "provisional" codepage.

             </para>

             <para>

               Be aware that a zip file created after you've explicitly set the <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> property to a value other than

               IBM437 may not be compliant to the PKWare specification, and may not be

               readable by compliant archivers.  On the other hand, many (most?)

               archivers are non-compliant and can read zip files created in arbitrary

               code pages.  The trick is to use or specify the proper codepage when

               reading the zip.

             </para>

             <para>

               When creating a zip archive using this library, it is possible to change

               the value of <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> between each

               entry you add, and between adding entries and the call to

               <c>Save()</c>. Don't do this. It will likely result in a zipfile that is

               not readable.  For best interoperability, either leave <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> alone, or specify it only once,

               before adding any entries to the <c>ZipFile</c> instance.  There is one

               exception to this recommendation, described later.

             </para>

             <para>

               When using an arbitrary, non-UTF8 code page for encoding, there is no

               standard way for the creator application - whether DotNetZip, WinZip,

               WinRar, or something else - to formally specify in the zip file which

               codepage has been used for the entries. As a result, readers of zip files

               are not able to inspect the zip file and determine the codepage that was

               used for the entries contained within it.  It is left to the application

               or user to determine the necessary codepage when reading zip files encoded

               this way.  In other words, if you explicitly specify the codepage when you

               create the zipfile, you must explicitly specify the same codepage when

               reading the zipfile.

             </para>

             <para>

               The way you specify the code page to use when reading a zip file varies

               depending on the tool or library you use to read the zip.  In DotNetZip,

               you use a ZipFile.Read() method that accepts an encoding parameter.  It

               isn't possible with Windows Explorer, as far as I know, to specify an

               explicit codepage to use when reading a zip.  If you use an incorrect

               codepage when reading a zipfile, you will get entries with filenames that

               are incorrect, and the incorrect filenames may even contain characters

               that are not legal for use within filenames in Windows. Extracting entries

               with illegal characters in the filenames will lead to exceptions. It's too

               bad, but this is just the way things are with code pages in zip

               files. Caveat Emptor.

             </para>

             <para>

               Example: Suppose you create a zipfile that contains entries with

               filenames that have Danish characters.  If you use <see cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/> equal to "iso-8859-1" (cp 28591),

               the filenames will be correctly encoded in the zip.  But, to read that

               zipfile correctly, you have to specify the same codepage at the time you

               read it. If try to read that zip file with Windows Explorer or another

               application that is not flexible with respect to the codepage used to

               decode filenames in zipfiles, you will get a filename like "Inf°.txt".

             </para>

             <para>

               When using DotNetZip to read a zip archive, and the zip archive uses an

               arbitrary code page, you must specify the encoding to use before or when

               the <c>Zipfile</c> is READ.  This means you must use a <c>ZipFile.Read()</c>

               method that allows you to specify a System.Text.Encoding parameter.  Setting

               the ProvisionalAlternateEncoding property after your application has read in

               the zip archive will not affect the entry names of entries that have already

               been read in.

             </para>

             <para>

               And now, the exception to the rule described above.  One strategy for

               specifying the code page for a given zip file is to describe the code page

               in a human-readable form in the Zip comment. For example, the comment may

               read "Entries in this archive are encoded in the Big5 code page".  For

               maximum interoperability, the zip comment in this case should be encoded

               in the default, IBM437 code page.  In this case, the zip comment is

               encoded using a different page than the filenames.  To do this, Specify

               <c>ProvisionalAlternateEncoding</c> to your desired region-specific code

               page, once before adding any entries, and then reset

               <c>ProvisionalAlternateEncoding</c> to IBM437 before setting the <see cref="P:Ionic.Zip.ZipFile.Comment"/> property and calling Save().

             </para>

             </remarks>

             <example>

             This example shows how to read a zip file using the Big-5 Chinese code page

             (950), and extract each entry in the zip file.  For this code to work as

             desired, the <c>Zipfile</c> must have been created using the big5 code page

             (CP950). This is typical, for example, when using WinRar on a machine with

             CP950 set as the default code page.  In that case, the names of entries

             within the Zip archive will be stored in that code page, and reading the zip

             archive must be done using that code page.  If the application did not use

             the correct code page in <c>ZipFile.Read()</c>, then names of entries within the

             zip archive would not be correctly retrieved.

             <code>

             using (var zip = ZipFile.Read(zipFileName, System.Text.Encoding.GetEncoding("big5")))

             {

                 // retrieve and extract an entry using a name encoded with CP950

                 zip[MyDesiredEntry].Extract("unpack");

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(ZipToExtract, System.Text.Encoding.GetEncoding("big5"))

                 ' retrieve and extract an entry using a name encoded with CP950

                 zip(MyDesiredEntry).Extract("unpack")

             End Using

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipFile.DefaultEncoding">DefaultEncoding</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipFile.AlternateEncoding">

            <summary>

              A Text Encoding to use when encoding the filenames and comments for

              all the ZipEntry items, during a ZipFile.Save() operation.

            </summary>

            <remarks>

              <para>

                Whether the encoding specified here is used during the save depends

                on <see cref="P:Ionic.Zip.ZipFile.AlternateEncodingUsage"/>.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.AlternateEncodingUsage">

            <summary>

              A flag that tells if and when this instance should apply

              AlternateEncoding to encode the filenames and comments associated to

              of ZipEntry objects contained within this instance.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ZipFile.DefaultEncoding">

            <summary>

            The default text encoding used in zip archives.  It is numeric 437, also

            known as IBM437.

            </summary>

            <seealso cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.StatusMessageTextWriter">

             <summary>

             Gets or sets the <c>TextWriter</c> to which status messages are delivered

             for the instance.

             </summary>

             <remarks>

               If the TextWriter is set to a non-null value, then verbose output is sent

               to the <c>TextWriter</c> during <c>Add</c><c>, Read</c><c>, Save</c> and

               <c>Extract</c> operations.  Typically, console applications might use

               <c>Console.Out</c> and graphical or headless applications might use a

               <c>System.IO.StringWriter</c>. The output of this is suitable for viewing

               by humans.

             </remarks>

             <example>

             <para>

               In this example, a console application instantiates a <c>ZipFile</c>, then

               sets the <c>StatusMessageTextWriter</c> to <c>Console.Out</c>.  At that

               point, all verbose status messages for that <c>ZipFile</c> are sent to the

               console.

             </para>

             <code lang="C#">

             using (ZipFile zip= ZipFile.Read(FilePath))

             {

               zip.StatusMessageTextWriter= System.Console.Out;

               // messages are sent to the console during extraction

               zip.ExtractAll();

             }

             </code>

             <code lang="VB">

             Using zip As ZipFile = ZipFile.Read(FilePath)

               zip.StatusMessageTextWriter= System.Console.Out

               'Status Messages will be sent to the console during extraction

               zip.ExtractAll()

             End Using

             </code>

             <para>

               In this example, a Windows Forms application instantiates a

               <c>ZipFile</c>, then sets the <c>StatusMessageTextWriter</c> to a

               <c>StringWriter</c>.  At that point, all verbose status messages for that

               <c>ZipFile</c> are sent to the <c>StringWriter</c>.

             </para>

             <code lang="C#">

             var sw = new System.IO.StringWriter();

             using (ZipFile zip= ZipFile.Read(FilePath))

             {

               zip.StatusMessageTextWriter= sw;

               zip.ExtractAll();

             }

             Console.WriteLine("{0}", sw.ToString());

             </code>

             <code lang="VB">

             Dim sw as New System.IO.StringWriter

             Using zip As ZipFile = ZipFile.Read(FilePath)

               zip.StatusMessageTextWriter= sw

               zip.ExtractAll()

             End Using

             'Status Messages are now available in sw

             </code>

             </example>

        </member>

        <member name="P:Ionic.Zip.ZipFile.TempFileFolder">

             <summary>

               Gets or sets the name for the folder to store the temporary file

               this library writes when saving a zip archive.

             </summary>

             <remarks>

             <para>

               This library will create a temporary file when saving a Zip archive to a

               file.  This file is written when calling one of the <c>Save()</c> methods

               that does not save to a stream, or one of the <c>SaveSelfExtractor()</c>

               methods.

             </para>

             <para>

               By default, the library will create the temporary file in the directory

               specified for the file itself, via the <see cref="P:Ionic.Zip.ZipFile.Name"/> property or via

               the <see cref="M:Ionic.Zip.ZipFile.Save(System.String)"/> method.

             </para>

             <para>

               Setting this property allows applications to override this default

               behavior, so that the library will create the temporary file in the

               specified folder. For example, to have the library create the temporary

               file in the current working directory, regardless where the <c>ZipFile</c>

               is saved, specfy ".".  To revert to the default behavior, set this

               property to <c>null</c> (<c>Nothing</c> in VB).

             </para>

             <para>

               When setting the property to a non-null value, the folder specified must

               exist; if it does not an exception is thrown.  The application should have

               write and delete permissions on the folder.  The permissions are not

               explicitly checked ahead of time; if the application does not have the

               appropriate rights, an exception will be thrown at the time <c>Save()</c>

               is called.

             </para>

             <para>

               There is no temporary file created when reading a zip archive.  When

               saving to a Stream, there is no temporary file created.  For example, if

               the application is an ASP.NET application and calls <c>Save()</c>

               specifying the <c>Response.OutputStream</c> as the output stream, there is

               no temporary file created.

             </para>

             </remarks>

             <exception cref="T:System.IO.FileNotFoundException">

             Thrown when setting the property if the directory does not exist.

             </exception>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Password">

             <summary>

             Sets the password to be used on the <c>ZipFile</c> instance.

             </summary>

             <remarks>

             <para>

               When writing a zip archive, this password is applied to the entries, not

               to the zip archive itself. It applies to any <c>ZipEntry</c> subsequently

               added to the <c>ZipFile</c>, using one of the <c>AddFile</c>,

               <c>AddDirectory</c>, <c>AddEntry</c>, or <c>AddItem</c> methods, etc.

               When reading a zip archive, this property applies to any entry

               subsequently extracted from the <c>ZipFile</c> using one of the Extract

               methods on the <c>ZipFile</c> class.

             </para>

             <para>

               When writing a zip archive, keep this in mind: though the password is set

               on the ZipFile object, according to the Zip spec, the "directory" of the

               archive - in other words the list of entries or files contained in the archive - is

               not encrypted with the password, or protected in any way.  If you set the

               Password property, the password actually applies to individual entries

               that are added to the archive, subsequent to the setting of this property.

               The list of filenames in the archive that is eventually created will

               appear in clear text, but the contents of the individual files are

               encrypted.  This is how Zip encryption works.

             </para>

             <para>

               One simple way around this limitation is to simply double-wrap sensitive

               filenames: Store the files in a zip file, and then store that zip file

               within a second, "outer" zip file.  If you apply a password to the outer

               zip file, then readers will be able to see that the outer zip file

               contains an inner zip file.  But readers will not be able to read the

               directory or file list of the inner zip file.

             </para>

             <para>

               If you set the password on the <c>ZipFile</c>, and then add a set of files

               to the archive, then each entry is encrypted with that password.  You may

               also want to change the password between adding different entries. If you

               set the password, add an entry, then set the password to <c>null</c>

               (<c>Nothing</c> in VB), and add another entry, the first entry is

               encrypted and the second is not.  If you call <c>AddFile()</c>, then set

               the <c>Password</c> property, then call <c>ZipFile.Save</c>, the file

               added will not be password-protected, and no warning will be generated.

             </para>

             <para>

               When setting the Password, you may also want to explicitly set the <see cref="P:Ionic.Zip.ZipFile.Encryption"/> property, to specify how to encrypt the entries added

               to the ZipFile.  If you set the Password to a non-null value and do not

               set <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, then PKZip 2.0 ("Weak") encryption is used.

               This encryption is relatively weak but is very interoperable. If you set

               the password to a <c>null</c> value (<c>Nothing</c> in VB), Encryption is

               reset to None.

             </para>

             <para>

               All of the preceding applies to writing zip archives, in other words when

               you use one of the Save methods.  To use this property when reading or an

               existing ZipFile, do the following: set the Password property on the

               <c>ZipFile</c>, then call one of the Extract() overloads on the <see cref="T:Ionic.Zip.ZipEntry"/>. In this case, the entry is extracted using the

               <c>Password</c> that is specified on the <c>ZipFile</c> instance. If you

               have not set the <c>Password</c> property, then the password is

               <c>null</c>, and the entry is extracted with no password.

             </para>

             <para>

               If you set the Password property on the <c>ZipFile</c>, then call

               <c>Extract()</c> an entry that has not been encrypted with a password, the

               password is not used for that entry, and the <c>ZipEntry</c> is extracted

               as normal. In other words, the password is used only if necessary.

             </para>

             <para>

               The <see cref="T:Ionic.Zip.ZipEntry"/> class also has a <see cref="P:Ionic.Zip.ZipEntry.Password">Password</see> property.  It takes precedence

               over this property on the <c>ZipFile</c>.  Typically, you would use the

               per-entry Password when most entries in the zip archive use one password,

               and a few entries use a different password.  If all entries in the zip

               file use the same password, then it is simpler to just set this property

               on the <c>ZipFile</c> itself, whether creating a zip archive or extracting

               a zip archive.

             </para>

             </remarks>

             <example>

             <para>

               This example creates a zip file, using password protection for the

               entries, and then extracts the entries from the zip file.  When creating

               the zip file, the Readme.txt file is not protected with a password, but

               the other two are password-protected as they are saved. During extraction,

               each file is extracted with the appropriate password.

             </para>

             <code>

             // create a file with encryption

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddFile("ReadMe.txt");

                 zip.Password= "!Secret1";

                 zip.AddFile("MapToTheSite-7440-N49th.png");

                 zip.AddFile("2008-Regional-Sales-Report.pdf");

                 zip.Save("EncryptedArchive.zip");

             }

             // extract entries that use encryption

             using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))

             {

                 zip.Password= "!Secret1";

                 zip.ExtractAll("extractDir");

             }

             </code>

             <code lang="VB">

             Using zip As New ZipFile

                 zip.AddFile("ReadMe.txt")

                 zip.Password = "123456!"

                 zip.AddFile("MapToTheSite-7440-N49th.png")

                 zip.Password= "!Secret1";

                 zip.AddFile("2008-Regional-Sales-Report.pdf")

                 zip.Save("EncryptedArchive.zip")

             End Using

             ' extract entries that use encryption

             Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))

                 zip.Password= "!Secret1"

                 zip.ExtractAll("extractDir")

             End Using

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipFile.Encryption">ZipFile.Encryption</seealso>

             <seealso cref="P:Ionic.Zip.ZipEntry.Password">ZipEntry.Password</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipFile.ExtractExistingFile">

             <summary>

               The action the library should take when extracting a file that already

               exists.

             </summary>

             <remarks>

             <para>

               This property affects the behavior of the Extract methods (one of the

               <c>Extract()</c> or <c>ExtractWithPassword()</c> overloads), when

               extraction would would overwrite an existing filesystem file. If you do

               not set this property, the library throws an exception when extracting an

               entry would overwrite an existing file.

             </para>

             <para>

               This property has no effect when extracting to a stream, or when the file

               to be extracted does not already exist.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipEntry.ExtractExistingFile"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.ZipErrorAction">

             <summary>

               The action the library should take when an error is encountered while

               opening or reading files as they are saved into a zip archive.

             </summary>

             <remarks>

              <para>

                Errors can occur as a file is being saved to the zip archive.  For

                example, the File.Open may fail, or a File.Read may fail, because of

                lock conflicts or other reasons.

              </para>

              <para>

                The first problem might occur after having called AddDirectory() on a

                directory that contains a Clipper .dbf file; the file is locked by

                Clipper and cannot be opened for read by another process. An example of

                the second problem might occur when trying to zip a .pst file that is in

                use by Microsoft Outlook. Outlook locks a range on the file, which allows

                other processes to open the file, but not read it in its entirety.

              </para>

              <para>

                This property tells DotNetZip what you would like to do in the case of

                these errors.  The primary options are: <c>ZipErrorAction.Throw</c> to

                throw an exception (this is the default behavior if you don't set this

                property); <c>ZipErrorAction.Skip</c> to Skip the file for which there

                was an error and continue saving; <c>ZipErrorAction.Retry</c> to Retry

                the entry that caused the problem; or

                <c>ZipErrorAction.InvokeErrorEvent</c> to invoke an event handler.

              </para>

              <para>

                This property is implicitly set to <c>ZipErrorAction.InvokeErrorEvent</c>

                if you add a handler to the <see cref="E:Ionic.Zip.ZipFile.ZipError"/> event.  If you set

                this property to something other than

                <c>ZipErrorAction.InvokeErrorEvent</c>, then the <c>ZipError</c>

                event is implicitly cleared.  What it means is you can set one or the

                other (or neither), depending on what you want, but you never need to set

                both.

              </para>

              <para>

                As with some other properties on the <c>ZipFile</c> class, like <see cref="P:Ionic.Zip.ZipFile.Password"/>, <see cref="P:Ionic.Zip.ZipFile.Encryption"/>, and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, setting this property on a <c>ZipFile</c>

                instance will cause the specified <c>ZipErrorAction</c> to be used on all

                <see cref="T:Ionic.Zip.ZipEntry"/> items that are subsequently added to the

                <c>ZipFile</c> instance. If you set this property after you have added

                items to the <c>ZipFile</c>, but before you have called <c>Save()</c>,

                those items will not use the specified error handling action.

              </para>

              <para>

                If you want to handle any errors that occur with any entry in the zip

                file in the same way, then set this property once, before adding any

                entries to the zip archive.

              </para>

              <para>

                If you set this property to <c>ZipErrorAction.Skip</c> and you'd like to

                learn which files may have been skipped after a <c>Save()</c>, you can

                set the <see cref="P:Ionic.Zip.ZipFile.StatusMessageTextWriter"/> on the ZipFile before

                calling <c>Save()</c>. A message will be emitted into that writer for

                each skipped file, if any.

              </para>

             </remarks>

             <example>

               This example shows how to tell DotNetZip to skip any files for which an

               error is generated during the Save().

             <code lang="VB">

             Public Sub SaveZipFile()

                 Dim SourceFolder As String = "fodder"

                 Dim DestFile As String =  "eHandler.zip"

                 Dim sw as New StringWriter

                 Using zipArchive As ZipFile = New ZipFile

                     ' Tell DotNetZip to skip any files for which it encounters an error

                     zipArchive.ZipErrorAction = ZipErrorAction.Skip

                     zipArchive.StatusMessageTextWriter = sw

                     zipArchive.AddDirectory(SourceFolder)

                     zipArchive.Save(DestFile)

                 End Using

                 ' examine sw here to see any messages

             End Sub

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipEntry.ZipErrorAction"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ZipError"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Encryption">

             <summary>

               The Encryption to use for entries added to the <c>ZipFile</c>.

             </summary>

             <remarks>

             <para>

               Set this when creating a zip archive, or when updating a zip archive. The

               specified Encryption is applied to the entries subsequently added to the

               <c>ZipFile</c> instance.  Applications do not need to set the

               <c>Encryption</c> property when reading or extracting a zip archive.

             </para>

             <para>

               If you set this to something other than EncryptionAlgorithm.None, you

               will also need to set the <see cref="P:Ionic.Zip.ZipFile.Password"/>.

             </para>

             <para>

               As with some other properties on the <c>ZipFile</c> class, like <see cref="P:Ionic.Zip.ZipFile.Password"/> and <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/>, setting this

               property on a <c>ZipFile</c> instance will cause the specified

               <c>EncryptionAlgorithm</c> to be used on all <see cref="T:Ionic.Zip.ZipEntry"/> items

               that are subsequently added to the <c>ZipFile</c> instance. In other

               words, if you set this property after you have added items to the

               <c>ZipFile</c>, but before you have called <c>Save()</c>, those items will

               not be encrypted or protected with a password in the resulting zip

               archive. To get a zip archive with encrypted entries, set this property,

               along with the <see cref="P:Ionic.Zip.ZipFile.Password"/> property, before calling

               <c>AddFile</c>, <c>AddItem</c>, or <c>AddDirectory</c> (etc.) on the

               <c>ZipFile</c> instance.

             </para>

             <para>

               If you read a <c>ZipFile</c>, you can modify the <c>Encryption</c> on an

               encrypted entry, only by setting the <c>Encryption</c> property on the

               <c>ZipEntry</c> itself.  Setting the <c>Encryption</c> property on the

               <c>ZipFile</c>, once it has been created via a call to

               <c>ZipFile.Read()</c>, does not affect entries that were previously read.

             </para>

             <para>

               For example, suppose you read a <c>ZipFile</c>, and there is an encrypted

               entry.  Setting the <c>Encryption</c> property on that <c>ZipFile</c> and

               then calling <c>Save()</c> on the <c>ZipFile</c> does not update the

               <c>Encryption</c> used for the entries in the archive.  Neither is an

               exception thrown. Instead, what happens during the <c>Save()</c> is that

               all previously existing entries are copied through to the new zip archive,

               with whatever encryption and password that was used when originally

               creating the zip archive. Upon re-reading that archive, to extract

               entries, applications should use the original password or passwords, if

               any.

             </para>

             <para>

               Suppose an application reads a <c>ZipFile</c>, and there is an encrypted

               entry.  Setting the <c>Encryption</c> property on that <c>ZipFile</c> and

               then adding new entries (via <c>AddFile()</c>, <c>AddEntry()</c>, etc)

               and then calling <c>Save()</c> on the <c>ZipFile</c> does not update the

               <c>Encryption</c> on any of the entries that had previously been in the

               <c>ZipFile</c>.  The <c>Encryption</c> property applies only to the

               newly-added entries.

             </para>

             </remarks>

             <example>

             <para>

               This example creates a zip archive that uses encryption, and then extracts

               entries from the archive.  When creating the zip archive, the ReadMe.txt

               file is zipped without using a password or encryption.  The other files

               use encryption.

             </para>

             <code>

             // Create a zip archive with AES Encryption.

             using (ZipFile zip = new ZipFile())

             {

                 zip.AddFile("ReadMe.txt");

                 zip.Encryption= EncryptionAlgorithm.WinZipAes256;

                 zip.Password= "Top.Secret.No.Peeking!";

                 zip.AddFile("7440-N49th.png");

                 zip.AddFile("2008-Regional-Sales-Report.pdf");

                 zip.Save("EncryptedArchive.zip");

             }

             // Extract a zip archive that uses AES Encryption.

             // You do not need to specify the algorithm during extraction.

             using (ZipFile zip = ZipFile.Read("EncryptedArchive.zip"))

             {

                 zip.Password= "Top.Secret.No.Peeking!";

                 zip.ExtractAll("extractDirectory");

             }

             </code>

             <code lang="VB">

             ' Create a zip that uses Encryption.

             Using zip As New ZipFile()

                 zip.Encryption= EncryptionAlgorithm.WinZipAes256

                 zip.Password= "Top.Secret.No.Peeking!"

                 zip.AddFile("ReadMe.txt")

                 zip.AddFile("7440-N49th.png")

                 zip.AddFile("2008-Regional-Sales-Report.pdf")

                 zip.Save("EncryptedArchive.zip")

             End Using

             ' Extract a zip archive that uses AES Encryption.

             ' You do not need to specify the algorithm during extraction.

             Using (zip as ZipFile = ZipFile.Read("EncryptedArchive.zip"))

                 zip.Password= "Top.Secret.No.Peeking!"

                 zip.ExtractAll("extractDirectory")

             End Using

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipFile.Password">ZipFile.Password</seealso>

             <seealso cref="P:Ionic.Zip.ZipEntry.Encryption">ZipEntry.Encryption</seealso>

        </member>

        <member name="P:Ionic.Zip.ZipFile.SetCompression">

             <summary>

               A callback that allows the application to specify the compression level

               to use for entries subsequently added to the zip archive.

             </summary>

             <remarks>

             <para>

               With this callback, the DotNetZip library allows the application to

               determine whether compression will be used, at the time of the

               <c>Save</c>. This may be useful if the application wants to favor

               speed over size, and wants to defer the decision until the time of

               <c>Save</c>.

             </para>

             <para>

               Typically applications set the <see cref="P:Ionic.Zip.ZipFile.CompressionLevel"/> property on

               the <c>ZipFile</c> or on each <c>ZipEntry</c> to determine the level of

               compression used. This is done at the time the entry is added to the

               <c>ZipFile</c>. Setting the property to

               <c>Ionic.Zlib.CompressionLevel.None</c> means no compression will be used.

             </para>

             <para>

               This callback allows the application to defer the decision on the

               <c>CompressionLevel</c> to use, until the time of the call to

               <c>ZipFile.Save()</c>. The callback is invoked once per <c>ZipEntry</c>,

               at the time the data for the entry is being written out as part of a

               <c>Save()</c> operation. The application can use whatever criteria it

               likes in determining the level to return.  For example, an application may

               wish that no .mp3 files should be compressed, because they are already

               compressed and the extra compression is not worth the CPU time incurred,

               and so can return <c>None</c> for all .mp3 entries.

             </para>

             <para>

               The library determines whether compression will be attempted for an entry

               this way: If the entry is a zero length file, or a directory, no

               compression is used.  Otherwise, if this callback is set, it is invoked

               and the <c>CompressionLevel</c> is set to the return value. If this

               callback has not been set, then the previously set value for

               <c>CompressionLevel</c> is used.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.MaxOutputSegmentSize">

             <summary>

             The maximum size of an output segment, when saving a split Zip file.

             </summary>

             <remarks>

               <para>

                 Set this to a non-zero value before calling <see cref="M:Ionic.Zip.ZipFile.Save"/> or <see cref="M:Ionic.Zip.ZipFile.Save(System.String)"/> to specify that the ZipFile should be saved as a

                 split archive, also sometimes called a spanned archive. Some also

                 call them multi-file archives.

               </para>

               <para>

                 A split zip archive is saved in a set of discrete filesystem files,

                 rather than in a single file. This is handy when transmitting the

                 archive in email or some other mechanism that has a limit to the size of

                 each file.  The first file in a split archive will be named

                 <c>basename.z01</c>, the second will be named <c>basename.z02</c>, and

                 so on. The final file is named <c>basename.zip</c>. According to the zip

                 specification from PKWare, the minimum value is 65536, for a 64k segment

                 size. The maximum number of segments allows in a split archive is 99.

               </para>

               <para>

                 The value of this property determines the maximum size of a split

                 segment when writing a split archive.  For example, suppose you have a

                 <c>ZipFile</c> that would save to a single file of 200k. If you set the

                 <c>MaxOutputSegmentSize</c> to 65536 before calling <c>Save()</c>, you

                 will get four distinct output files. On the other hand if you set this

                 property to 256k, then you will get a single-file archive for that

                 <c>ZipFile</c>.

               </para>

               <para>

                 The size of each split output file will be as large as possible, up to

                 the maximum size set here. The zip specification requires that some data

                 fields in a zip archive may not span a split boundary, and an output

                 segment may be smaller than the maximum if necessary to avoid that

                 problem. Also, obviously the final segment of the archive may be smaller

                 than the maximum segment size. Segments will never be larger than the

                 value set with this property.

               </para>

               <para>

                 You can save a split Zip file only when saving to a regular filesystem

                 file. It's not possible to save a split zip file as a self-extracting

                 archive, nor is it possible to save a split zip file to a stream. When

                 saving to a SFX or to a Stream, this property is ignored.

               </para>

               <para>

                 About interoperability: Split or spanned zip files produced by DotNetZip

                 can be read by WinZip or PKZip, and vice-versa. Segmented zip files may

                 not be readable by other tools, if those other tools don't support zip

                 spanning or splitting.  When in doubt, test.  I don't believe Windows

                 Explorer can extract a split archive.

               </para>

               <para>

                 This property has no effect when reading a split archive. You can read

                 a split archive in the normal way with DotNetZip.

               </para>

               <para>

                 When saving a zip file, if you want a regular zip file rather than a

                 split zip file, don't set this property, or set it to Zero.

               </para>

               <para>

                 If you read a split archive, with <see cref="M:Ionic.Zip.ZipFile.Read(System.String)"/> and

                 then subsequently call <c>ZipFile.Save()</c>, unless you set this

                 property before calling <c>Save()</c>, you will get a normal,

                 single-file archive.

               </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.NumberOfSegmentsForMostRecentSave"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.NumberOfSegmentsForMostRecentSave">

            <summary>

              Returns the number of segments used in the most recent Save() operation.

            </summary>

            <remarks>

              <para>

                This is normally zero, unless you have set the <see cref="P:Ionic.Zip.ZipFile.MaxOutputSegmentSize"/> property.  If you have set <see cref="P:Ionic.Zip.ZipFile.MaxOutputSegmentSize"/>, and then you save a file, after the call to

                Save() completes, you can read this value to learn the number of segments that

                were created.

              </para>

              <para>

                If you call Save("Archive.zip"), and it creates 5 segments, then you

                will have filesystem files named Archive.z01, Archive.z02, Archive.z03,

                Archive.z04, and Archive.zip, and the value of this property will be 5.

              </para>

            </remarks>

            <seealso cref="P:Ionic.Zip.ZipFile.MaxOutputSegmentSize"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.ParallelDeflateThreshold">

             <summary>

               The size threshold for an entry, above which a parallel deflate is used.

             </summary>

             <remarks>

               <para>

                 DotNetZip will use multiple threads to compress any ZipEntry,

                 if the entry is larger than the given size.  Zero means "always

                 use parallel deflate", while -1 means "never use parallel

                 deflate". The default value for this property is 512k. Aside

                 from the special values of 0 and 1, the minimum value is 65536.

               </para>

               <para>

                 If the entry size cannot be known before compression, as with a

                 read-forward stream, then Parallel deflate will never be

                 performed, unless the value of this property is zero.

               </para>

               <para>

                 A parallel deflate operations will speed up the compression of

                 large files, on computers with multiple CPUs or multiple CPU

                 cores.  For files above 1mb, on a dual core or dual-cpu (2p)

                 machine, the time required to compress the file can be 70% of the

                 single-threaded deflate.  For very large files on 4p machines the

                 compression can be done in 30% of the normal time.  The downside

                 is that parallel deflate consumes extra memory during the deflate,

                 and the deflation is not as effective.

               </para>

               <para>

                 Parallel deflate tends to yield slightly less compression when

                 compared to as single-threaded deflate; this is because the original

                 data stream is split into multiple independent buffers, each of which

                 is compressed in parallel.  But because they are treated

                 independently, there is no opportunity to share compression

                 dictionaries.  For that reason, a deflated stream may be slightly

                 larger when compressed using parallel deflate, as compared to a

                 traditional single-threaded deflate. Sometimes the increase over the

                 normal deflate is as much as 5% of the total compressed size. For

                 larger files it can be as small as 0.1%.

               </para>

               <para>

                 Multi-threaded compression does not give as much an advantage when

                 using Encryption. This is primarily because encryption tends to slow

                 down the entire pipeline. Also, multi-threaded compression gives less

                 of an advantage when using lower compression levels, for example <see cref="F:Ionic.Zlib.CompressionLevel.BestSpeed"/>.  You may have to

                 perform some tests to determine the best approach for your situation.

               </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.ParallelDeflateMaxBufferPairs"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.ParallelDeflateMaxBufferPairs">

             <summary>

               The maximum number of buffer pairs to use when performing

               parallel compression.

             </summary>

             <remarks>

             <para>

               This property sets an upper limit on the number of memory

               buffer pairs to create when performing parallel

               compression.  The implementation of the parallel

               compression stream allocates multiple buffers to

               facilitate parallel compression.  As each buffer fills up,

               the stream uses <see cref="M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback)">

               ThreadPool.QueueUserWorkItem()</see> to compress those

               buffers in a background threadpool thread. After a buffer

               is compressed, it is re-ordered and written to the output

               stream.

             </para>

             <para>

               A higher number of buffer pairs enables a higher degree of

               parallelism, which tends to increase the speed of compression on

               multi-cpu computers.  On the other hand, a higher number of buffer

               pairs also implies a larger memory consumption, more active worker

               threads, and a higher cpu utilization for any compression. This

               property enables the application to limit its memory consumption and

               CPU utilization behavior depending on requirements.

             </para>

             <para>

               For each compression "task" that occurs in parallel, there are 2

               buffers allocated: one for input and one for output.  This property

               sets a limit for the number of pairs.  The total amount of storage

               space allocated for buffering will then be (N*S*2), where N is the

               number of buffer pairs, S is the size of each buffer (<see cref="P:Ionic.Zip.ZipFile.BufferSize"/>).  By default, DotNetZip allocates 4 buffer

               pairs per CPU core, so if your machine has 4 cores, and you retain

               the default buffer size of 128k, then the

               ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer

               memory in total, or 4mb, in blocks of 128kb.  If you then set this

               property to 8, then the number will be 8 * 2 * 128kb of buffer

               memory, or 2mb.

             </para>

             <para>

               CPU utilization will also go up with additional buffers, because a

               larger number of buffer pairs allows a larger number of background

               threads to compress in parallel. If you find that parallel

               compression is consuming too much memory or CPU, you can adjust this

               value downward.

             </para>

             <para>

               The default value is 16. Different values may deliver better or

               worse results, depending on your priorities and the dynamic

               performance characteristics of your storage and compute resources.

             </para>

             <para>

               This property is not the number of buffer pairs to use; it is an

               upper limit. An illustration: Suppose you have an application that

               uses the default value of this property (which is 16), and it runs

               on a machine with 2 CPU cores. In that case, DotNetZip will allocate

               4 buffer pairs per CPU core, for a total of 8 pairs.  The upper

               limit specified by this property has no effect.

             </para>

             <para>

               The application can set this value at any time

               before calling <c>ZipFile.Save()</c>.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.ParallelDeflateThreshold"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.LibraryVersion">

             <summary>

             Returns the version number on the DotNetZip assembly.

             </summary>

             <remarks>

               <para>

                 This property is exposed as a convenience.  Callers could also get the

                 version value by retrieving GetName().Version on the

                 System.Reflection.Assembly object pointing to the DotNetZip

                 assembly. But sometimes it is not clear which assembly is being loaded.

                 This property makes it clear.

               </para>

               <para>

                 This static property is primarily useful for diagnostic purposes.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Item(System.Int32)">

             <summary>

               This is an integer indexer into the Zip archive.

             </summary>

             <remarks>

             <para>

               This property is read-only.

             </para>

             <para>

               Internally, the <c>ZipEntry</c> instances that belong to the

               <c>ZipFile</c> are stored in a Dictionary.  When you use this

               indexer the first time, it creates a read-only

               <c>List&lt;ZipEntry&gt;</c> from the Dictionary.Values Collection.

               If at any time you modify the set of entries in the <c>ZipFile</c>,

               either by adding an entry, removing an entry, or renaming an

               entry, a new List will be created, and the numeric indexes for the

               remaining entries may be different.

             </para>

             <para>

               This means you cannot rename any ZipEntry from

               inside an enumeration of the zip file.

             </para>

             <param name="ix">

               The index value.

             </param>

             </remarks>

             <returns>

               The <c>ZipEntry</c> within the Zip archive at the specified index. If the

               entry does not exist in the archive, this indexer throws.

             </returns>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Item(System.String)">

             <summary>

               This is a name-based indexer into the Zip archive.

             </summary>

             <remarks>

             <para>

               This property is read-only.

             </para>

             <para>

               The <see cref="P:Ionic.Zip.ZipFile.CaseSensitiveRetrieval"/> property on the <c>ZipFile</c>

               determines whether retrieval via this indexer is done via case-sensitive

               comparisons. By default, retrieval is not case sensitive.  This makes

               sense on Windows, in which filesystems are not case sensitive.

             </para>

             <para>

               Regardless of case-sensitivity, it is not always the case that

               <c>this[value].FileName == value</c>. In other words, the <c>FileName</c>

               property of the <c>ZipEntry</c> retrieved with this indexer, may or may

               not be equal to the index value.

             </para>

             <para>

               This is because DotNetZip performs a normalization of filenames passed to

               this indexer, before attempting to retrieve the item.  That normalization

               includes: removal of a volume letter and colon, swapping backward slashes

               for forward slashes.  So, <c>zip["dir1\\entry1.txt"].FileName ==

               "dir1/entry.txt"</c>.

             </para>

             <para>

               Directory entries in the zip file may be retrieved via this indexer only

               with names that have a trailing slash. DotNetZip automatically appends a

               trailing slash to the names of any directory entries added to a zip.

             </para>

             </remarks>

             <example>

             This example extracts only the entries in a zip file that are .txt files.

             <code>

             using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))

             {

               foreach (string s1 in zip.EntryFilenames)

               {

                 if (s1.EndsWith(".txt"))

                   zip[s1].Extract("textfiles");

               }

             }

             </code>

             <code lang="VB">

               Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")

                   Dim s1 As String

                   For Each s1 In zip.EntryFilenames

                       If s1.EndsWith(".txt") Then

                           zip(s1).Extract("textfiles")

                       End If

                   Next

               End Using

             </code>

             </example>

             <seealso cref="M:Ionic.Zip.ZipFile.RemoveEntry(System.String)"/>

             <exception cref="T:System.ArgumentException">

               Thrown if the caller attempts to assign a non-null value to the indexer.

             </exception>

             <param name="fileName">

               The name of the file, including any directory path, to retrieve from the

               zip.  The filename match is not case-sensitive by default; you can use the

               <see cref="P:Ionic.Zip.ZipFile.CaseSensitiveRetrieval"/> property to change this behavior. The

               pathname can use forward-slashes or backward slashes.

             </param>

             <returns>

               The <c>ZipEntry</c> within the Zip archive, given by the specified

               filename. If the named entry does not exist in the archive, this indexer

               returns <c>null</c> (<c>Nothing</c> in VB).

             </returns>

        </member>

        <member name="P:Ionic.Zip.ZipFile.EntryFileNames">

             <summary>

               The list of filenames for the entries contained within the zip archive.

             </summary>

             <remarks>

               According to the ZIP specification, the names of the entries use forward

               slashes in pathnames.  If you are scanning through the list, you may have

               to swap forward slashes for backslashes.

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.Item(System.String)"/>

             <example>

               This example shows one way to test if a filename is already contained

               within a zip archive.

             <code>

             String zipFileToRead= "PackedDocuments.zip";

             string candidate = "DatedMaterial.xps";

             using (ZipFile zip = new ZipFile(zipFileToRead))

             {

               if (zip.EntryFilenames.Contains(candidate))

                 Console.WriteLine("The file '{0}' exists in the zip archive '{1}'",

                                   candidate,

                                   zipFileName);

               else

                 Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'",

                                   candidate,

                                   zipFileName);

               Console.WriteLine();

             }

             </code>

             <code lang="VB">

               Dim zipFileToRead As String = "PackedDocuments.zip"

               Dim candidate As String = "DatedMaterial.xps"

               Using zip As ZipFile.Read(ZipFileToRead)

                   If zip.EntryFilenames.Contains(candidate) Then

                       Console.WriteLine("The file '{0}' exists in the zip archive '{1}'", _

                                   candidate, _

                                   zipFileName)

                   Else

                     Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'", _

                                   candidate, _

                                   zipFileName)

                   End If

                   Console.WriteLine

               End Using

             </code>

             </example>

             <returns>

               The list of strings for the filenames contained within the Zip archive.

             </returns>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Entries">

             <summary>

               Returns the readonly collection of entries in the Zip archive.

             </summary>

             <remarks>

             <para>

               If there are no entries in the current <c>ZipFile</c>, the value returned is a

               non-null zero-element collection.  If there are entries in the zip file,

               the elements are returned in no particular order.

             </para>

             <para>

               This is the implied enumerator on the <c>ZipFile</c> class.  If you use a

               <c>ZipFile</c> instance in a context that expects an enumerator, you will

               get this collection.

             </para>

             </remarks>

             <seealso cref="P:Ionic.Zip.ZipFile.EntriesSorted"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.EntriesSorted">

             <summary>

               Returns a readonly collection of entries in the Zip archive, sorted by FileName.

             </summary>

             <remarks>

               If there are no entries in the current <c>ZipFile</c>, the value returned

               is a non-null zero-element collection.  If there are entries in the zip

               file, the elements are returned sorted by the name of the entry.

             </remarks>

             <example>

               This example fills a Windows Forms ListView with the entries in a zip file.

             <code lang="C#">

             using (ZipFile zip = ZipFile.Read(zipFile))

             {

                 foreach (ZipEntry entry in zip.EntriesSorted)

                 {

                     ListViewItem item = new ListViewItem(n.ToString());

                     n++;

                     string[] subitems = new string[] {

                         entry.FileName.Replace("/","\\"),

                         entry.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),

                         entry.UncompressedSize.ToString(),

                         String.Format("{0,5:F0}%", entry.CompressionRatio),

                         entry.CompressedSize.ToString(),

                         (entry.UsesEncryption) ? "Y" : "N",

                         String.Format("{0:X8}", entry.Crc)};

                     foreach (String s in subitems)

                     {

                         ListViewItem.ListViewSubItem subitem = new ListViewItem.ListViewSubItem();

                         subitem.Text = s;

                         item.SubItems.Add(subitem);

                     }

                     this.listView1.Items.Add(item);

                 }

             }

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipFile.Entries"/>

        </member>

        <member name="P:Ionic.Zip.ZipFile.Count">

            <summary>

            Returns the number of entries in the Zip archive.

            </summary>

        </member>

        <member name="E:Ionic.Zip.ZipFile.SaveProgress">

             <summary>

               An event handler invoked when a Save() starts, before and after each

               entry has been written to the archive, when a Save() completes, and

               during other Save events.

             </summary>

             <remarks>

             <para>

               Depending on the particular event, different properties on the <see cref="T:Ionic.Zip.SaveProgressEventArgs"/> parameter are set.  The following

               table summarizes the available EventTypes and the conditions under

               which this event handler is invoked with a

               <c>SaveProgressEventArgs</c> with the given EventType.

             </para>

             <list type="table">

             <listheader>

             <term>value of EntryType</term>

             <description>Meaning and conditions</description>

             </listheader>

             <item>

             <term>ZipProgressEventType.Saving_Started</term>

             <description>Fired when ZipFile.Save() begins.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_BeforeSaveEntry</term>

             <description>

               Fired within ZipFile.Save(), just before writing data for each

               particular entry.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_AfterSaveEntry</term>

             <description>

               Fired within ZipFile.Save(), just after having finished writing data

               for each particular entry.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_Completed</term>

             <description>Fired when ZipFile.Save() has completed.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_AfterSaveTempArchive</term>

             <description>

               Fired after the temporary file has been created.  This happens only

               when saving to a disk file.  This event will not be invoked when

               saving to a stream.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_BeforeRenameTempArchive</term>

             <description>

               Fired just before renaming the temporary file to the permanent

               location.  This happens only when saving to a disk file.  This event

               will not be invoked when saving to a stream.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_AfterRenameTempArchive</term>

             <description>

               Fired just after renaming the temporary file to the permanent

               location.  This happens only when saving to a disk file.  This event

               will not be invoked when saving to a stream.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_AfterCompileSelfExtractor</term>

             <description>

               Fired after a self-extracting archive has finished compiling.  This

               EventType is used only within SaveSelfExtractor().

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Saving_BytesRead</term>

             <description>

               Set during the save of a particular entry, to update progress of the

               Save().  When this EventType is set, the BytesTransferred is the

               number of bytes that have been read from the source stream.  The

               TotalBytesToTransfer is the number of bytes in the uncompressed

               file.

             </description>

             </item>

             </list>

             </remarks>

             <example>

                This example uses an anonymous method to handle the

                SaveProgress event, by updating a progress bar.

             <code lang="C#">

             progressBar1.Value = 0;

             progressBar1.Max = listbox1.Items.Count;

             using (ZipFile zip = new ZipFile())

             {

                // listbox1 contains a list of filenames

                zip.AddFiles(listbox1.Items);

                // do the progress bar:

                zip.SaveProgress += (sender, e) =&gt; {

                   if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry) {

                      progressBar1.PerformStep();

                   }

                };

                zip.Save(fs);

             }

             </code>

             </example>

             <example>

               This example uses a named method as the

               <c>SaveProgress</c> event handler, to update the user, in a

               console-based application.

             <code lang="C#">

             static bool justHadByteUpdate= false;

             public static void SaveProgress(object sender, SaveProgressEventArgs e)

             {

                 if (e.EventType == ZipProgressEventType.Saving_Started)

                     Console.WriteLine("Saving: {0}", e.ArchiveName);

                 else if (e.EventType == ZipProgressEventType.Saving_Completed)

                 {

                     justHadByteUpdate= false;

                     Console.WriteLine();

                     Console.WriteLine("Done: {0}", e.ArchiveName);

                 }

                 else if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry)

                 {

                     if (justHadByteUpdate)

                         Console.WriteLine();

                     Console.WriteLine("  Writing: {0} ({1}/{2})",

                                       e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal);

                     justHadByteUpdate= false;

                 }

                 else if (e.EventType == ZipProgressEventType.Saving_EntryBytesRead)

                 {

                     if (justHadByteUpdate)

                         Console.SetCursorPosition(0, Console.CursorTop);

                      Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer,

                                   e.BytesTransferred / (0.01 * e.TotalBytesToTransfer ));

                     justHadByteUpdate= true;

                 }

             }

             public static ZipUp(string targetZip, string directory)

             {

               using (var zip = new ZipFile()) {

                 zip.SaveProgress += SaveProgress;

                 zip.AddDirectory(directory);

                 zip.Save(targetZip);

               }

             }

             </code>

             <code lang="VB">

             Public Sub ZipUp(ByVal targetZip As String, ByVal directory As String)

                 Using zip As ZipFile = New ZipFile

                     AddHandler zip.SaveProgress, AddressOf MySaveProgress

                     zip.AddDirectory(directory)

                     zip.Save(targetZip)

                 End Using

             End Sub

             Private Shared justHadByteUpdate As Boolean = False

             Public Shared Sub MySaveProgress(ByVal sender As Object, ByVal e As SaveProgressEventArgs)

                 If (e.EventType Is ZipProgressEventType.Saving_Started) Then

                     Console.WriteLine("Saving: {0}", e.ArchiveName)

                 ElseIf (e.EventType Is ZipProgressEventType.Saving_Completed) Then

                     justHadByteUpdate = False

                     Console.WriteLine

                     Console.WriteLine("Done: {0}", e.ArchiveName)

                 ElseIf (e.EventType Is ZipProgressEventType.Saving_BeforeWriteEntry) Then

                     If justHadByteUpdate Then

                         Console.WriteLine

                     End If

                     Console.WriteLine("  Writing: {0} ({1}/{2})", e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal)

                     justHadByteUpdate = False

                 ElseIf (e.EventType Is ZipProgressEventType.Saving_EntryBytesRead) Then

                     If justHadByteUpdate Then

                         Console.SetCursorPosition(0, Console.CursorTop)

                     End If

                     Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, _

                                   e.TotalBytesToTransfer, _

                                   (CDbl(e.BytesTransferred) / (0.01 * e.TotalBytesToTransfer)))

                     justHadByteUpdate = True

                 End If

             End Sub

             </code>

             </example>

             <example>

             This is a more complete example of using the SaveProgress

             events in a Windows Forms application, with a

             Thread object.

             <code lang="C#">

             delegate void SaveEntryProgress(SaveProgressEventArgs e);

             delegate void ButtonClick(object sender, EventArgs e);

             public class WorkerOptions

             {

                 public string ZipName;

                 public string Folder;

                 public string Encoding;

                 public string Comment;

                 public int ZipFlavor;

                 public Zip64Option Zip64;

             }

             private int _progress2MaxFactor;

             private bool _saveCanceled;

             private long _totalBytesBeforeCompress;

             private long _totalBytesAfterCompress;

             private Thread _workerThread;

             private void btnZipup_Click(object sender, EventArgs e)

             {

                 KickoffZipup();

             }

             private void btnCancel_Click(object sender, EventArgs e)

             {

                 if (this.lblStatus.InvokeRequired)

                 {

                     this.lblStatus.Invoke(new ButtonClick(this.btnCancel_Click), new object[] { sender, e });

                 }

                 else

                 {

                     _saveCanceled = true;

                     lblStatus.Text = "Canceled...";

                     ResetState();

                 }

             }

             private void KickoffZipup()

             {

                 _folderName = tbDirName.Text;

                 if (_folderName == null || _folderName == "") return;

                 if (this.tbZipName.Text == null || this.tbZipName.Text == "") return;

                 // check for existence of the zip file:

                 if (System.IO.File.Exists(this.tbZipName.Text))

                 {

                     var dlgResult = MessageBox.Show(String.Format("The file you have specified ({0}) already exists." +

                                                                   "  Do you want to overwrite this file?", this.tbZipName.Text),

                                                     "Confirmation is Required", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

                     if (dlgResult != DialogResult.Yes) return;

                     System.IO.File.Delete(this.tbZipName.Text);

                 }

                  _saveCanceled = false;

                 _nFilesCompleted = 0;

                 _totalBytesAfterCompress = 0;

                 _totalBytesBeforeCompress = 0;

                 this.btnOk.Enabled = false;

                 this.btnOk.Text = "Zipping...";

                 this.btnCancel.Enabled = true;

                 lblStatus.Text = "Zipping...";

                 var options = new WorkerOptions

                 {

                     ZipName = this.tbZipName.Text,

                     Folder = _folderName,

                     Encoding = "ibm437"

                 };

                 if (this.comboBox1.SelectedIndex != 0)

                 {

                     options.Encoding = this.comboBox1.SelectedItem.ToString();

                 }

                 if (this.radioFlavorSfxCmd.Checked)

                     options.ZipFlavor = 2;

                 else if (this.radioFlavorSfxGui.Checked)

                     options.ZipFlavor = 1;

                 else options.ZipFlavor = 0;

                 if (this.radioZip64AsNecessary.Checked)

                     options.Zip64 = Zip64Option.AsNecessary;

                 else if (this.radioZip64Always.Checked)

                     options.Zip64 = Zip64Option.Always;

                 else options.Zip64 = Zip64Option.Never;

                 options.Comment = String.Format("Encoding:{0} || Flavor:{1} || ZIP64:{2}\r\nCreated at {3} || {4}\r\n",

                             options.Encoding,

                             FlavorToString(options.ZipFlavor),

                             options.Zip64.ToString(),

                             System.DateTime.Now.ToString("yyyy-MMM-dd HH:mm:ss"),

                             this.Text);

                 if (this.tbComment.Text != TB_COMMENT_NOTE)

                     options.Comment += this.tbComment.Text;

                 _workerThread = new Thread(this.DoSave);

                 _workerThread.Name = "Zip Saver thread";

                 _workerThread.Start(options);

                 this.Cursor = Cursors.WaitCursor;

              }

             private void DoSave(Object p)

             {

                 WorkerOptions options = p as WorkerOptions;

                 try

                 {

                     using (var zip1 = new ZipFile())

                     {

                         zip1.ProvisionalAlternateEncoding = System.Text.Encoding.GetEncoding(options.Encoding);

                         zip1.Comment = options.Comment;

                         zip1.AddDirectory(options.Folder);

                         _entriesToZip = zip1.EntryFileNames.Count;

                         SetProgressBars();

                         zip1.SaveProgress += this.zip1_SaveProgress;

                         zip1.UseZip64WhenSaving = options.Zip64;

                         if (options.ZipFlavor == 1)

                             zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.WinFormsApplication);

                         else if (options.ZipFlavor == 2)

                             zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.ConsoleApplication);

                         else

                             zip1.Save(options.ZipName);

                     }

                 }

                 catch (System.Exception exc1)

                 {

                     MessageBox.Show(String.Format("Exception while zipping: {0}", exc1.Message));

                     btnCancel_Click(null, null);

                 }

             }

             void zip1_SaveProgress(object sender, SaveProgressEventArgs e)

             {

                 switch (e.EventType)

                 {

                     case ZipProgressEventType.Saving_AfterWriteEntry:

                         StepArchiveProgress(e);

                         break;

                     case ZipProgressEventType.Saving_EntryBytesRead:

                         StepEntryProgress(e);

                         break;

                     case ZipProgressEventType.Saving_Completed:

                         SaveCompleted();

                         break;

                     case ZipProgressEventType.Saving_AfterSaveTempArchive:

                         // this event only occurs when saving an SFX file

                         TempArchiveSaved();

                         break;

                 }

                 if (_saveCanceled)

                     e.Cancel = true;

             }

             private void StepArchiveProgress(SaveProgressEventArgs e)

             {

                 if (this.progressBar1.InvokeRequired)

                 {

                     this.progressBar1.Invoke(new SaveEntryProgress(this.StepArchiveProgress), new object[] { e });

                 }

                 else

                 {

                     if (!_saveCanceled)

                     {

                         _nFilesCompleted++;

                         this.progressBar1.PerformStep();

                         _totalBytesAfterCompress += e.CurrentEntry.CompressedSize;

                         _totalBytesBeforeCompress += e.CurrentEntry.UncompressedSize;

                         // reset the progress bar for the entry:

                         this.progressBar2.Value = this.progressBar2.Maximum = 1;

                         this.Update();

                     }

                 }

             }

             private void StepEntryProgress(SaveProgressEventArgs e)

             {

                 if (this.progressBar2.InvokeRequired)

                 {

                     this.progressBar2.Invoke(new SaveEntryProgress(this.StepEntryProgress), new object[] { e });

                 }

                 else

                 {

                     if (!_saveCanceled)

                     {

                         if (this.progressBar2.Maximum == 1)

                         {

                             // reset

                             Int64 max = e.TotalBytesToTransfer;

                             _progress2MaxFactor = 0;

                             while (max &gt; System.Int32.MaxValue)

                             {

                                 max /= 2;

                                 _progress2MaxFactor++;

                             }

                             this.progressBar2.Maximum = (int)max;

                             lblStatus.Text = String.Format("{0} of {1} files...({2})",

                                 _nFilesCompleted + 1, _entriesToZip, e.CurrentEntry.FileName);

                         }

                          int xferred = e.BytesTransferred &gt;&gt; _progress2MaxFactor;

                          this.progressBar2.Value = (xferred &gt;= this.progressBar2.Maximum)

                             ? this.progressBar2.Maximum

                             : xferred;

                          this.Update();

                     }

                 }

             }

             private void SaveCompleted()

             {

                 if (this.lblStatus.InvokeRequired)

                 {

                     this.lblStatus.Invoke(new MethodInvoker(this.SaveCompleted));

                 }

                 else

                 {

                     lblStatus.Text = String.Format("Done, Compressed {0} files, {1:N0}% of original.",

                         _nFilesCompleted, (100.00 * _totalBytesAfterCompress) / _totalBytesBeforeCompress);

                      ResetState();

                 }

             }

             private void ResetState()

             {

                 this.btnCancel.Enabled = false;

                 this.btnOk.Enabled = true;

                 this.btnOk.Text = "Zip it!";

                 this.progressBar1.Value = 0;

                 this.progressBar2.Value = 0;

                 this.Cursor = Cursors.Default;

                 if (!_workerThread.IsAlive)

                     _workerThread.Join();

             }

             </code>

             </example>

             <seealso cref="E:Ionic.Zip.ZipFile.ReadProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.AddProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ExtractProgress"/>

        </member>

        <member name="E:Ionic.Zip.ZipFile.ReadProgress">

             <summary>

             An event handler invoked before, during, and after the reading of a zip archive.

             </summary>

             <remarks>

             <para>

             Depending on the particular event being signaled, different properties on the

             <see cref="T:Ionic.Zip.ReadProgressEventArgs"/> parameter are set.  The following table

             summarizes the available EventTypes and the conditions under which this

             event handler is invoked with a <c>ReadProgressEventArgs</c> with the given EventType.

             </para>

             <list type="table">

             <listheader>

             <term>value of EntryType</term>

             <description>Meaning and conditions</description>

             </listheader>

             <item>

             <term>ZipProgressEventType.Reading_Started</term>

             <description>Fired just as ZipFile.Read() begins. Meaningful properties: ArchiveName.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Reading_Completed</term>

             <description>Fired when ZipFile.Read() has completed. Meaningful properties: ArchiveName.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Reading_ArchiveBytesRead</term>

             <description>Fired while reading, updates the number of bytes read for the entire archive.

             Meaningful properties: ArchiveName, CurrentEntry, BytesTransferred, TotalBytesToTransfer.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Reading_BeforeReadEntry</term>

             <description>Indicates an entry is about to be read from the archive.

             Meaningful properties: ArchiveName, EntriesTotal.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Reading_AfterReadEntry</term>

             <description>Indicates an entry has just been read from the archive.

             Meaningful properties: ArchiveName, EntriesTotal, CurrentEntry.

             </description>

             </item>

             </list>

             </remarks>

             <seealso cref="E:Ionic.Zip.ZipFile.SaveProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.AddProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ExtractProgress"/>

        </member>

        <member name="E:Ionic.Zip.ZipFile.ExtractProgress">

             <summary>

               An event handler invoked before, during, and after extraction of

               entries in the zip archive.

             </summary>

             <remarks>

             <para>

               Depending on the particular event, different properties on the <see cref="T:Ionic.Zip.ExtractProgressEventArgs"/> parameter are set.  The following

               table summarizes the available EventTypes and the conditions under

               which this event handler is invoked with a

               <c>ExtractProgressEventArgs</c> with the given EventType.

             </para>

             <list type="table">

             <listheader>

             <term>value of EntryType</term>

             <description>Meaning and conditions</description>

             </listheader>

             <item>

             <term>ZipProgressEventType.Extracting_BeforeExtractAll</term>

             <description>

               Set when ExtractAll() begins. The ArchiveName, Overwrite, and

               ExtractLocation properties are meaningful.</description>

             </item>

             <item>

             <term>ZipProgressEventType.Extracting_AfterExtractAll</term>

             <description>

               Set when ExtractAll() has completed.  The ArchiveName, Overwrite,

               and ExtractLocation properties are meaningful.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Extracting_BeforeExtractEntry</term>

             <description>

               Set when an Extract() on an entry in the ZipFile has begun.

               Properties that are meaningful: ArchiveName, EntriesTotal,

               CurrentEntry, Overwrite, ExtractLocation, EntriesExtracted.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Extracting_AfterExtractEntry</term>

             <description>

               Set when an Extract() on an entry in the ZipFile has completed.

               Properties that are meaningful: ArchiveName, EntriesTotal,

               CurrentEntry, Overwrite, ExtractLocation, EntriesExtracted.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Extracting_EntryBytesWritten</term>

             <description>

               Set within a call to Extract() on an entry in the ZipFile, as data

               is extracted for the entry.  Properties that are meaningful:

               ArchiveName, CurrentEntry, BytesTransferred, TotalBytesToTransfer.

             </description>

             </item>

             <item>

             <term>ZipProgressEventType.Extracting_ExtractEntryWouldOverwrite</term>

             <description>

               Set within a call to Extract() on an entry in the ZipFile, when the

               extraction would overwrite an existing file. This event type is used

               only when <c>ExtractExistingFileAction</c> on the <c>ZipFile</c> or

               <c>ZipEntry</c> is set to <c>InvokeExtractProgressEvent</c>.

             </description>

             </item>

             </list>

             </remarks>

             <example>

             <code>

             private static bool justHadByteUpdate = false;

             public static void ExtractProgress(object sender, ExtractProgressEventArgs e)

             {

               if(e.EventType == ZipProgressEventType.Extracting_EntryBytesWritten)

               {

                 if (justHadByteUpdate)

                   Console.SetCursorPosition(0, Console.CursorTop);

                 Console.Write("   {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer,

                               e.BytesTransferred / (0.01 * e.TotalBytesToTransfer ));

                 justHadByteUpdate = true;

               }

               else if(e.EventType == ZipProgressEventType.Extracting_BeforeExtractEntry)

               {

                 if (justHadByteUpdate)

                   Console.WriteLine();

                 Console.WriteLine("Extracting: {0}", e.CurrentEntry.FileName);

                 justHadByteUpdate= false;

               }

             }

             public static ExtractZip(string zipToExtract, string directory)

             {

               string TargetDirectory= "extract";

               using (var zip = ZipFile.Read(zipToExtract)) {

                 zip.ExtractProgress += ExtractProgress;

                 foreach (var e in zip1)

                 {

                   e.Extract(TargetDirectory, true);

                 }

               }

             }

             </code>

             <code lang="VB">

             Public Shared Sub Main(ByVal args As String())

                 Dim ZipToUnpack As String = "C1P3SML.zip"

                 Dim TargetDir As String = "ExtractTest_Extract"

                 Console.WriteLine("Extracting file {0} to {1}", ZipToUnpack, TargetDir)

                 Using zip1 As ZipFile = ZipFile.Read(ZipToUnpack)

                     AddHandler zip1.ExtractProgress, AddressOf MyExtractProgress

                     Dim e As ZipEntry

                     For Each e In zip1

                         e.Extract(TargetDir, True)

                     Next

                 End Using

             End Sub

             Private Shared justHadByteUpdate As Boolean = False

             Public Shared Sub MyExtractProgress(ByVal sender As Object, ByVal e As ExtractProgressEventArgs)

                 If (e.EventType = ZipProgressEventType.Extracting_EntryBytesWritten) Then

                     If ExtractTest.justHadByteUpdate Then

                         Console.SetCursorPosition(0, Console.CursorTop)

                     End If

                     Console.Write("   {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer, (CDbl(e.BytesTransferred) / (0.01 * e.TotalBytesToTransfer)))

                     ExtractTest.justHadByteUpdate = True

                 ElseIf (e.EventType = ZipProgressEventType.Extracting_BeforeExtractEntry) Then

                     If ExtractTest.justHadByteUpdate Then

                         Console.WriteLine

                     End If

                     Console.WriteLine("Extracting: {0}", e.CurrentEntry.FileName)

                     ExtractTest.justHadByteUpdate = False

                 End If

             End Sub

             </code>

             </example>

             <seealso cref="E:Ionic.Zip.ZipFile.SaveProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ReadProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.AddProgress"/>

        </member>

        <member name="E:Ionic.Zip.ZipFile.AddProgress">

             <summary>

             An event handler invoked before, during, and after Adding entries to a zip archive.

             </summary>

             <remarks>

                 Adding a large number of entries to a zip file can take a long

                 time.  For example, when calling <see cref="M:Ionic.Zip.ZipFile.AddDirectory(System.String)"/> on a

                 directory that contains 50,000 files, it could take 3 minutes or so.

                 This event handler allws an application to track the progress of the Add

                 operation, and to optionally cancel a lengthy Add operation.

             </remarks>

             <example>

             <code lang="C#">

             int _numEntriesToAdd= 0;

             int _numEntriesAdded= 0;

             void AddProgressHandler(object sender, AddProgressEventArgs e)

             {

                 switch (e.EventType)

                 {

                     case ZipProgressEventType.Adding_Started:

                         Console.WriteLine("Adding files to the zip...");

                         break;

                     case ZipProgressEventType.Adding_AfterAddEntry:

                         _numEntriesAdded++;

                         Console.WriteLine(String.Format("Adding file {0}/{1} :: {2}",

                                                  _numEntriesAdded, _numEntriesToAdd, e.CurrentEntry.FileName));

                         break;

                     case ZipProgressEventType.Adding_Completed:

                         Console.WriteLine("Added all files");

                         break;

                 }

             }

             void CreateTheZip()

             {

                 using (ZipFile zip = new ZipFile())

                 {

                     zip.AddProgress += AddProgressHandler;

                     zip.AddDirectory(System.IO.Path.GetFileName(DirToZip));

                     zip.Save(ZipFileToCreate);

                 }

             }

             </code>

             <code lang="VB">

             Private Sub AddProgressHandler(ByVal sender As Object, ByVal e As AddProgressEventArgs)

                 Select Case e.EventType

                     Case ZipProgressEventType.Adding_Started

                         Console.WriteLine("Adding files to the zip...")

                         Exit Select

                     Case ZipProgressEventType.Adding_AfterAddEntry

                         Console.WriteLine(String.Format("Adding file {0}", e.CurrentEntry.FileName))

                         Exit Select

                     Case ZipProgressEventType.Adding_Completed

                         Console.WriteLine("Added all files")

                         Exit Select

                 End Select

             End Sub

             Sub CreateTheZip()

                 Using zip as ZipFile = New ZipFile

                     AddHandler zip.AddProgress, AddressOf AddProgressHandler

                     zip.AddDirectory(System.IO.Path.GetFileName(DirToZip))

                     zip.Save(ZipFileToCreate);

                 End Using

             End Sub

             </code>

             </example>

             <seealso cref="E:Ionic.Zip.ZipFile.SaveProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ReadProgress"/>

             <seealso cref="E:Ionic.Zip.ZipFile.ExtractProgress"/>

        </member>

        <member name="E:Ionic.Zip.ZipFile.ZipError">

             <summary>

             An event that is raised when an error occurs during open or read of files

             while saving a zip archive.

             </summary>

             <remarks>

              <para>

                 Errors can occur as a file is being saved to the zip archive.  For

                 example, the File.Open may fail, or a File.Read may fail, because of

                 lock conflicts or other reasons.  If you add a handler to this event,

                 you can handle such errors in your own code.  If you don't add a

                 handler, the library will throw an exception if it encounters an I/O

                 error during a call to <c>Save()</c>.

              </para>

              <para>

                Setting a handler implicitly sets <see cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/> to

                <c>ZipErrorAction.InvokeErrorEvent</c>.

              </para>

              <para>

                The handler you add applies to all <see cref="T:Ionic.Zip.ZipEntry"/> items that are

                subsequently added to the <c>ZipFile</c> instance. If you set this

                property after you have added items to the <c>ZipFile</c>, but before you

                have called <c>Save()</c>, errors that occur while saving those items

                will not cause the error handler to be invoked.

              </para>

              <para>

                If you want to handle any errors that occur with any entry in the zip

                file using the same error handler, then add your error handler once,

                before adding any entries to the zip archive.

              </para>

              <para>

                In the error handler method, you need to set the <see cref="P:Ionic.Zip.ZipEntry.ZipErrorAction"/> property on the

                <c>ZipErrorEventArgs.CurrentEntry</c>.  This communicates back to

                DotNetZip what you would like to do with this particular error.  Within

                an error handler, if you set the <c>ZipEntry.ZipErrorAction</c> property

                on the <c>ZipEntry</c> to <c>ZipErrorAction.InvokeErrorEvent</c> or if

                you don't set it at all, the library will throw the exception. (It is the

                same as if you had set the <c>ZipEntry.ZipErrorAction</c> property on the

                <c>ZipEntry</c> to <c>ZipErrorAction.Throw</c>.) If you set the

                <c>ZipErrorEventArgs.Cancel</c> to true, the entire <c>Save()</c> will be

                canceled.

              </para>

              <para>

                In the case that you use <c>ZipErrorAction.Skip</c>, implying that

                you want to skip the entry for which there's been an error, DotNetZip

                tries to seek backwards in the output stream, and truncate all bytes

                written on behalf of that particular entry. This works only if the

                output stream is seekable.  It will not work, for example, when using

                ASPNET's Response.OutputStream.

              </para>

             </remarks>

             <example>

             This example shows how to use an event handler to handle

             errors during save of the zip file.

             <code lang="C#">

             public static void MyZipError(object sender, ZipErrorEventArgs e)

             {

                 Console.WriteLine("Error saving {0}...", e.FileName);

                 Console.WriteLine("   Exception: {0}", e.exception);

                 ZipEntry entry = e.CurrentEntry;

                 string response = null;

                 // Ask the user whether he wants to skip this error or not

                 do

                 {

                     Console.Write("Retry, Skip, Throw, or Cancel ? (R/S/T/C) ");

                     response = Console.ReadLine();

                     Console.WriteLine();

                 } while (response != null &amp;&amp;

                          response[0]!='S' &amp;&amp; response[0]!='s' &amp;&amp;

                          response[0]!='R' &amp;&amp; response[0]!='r' &amp;&amp;

                          response[0]!='T' &amp;&amp; response[0]!='t' &amp;&amp;

                          response[0]!='C' &amp;&amp; response[0]!='c');

                 e.Cancel = (response[0]=='C' || response[0]=='c');

                 if (response[0]=='S' || response[0]=='s')

                     entry.ZipErrorAction = ZipErrorAction.Skip;

                 else if (response[0]=='R' || response[0]=='r')

                     entry.ZipErrorAction = ZipErrorAction.Retry;

                 else if (response[0]=='T' || response[0]=='t')

                     entry.ZipErrorAction = ZipErrorAction.Throw;

             }

             public void SaveTheFile()

             {

               string directoryToZip = "fodder";

               string directoryInArchive = "files";

               string zipFileToCreate = "Archive.zip";

               using (var zip = new ZipFile())

               {

                 // set the event handler before adding any entries

                 zip.ZipError += MyZipError;

                 zip.AddDirectory(directoryToZip, directoryInArchive);

                 zip.Save(zipFileToCreate);

               }

             }

             </code>

             <code lang="VB">

             Private Sub MyZipError(ByVal sender As Object, ByVal e As Ionic.Zip.ZipErrorEventArgs)

                 ' At this point, the application could prompt the user for an action to take.

                 ' But in this case, this application will simply automatically skip the file, in case of error.

                 Console.WriteLine("Zip Error,  entry {0}", e.CurrentEntry.FileName)

                 Console.WriteLine("   Exception: {0}", e.exception)

                 ' set the desired ZipErrorAction on the CurrentEntry to communicate that to DotNetZip

                 e.CurrentEntry.ZipErrorAction = Zip.ZipErrorAction.Skip

             End Sub

             Public Sub SaveTheFile()

                 Dim directoryToZip As String = "fodder"

                 Dim directoryInArchive As String = "files"

                 Dim zipFileToCreate as String = "Archive.zip"

                 Using zipArchive As ZipFile = New ZipFile

                     ' set the event handler before adding any entries

                     AddHandler zipArchive.ZipError, AddressOf MyZipError

                     zipArchive.AddDirectory(directoryToZip, directoryInArchive)

                     zipArchive.Save(zipFileToCreate)

                 End Using

             End Sub

             </code>

             </example>

             <seealso cref="P:Ionic.Zip.ZipFile.ZipErrorAction"/>

        </member>

        <member name="T:Ionic.Zip.Zip64Option">

             <summary>

               Options for using ZIP64 extensions when saving zip archives.

             </summary>

             <remarks>

             <para>

               Designed many years ago, the <see href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">original zip

               specification from PKWARE</see> allowed for 32-bit quantities for the

               compressed and uncompressed sizes of zip entries, as well as a 32-bit quantity

               for specifying the length of the zip archive itself, and a maximum of 65535

               entries.  These limits are now regularly exceeded in many backup and archival

               scenarios.  Recently, PKWare added extensions to the original zip spec, called

               "ZIP64 extensions", to raise those limitations.  This property governs whether

               DotNetZip will use those extensions when writing zip archives. The use of

               these extensions is optional and explicit in DotNetZip because, despite the

               status of ZIP64 as a bona fide standard, many other zip tools and libraries do

               not support ZIP64, and therefore a zip file with ZIP64 extensions may be

               unreadable by some of those other tools.

             </para>

             <para>

               Set this property to <see cref="F:Ionic.Zip.Zip64Option.Always"/> to always use ZIP64

               extensions when saving, regardless of whether your zip archive needs it.

               Suppose you add 5 files, each under 100k, to a ZipFile. If you specify Always

               for this flag, you will get a ZIP64 archive, though the archive does not need

               to use ZIP64 because none of the original zip limits had been exceeded.

             </para>

             <para>

               Set this property to <see cref="F:Ionic.Zip.Zip64Option.Never"/> to tell the DotNetZip

               library to never use ZIP64 extensions.  This is useful for maximum

               compatibility and interoperability, at the expense of the capability of

               handling large files or large archives.  NB: Windows Explorer in Windows XP

               and Windows Vista cannot currently extract files from a zip64 archive, so if

               you want to guarantee that a zip archive produced by this library will work in

               Windows Explorer, use <c>Never</c>. If you set this property to <see cref="F:Ionic.Zip.Zip64Option.Never"/>, and your application creates a zip that would

               exceed one of the Zip limits, the library will throw an exception while saving

               the zip file.

             </para>

             <para>

               Set this property to <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> to tell the

               DotNetZip library to use the ZIP64 extensions when required by the

               entry. After the file is compressed, the original and compressed sizes are

               checked, and if they exceed the limits described above, then zip64 can be

               used. That is the general idea, but there is an additional wrinkle when saving

               to a non-seekable device, like the ASP.NET <c>Response.OutputStream</c>, or

               <c>Console.Out</c>.  When using non-seekable streams for output, the entry

               header - which indicates whether zip64 is in use - is emitted before it is

               known if zip64 is necessary.  It is only after all entries have been saved

               that it can be known if ZIP64 will be required.  On seekable output streams,

               after saving all entries, the library can seek backward and re-emit the zip

               file header to be consistent with the actual ZIP64 requirement.  But using a

               non-seekable output stream, the library cannot seek backward, so the header

               can never be changed. In other words, the archive's use of ZIP64 extensions is

               not alterable after the header is emitted.  Therefore, when saving to

               non-seekable streams, using <see cref="F:Ionic.Zip.Zip64Option.AsNecessary"/> is the same

               as using <see cref="F:Ionic.Zip.Zip64Option.Always"/>: it will always produce a zip

               archive that uses ZIP64 extensions.

             </para>

             </remarks>

        </member>

        <member name="F:Ionic.Zip.Zip64Option.Default">

            <summary>

            The default behavior, which is "Never".

            (For COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.Zip64Option.Never">

            <summary>

            Do not use ZIP64 extensions when writing zip archives.

            (For COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.Zip64Option.AsNecessary">

            <summary>

            Use ZIP64 extensions when writing zip archives, as necessary.

            For example, when a single entry exceeds 0xFFFFFFFF in size, or when the archive as a whole

            exceeds 0xFFFFFFFF in size, or when there are more than 65535 entries in an archive.

            (For COM clients, this is a 1.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.Zip64Option.Always">

            <summary>

            Always use ZIP64 extensions when writing zip archives, even when unnecessary.

            (For COM clients, this is a 2.)

            </summary>

        </member>

        <member name="T:Ionic.Zip.ZipOption">

            <summary>

             An enum representing the values on a three-way toggle switch

             for various options in the library. This might be used to

             specify whether to employ a particular text encoding, or to use

             ZIP64 extensions, or some other option.

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipOption.Default">

            <summary>

            The default behavior. This is the same as "Never".

            (For COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipOption.Never">

            <summary>

            Never use the associated option.

            (For COM clients, this is a 0 (zero).)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipOption.AsNecessary">

            <summary>

            Use the associated behavior "as necessary."

            (For COM clients, this is a 1.)

            </summary>

        </member>

        <member name="F:Ionic.Zip.ZipOption.Always">

            <summary>

            Use the associated behavior Always, whether necessary or not.

            (For COM clients, this is a 2.)

            </summary>

        </member>

        <member name="T:Ionic.Zip.ReadOptions">

             <summary>

               A class for collecting the various options that can be used when

               Reading zip files for extraction or update.

             </summary>

             <remarks>

               <para>

                 When reading a zip file, there are several options an

                 application can set, to modify how the file is read, or what

                 the library does while reading.  This class collects those

                 options into one container.

               </para>

               <para>

                 Pass an instance of the <c>ReadOptions</c> class into the

                 <c>ZipFile.Read()</c> method.

               </para>

             <seealso cref="M:Ionic.Zip.ZipFile.Read(System.String,Ionic.Zip.ReadOptions)"/>.

             <seealso cref="M:Ionic.Zip.ZipFile.Read(System.IO.Stream,Ionic.Zip.ReadOptions)"/>.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.ReadOptions.ReadProgress">

            <summary>

            An event handler for Read operations.  When opening large zip

            archives, you may want to display a progress bar or other

            indicator of status progress while reading.  This parameter

            allows you to specify a ReadProgress Event Handler directly.

            When you call <c>Read()</c>, the progress event is invoked as

            necessary.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ReadOptions.StatusMessageWriter">

            <summary>

            The <c>System.IO.TextWriter</c> to use for writing verbose status messages

            during operations on the zip archive.  A console application may wish to

            pass <c>System.Console.Out</c> to get messages on the Console. A graphical

            or headless application may wish to capture the messages in a different

            <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>.

            </summary>

        </member>

        <member name="P:Ionic.Zip.ReadOptions.Encoding">

             <summary>

             The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be

             careful specifying the encoding.  If the value you use here is not the same

             as the Encoding used when the zip archive was created (possibly by a

             different archiver) you will get unexpected results and possibly exceptions.

             </summary>

             <seealso cref="P:Ionic.Zip.ZipFile.ProvisionalAlternateEncoding"/>

        </member>

        <member name="T:Ionic.Zip.SelfExtractorFlavor">

            <summary>

            An enum that provides the different self-extractor flavors

            </summary>

        </member>

        <member name="F:Ionic.Zip.SelfExtractorFlavor.ConsoleApplication">

            <summary>

            A self-extracting zip archive that runs from the console or

            command line.

            </summary>

        </member>

        <member name="F:Ionic.Zip.SelfExtractorFlavor.WinFormsApplication">

            <summary>

            A self-extracting zip archive that presents a graphical user

            interface when it is executed.

            </summary>

        </member>

        <member name="T:Ionic.Zip.SelfExtractorSaveOptions">

            <summary>

            The options for generating a self-extracting archive.

            </summary>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.Flavor">

            <summary>

              The type of SFX to create.

            </summary>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.PostExtractCommandLine">

             <summary>

               The command to run after extraction.

             </summary>

             <remarks>

             <para>

               This is optional. Leave it empty (<c>null</c> in C# or <c>Nothing</c> in

               VB) to run no command after extraction.

             </para>

             <para>

               If it is non-empty, the SFX will execute the command specified in this

               string on the user's machine, and using the extract directory as the

               working directory for the process, after unpacking the archive. The

               program to execute can include a path, if you like. If you want to execute

               a program that accepts arguments, specify the program name, followed by a

               space, and then the arguments for the program, each separated by a space,

               just as you would on a normal command line. Example: <c>program.exe arg1

               arg2</c>.  The string prior to the first space will be taken as the

               program name, and the string following the first space specifies the

               arguments to the program.

             </para>

             <para>

               If you want to execute a program that has a space in the name or path of

               the file, surround the program name in double-quotes. The first character

               of the command line should be a double-quote character, and there must be

               a matching double-quote following the end of the program file name. Any

               optional arguments to the program follow that, separated by

               spaces. Example: <c>"c:\project files\program name.exe" arg1 arg2</c>.

             </para>

             <para>

               If the flavor of the SFX is <c>SelfExtractorFlavor.ConsoleApplication</c>,

               then the SFX starts a new process, using this string as the post-extract

               command line.  The SFX waits for the process to exit.  The exit code of

               the post-extract command line is returned as the exit code of the

               command-line self-extractor exe. A non-zero exit code is typically used to

               indicated a failure by the program. In the case of an SFX, a non-zero exit

               code may indicate a failure during extraction, OR, it may indicate a

               failure of the run-after-extract program if specified, OR, it may indicate

               the run-after-extract program could not be fuond. There is no way to

               distinguish these conditions from the calling shell, aside from parsing

               the output of the SFX. If you have Quiet set to <c>true</c>, you may not

               see error messages, if a problem occurs.

             </para>

             <para>

               If the flavor of the SFX is

               <c>SelfExtractorFlavor.WinFormsApplication</c>, then the SFX starts a new

               process, using this string as the post-extract command line, and using the

               extract directory as the working directory for the process. The SFX does

               not wait for the command to complete, and does not check the exit code of

               the program. If the run-after-extract program cannot be fuond, a message

               box is displayed indicating that fact.

             </para>

             <para>

               You can specify environment variables within this string, with a format like

               <c>%NAME%</c>. The value of these variables will be expanded at the time

               the SFX is run. Example: <c>%WINDIR%\system32\xcopy.exe</c> may expand at

               runtime to <c>c:\Windows\System32\xcopy.exe</c>.

             </para>

             <para>

               By combining this with the <c>RemoveUnpackedFilesAfterExecute</c>

               flag, you can create an SFX that extracts itself, runs a file that

               was extracted, then deletes all the files that were extracted. If

               you want it to run "invisibly" then set <c>Flavor</c> to

               <c>SelfExtractorFlavor.ConsoleApplication</c>, and set <c>Quiet</c>

               to true.  The user running such an EXE will see a console window

               appear, then disappear quickly.  You may also want to specify the

               default extract location, with <c>DefaultExtractDirectory</c>.

             </para>

             <para>

               If you set <c>Flavor</c> to

               <c>SelfExtractorFlavor.WinFormsApplication</c>, and set <c>Quiet</c> to

               true, then a GUI with progressbars is displayed, but it is

               "non-interactive" - it accepts no input from the user.  Instead the SFX

               just automatically unpacks and exits.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.DefaultExtractDirectory">

             <summary>

               The default extract directory the user will see when

               running the self-extracting archive.

             </summary>

             <remarks>

             <para>

               Passing null (or Nothing in VB) here will cause the Self Extractor to use

               the the user's personal directory (<see cref="F:System.Environment.SpecialFolder.Personal"/>) for the default extract

               location.

             </para>

             <para>

               This is only a default location.  The actual extract location will be

               settable on the command line when the SFX is executed.

             </para>

             <para>

               You can specify environment variables within this string,

               with <c>%NAME%</c>. The value of these variables will be

               expanded at the time the SFX is run. Example:

               <c>%USERPROFILE%\Documents\unpack</c> may expand at runtime to

               <c>c:\users\melvin\Documents\unpack</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.IconFile">

             <summary>

               The name of an .ico file in the filesystem to use for the application icon

               for the generated SFX.

             </summary>

             <remarks>

             <para>

               Normally, DotNetZip will embed an "zipped folder" icon into the generated

               SFX.  If you prefer to use a different icon, you can specify it here. It

               should be a .ico file.  This file is passed as the <c>/win32icon</c>

               option to the csc.exe compiler when constructing the SFX file.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.Quiet">

             <summary>

               Whether the ConsoleApplication SFX will be quiet during extraction.

             </summary>

             <remarks>

             <para>

               This option affects the way the generated SFX runs. By default it is

               false.  When you set it to true,...

             </para>

             <list type="table">

               <listheader>

                 <term>Flavor</term>

                 <description>Behavior</description>

               </listheader>

             <item>

               <term><c>ConsoleApplication</c></term>

               <description><para>no messages will be emitted during successful

                 operation.</para> <para> Double-clicking the SFX in Windows

                 Explorer or as an attachment in an email will cause a console

                 window to appear briefly, before it disappears. If you run the

                 ConsoleApplication SFX from the cmd.exe prompt, it runs as a

                 normal console app; by default, because it is quiet, it displays

                 no messages to the console.  If you pass the -v+ command line

                 argument to the Console SFX when you run it, you will get verbose

                 messages to the console. </para>

               </description>

             </item>

             <item>

               <term><c>WinFormsApplication</c></term>

               <description>the SFX extracts automatically when the application

                    is launched, with no additional user input.

               </description>

             </item>

             </list>

             <para>

               When you set it to false,...

             </para>

             <list type="table">

               <listheader>

                 <term>Flavor</term>

                 <description>Behavior</description>

               </listheader>

             <item>

               <term><c>ConsoleApplication</c></term>

               <description><para>the extractor will emit a

                 message to the console for each entry extracted.</para>

                 <para>

                   When double-clicking to launch the SFX, the console window will

                   remain, and the SFX will emit a message for each file as it

                   extracts. The messages fly by quickly, they won't be easily

                   readable, unless the extracted files are fairly large.

                 </para>

               </description>

             </item>

             <item>

               <term><c>WinFormsApplication</c></term>

               <description>the SFX presents a forms UI and allows the user to select

                 options before extracting.

               </description>

             </item>

             </list>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.ExtractExistingFile">

            <summary>

              Specify what the self-extractor will do when extracting an entry

              would overwrite an existing file.

            </summary>

            <remarks>

            <para>

              The default behavvior is to Throw.

            </para>

            </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.RemoveUnpackedFilesAfterExecute">

             <summary>

               Whether to remove the files that have been unpacked, after executing the

               PostExtractCommandLine.

             </summary>

             <remarks>

             <para>

               If true, and if there is a <see cref="P:Ionic.Zip.SelfExtractorSaveOptions.PostExtractCommandLine">

               PostExtractCommandLine</see>, and if the command runs successfully,

               then the files that the SFX unpacked will be removed, afterwards.  If

               the command does not complete successfully (non-zero return code),

               that is interpreted as a failure, and the extracted files will not be

               removed.

             </para>

             <para>

               Setting this flag, and setting <c>Flavor</c> to

               <c>SelfExtractorFlavor.ConsoleApplication</c>, and setting <c>Quiet</c> to

               true, results in an SFX that extracts itself, runs a file that was

               extracted, then deletes all the files that were extracted, with no

               intervention by the user.  You may also want to specify the default

               extract location, with <c>DefaultExtractDirectory</c>.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.FileVersion">

             <summary>

               The file version number to embed into the generated EXE. It will show up, for

               example, during a mouseover in Windows Explorer.

             </summary>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.ProductVersion">

             <summary>

               The product version to embed into the generated EXE. It will show up, for

               example, during a mouseover in Windows Explorer.

             </summary>

             <remarks>

               You can use any arbitrary string, but a human-readable version number is

               recommended. For example "v1.2 alpha" or "v4.2 RC2".  If you specify nothing,

               then there is no product version embedded into the EXE.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.Copyright">

             <summary>

               The copyright notice, if any, to embed into the generated EXE.

             </summary>

             <remarks>

               It will show up, for example, while viewing properties of the file in

               Windows Explorer.  You can use any arbitrary string, but typically you

               want something like "Copyright © Dino Chiesa 2011".

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.Description">

             <summary>

               The description to embed into the generated EXE.

             </summary>

             <remarks>

               Use any arbitrary string.  This text will be displayed during a

               mouseover in Windows Explorer.  If you specify nothing, then the string

               "DotNetZip SFX Archive" is embedded into the EXE as the description.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.ProductName">

             <summary>

               The product name to embed into the generated EXE.

             </summary>

             <remarks>

               Use any arbitrary string. This text will be displayed

               while viewing properties of the EXE file in

               Windows Explorer.

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.SfxExeWindowTitle">

             <summary>

               The title to display in the Window of a GUI SFX, while it extracts.

             </summary>

             <remarks>

               <para>

                 By default the title show in the GUI window of a self-extractor

                 is "DotNetZip Self-extractor (http://DotNetZip.codeplex.com/)".

                 You can change that by setting this property before saving the SFX.

               </para>

               <para>

                 This property has an effect only when producing a Self-extractor

                 of flavor <c>SelfExtractorFlavor.WinFormsApplication</c>.

               </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zip.SelfExtractorSaveOptions.AdditionalCompilerSwitches">

            <summary>

              Additional options for the csc.exe compiler, when producing the SFX

              EXE.

            </summary>

            <exclude/>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.Reset">

            <summary>

              Reset the BitWriter.

            </summary>

            <remarks>

              <para>

                This is useful when the BitWriter writes into a MemoryStream, and

                is used by a BZip2Compressor, which itself is re-used for multiple

                distinct data blocks.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.WriteBits(System.Int32,System.UInt32)">

            <summary>

              Write some number of bits from the given value, into the output.

            </summary>

            <remarks>

              <para>

                The nbits value should be a max of 25, for safety. For performance

                reasons, this method does not check!

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.WriteByte(System.Byte)">

            <summary>

              Write a full 8-bit byte into the output.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.WriteInt(System.UInt32)">

            <summary>

              Write four 8-bit bytes into the output.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.Flush">

            <summary>

              Write all available byte-aligned bytes.

            </summary>

            <remarks>

              <para>

                This method writes no new output, but flushes any accumulated

                bits. At completion, the accumulator may contain up to 7

                bits.

              </para>

              <para>

                This is necessary when re-assembling output from N independent

                compressors, one for each of N blocks. The output of any

                particular compressor will in general have some fragment of a byte

                remaining. This fragment needs to be accumulated into the

                parent BZip2OutputStream.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BitWriter.FinishAndPad">

            <summary>

              Writes all available bytes, and emits padding for the final byte as

              necessary. This must be the last method invoked on an instance of

              BitWriter.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.BitWriter.RemainingBits">

            <summary>

              Delivers the remaining bits, left-aligned, in a byte.

            </summary>

            <remarks>

              <para>

                This is valid only if NumRemainingBits is less than 8;

                in other words it is valid only after a call to Flush().

              </para>

            </remarks>

        </member>

        <member name="F:Ionic.BZip2.BZip2Compressor.increments">

            Knuth's increments seem to work better than Incerpi-Sedgewick here.

            Possibly because the number of elems to sort is usually small, typically

            &lt;= 20.

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.#ctor(Ionic.BZip2.BitWriter)">

            <summary>

              BZip2Compressor writes its compressed data out via a BitWriter. This

              is necessary because BZip2 does byte shredding.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.Fill(System.Byte[],System.Int32,System.Int32)">

            <summary>

              Accept new bytes into the compressor data buffer

            </summary>

            <remarks>

              <para>

                This method does the first-level (cheap) run-length encoding, and

                stores the encoded data into the rle block.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.write0(System.Byte)">

             <summary>

               Process one input byte into the block.

             </summary>

             <remarks>

               <para>

                 To "process" the byte means to do the run-length encoding.

                 There are 3 possible return values:

                    0 - the byte was not written, in other words, not

                        encoded into the block. This happens when the

                        byte b would require the start of a new run, and

                        the block has no more room for new runs.

                    1 - the byte was written, and the block is not full.

                    2 - the byte was written, and the block is full.

               </para>

             </remarks>

             <returns>0 if the byte was not written, non-zero if written.</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.AddRunToOutputBlock(System.Boolean)">

             <summary>

               Append one run to the output block.

             </summary>

             <remarks>

               <para>

                 This compressor does run-length-encoding before BWT and etc. This

                 method simply appends a run to the output block. The append always

                 succeeds. The return value indicates whether the block is full:

                 false (not full) implies that at least one additional run could be

                 processed.

               </para>

             </remarks>

             <returns>true if the block is now full; otherwise false.</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.CompressAndWrite">

            <summary>

              Compress the data that has been placed (Run-length-encoded) into the

              block. The compressed data goes into the CompressedBytes array.

            </summary>

            <remarks>

              <para>

                Side effects: 1.  fills the CompressedBytes array.  2. sets the

                AvailableBytesOut property.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.mainSimpleSort(Ionic.BZip2.BZip2Compressor.CompressionState,System.Int32,System.Int32,System.Int32)">

             This is the most hammered method of this class.

             <p>

             This is the version using unrolled loops.

             </p>

        </member>

        <member name="M:Ionic.BZip2.BZip2Compressor.mainQSort3(Ionic.BZip2.BZip2Compressor.CompressionState,System.Int32,System.Int32,System.Int32)">

            Method "mainQSort3", file "blocksort.c", BZip2 1.0.2

        </member>

        <member name="P:Ionic.BZip2.BZip2Compressor.UncompressedBytes">

            <summary>

              The number of uncompressed bytes being held in the buffer.

            </summary>

            <remarks>

              <para>

                I am thinking this may be useful in a Stream that uses this

                compressor class. In the Close() method on the stream it could

                check this value to see if anything has been written at all.  You

                may think the stream could easily track the number of bytes it

                wrote, which would eliminate the need for this. But, there is the

                case where the stream writes a complete block, and it is full, and

                then writes no more. In that case the stream may want to check.

              </para>

            </remarks>

        </member>

        <member name="F:Ionic.BZip2.BZip2Compressor.CompressionState.quadrant">

            Array instance identical to sfmap, both are used only

            temporarily and independently, so we do not need to allocate

            additional memory.

        </member>

        <member name="T:Ionic.BZip2.BZip2InputStream">

            <summary>

              A read-only decorator stream that performs BZip2 decompression on Read.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.#ctor(System.IO.Stream)">

            <summary>

              Create a BZip2InputStream, wrapping it around the given input Stream.

            </summary>

            <remarks>

              <para>

                The input stream will be closed when the BZip2InputStream is closed.

              </para>

            </remarks>

            <param name='input'>The stream from which to read compressed data</param>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.#ctor(System.IO.Stream,System.Boolean)">

             <summary>

               Create a BZip2InputStream with the given stream, and

               specifying whether to leave the wrapped stream open when

               the BZip2InputStream is closed.

             </summary>

             <param name='input'>The stream from which to read compressed data</param>

             <param name='leaveOpen'>

               Whether to leave the input stream open, when the BZip2InputStream closes.

             </param>

             <example>

               This example reads a bzip2-compressed file, decompresses it,

               and writes the decompressed data into a newly created file.

               <code>

               var fname = "logfile.log.bz2";

               using (var fs = File.OpenRead(fname))

               {

                   using (var decompressor = new Ionic.BZip2.BZip2InputStream(fs))

                   {

                       var outFname = fname + ".decompressed";

                       using (var output = File.Create(outFname))

                       {

                           byte[] buffer = new byte[2048];

                           int n;

                           while ((n = decompressor.Read(buffer, 0, buffer.Length)) > 0)

                           {

                               output.Write(buffer, 0, n);

                           }

                       }

                   }

               }

               </code>

             </example>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Read(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Read data from the stream.

             </summary>

             <remarks>

               <para>

                 To decompress a BZip2 data stream, create a <c>BZip2InputStream</c>,

                 providing a stream that reads compressed data.  Then call Read() on

                 that <c>BZip2InputStream</c>, and the data read will be decompressed

                 as you read.

               </para>

               <para>

                 A <c>BZip2InputStream</c> can be used only for <c>Read()</c>, not for <c>Write()</c>.

               </para>

             </remarks>

             <param name="buffer">The buffer into which the read data should be placed.</param>

             <param name="offset">the offset within that data array to put the first byte read.</param>

             <param name="count">the number of bytes to read.</param>

             <returns>the number of bytes actually read</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.ReadByte">

            <summary>

              Read a single byte from the stream.

            </summary>

            <returns>the byte read from the stream, or -1 if EOF</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="offset">this is irrelevant, since it will always throw!</param>

            <param name="origin">this is irrelevant, since it will always throw!</param>

            <returns>irrelevant!</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.SetLength(System.Int64)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="value">this is irrelevant, since it will always throw!</param>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Write(System.Byte[],System.Int32,System.Int32)">

            <summary>

              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="buffer">this parameter is never used</param>

            <param name="offset">this parameter is never used</param>

            <param name="count">this parameter is never used</param>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Dispose(System.Boolean)">

            <summary>

              Dispose the stream.

            </summary>

            <param name="disposing">

              indicates whether the Dispose method was invoked by user code.

            </param>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.Close">

            <summary>

              Close the stream.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.GetBits(System.Int32)">

            <summary>

              Read n bits from input, right justifying the result.

            </summary>

            <remarks>

              <para>

                For example, if you read 1 bit, the result is either 0

                or 1.

              </para>

            </remarks>

            <param name ="n">

              The number of bits to read, always between 1 and 32.

            </param>

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.hbCreateDecodeTables(System.Int32[],System.Int32[],System.Int32[],System.Char[],System.Int32,System.Int32,System.Int32)">

            Called by createHuffmanDecodingTables() exclusively.

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.createHuffmanDecodingTables(System.Int32,System.Int32)">

            Called by recvDecodingTables() exclusively.

        </member>

        <member name="P:Ionic.BZip2.BZip2InputStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports reading.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2InputStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2InputStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports writing.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2InputStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.BZip2InputStream.Position">

             <summary>

             The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotImplementedException"/>. Reading will return the

               total number of uncompressed bytes read in.

             </remarks>

        </member>

        <member name="T:Ionic.BZip2.BZip2InputStream.CState">

            <summary>

              Compressor State

            </summary>

        </member>

        <member name="F:Ionic.BZip2.BZip2InputStream.DecompressionState.unzftab">

            Freq table collected to save a pass over the data during

            decompression.

        </member>

        <member name="M:Ionic.BZip2.BZip2InputStream.DecompressionState.initTT(System.Int32)">

             Initializes the tt array.

             This method is called when the required length of the array is known.

             I don't initialize it at construction time to avoid unneccessary

             memory allocation when compressing small files.

        </member>

        <member name="T:Ionic.BZip2.BZip2OutputStream">

            <summary>

              A write-only decorator stream that compresses data as it is

              written using the BZip2 algorithm.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.#ctor(System.IO.Stream)">

             <summary>

               Constructs a new <c>BZip2OutputStream</c>, that sends its

               compressed output to the given output stream.

             </summary>

             <param name='output'>

               The destination stream, to which compressed output will be sent.

             </param>

             <example>

               This example reads a file, then compresses it with bzip2 file,

               and writes the compressed data into a newly created file.

               <code>

               var fname = "logfile.log";

               using (var fs = File.OpenRead(fname))

               {

                   var outFname = fname + ".bz2";

                   using (var output = File.Create(outFname))

                   {

                       using (var compressor = new Ionic.BZip2.BZip2OutputStream(output))

                       {

                           byte[] buffer = new byte[2048];

                           int n;

                           while ((n = fs.Read(buffer, 0, buffer.Length)) > 0)

                           {

                               compressor.Write(buffer, 0, n);

                           }

                       }

                   }

               }

               </code>

             </example>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.#ctor(System.IO.Stream,System.Int32)">

            <summary>

              Constructs a new <c>BZip2OutputStream</c> with specified blocksize.

            </summary>

            <param name = "output">the destination stream.</param>

            <param name = "blockSize">

              The blockSize in units of 100000 bytes.

              The valid range is 1..9.

            </param>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.#ctor(System.IO.Stream,System.Boolean)">

            <summary>

              Constructs a new <c>BZip2OutputStream</c>.

            </summary>

              <param name = "output">the destination stream.</param>

            <param name = "leaveOpen">

              whether to leave the captive stream open upon closing this stream.

            </param>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.#ctor(System.IO.Stream,System.Int32,System.Boolean)">

             <summary>

               Constructs a new <c>BZip2OutputStream</c> with specified blocksize,

               and explicitly specifies whether to leave the wrapped stream open.

             </summary>

             <param name = "output">the destination stream.</param>

             <param name = "blockSize">

               The blockSize in units of 100000 bytes.

               The valid range is 1..9.

             </param>

             <param name = "leaveOpen">

               whether to leave the captive stream open upon closing this stream.

             </param>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.Close">

            <summary>

              Close the stream.

            </summary>

            <remarks>

              <para>

                This may or may not close the underlying stream.  Check the

                constructors that accept a bool value.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.Flush">

            <summary>

              Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write data to the stream.

             </summary>

             <remarks>

             <para>

               Use the <c>BZip2OutputStream</c> to compress data while writing:

               create a <c>BZip2OutputStream</c> with a writable output stream.

               Then call <c>Write()</c> on that <c>BZip2OutputStream</c>, providing

               uncompressed data as input.  The data sent to the output stream will

               be the compressed form of the input data.

             </para>

             <para>

               A <c>BZip2OutputStream</c> can be used only for <c>Write()</c> not for <c>Read()</c>.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="offset">this is irrelevant, since it will always throw!</param>

            <param name="origin">this is irrelevant, since it will always throw!</param>

            <returns>irrelevant!</returns>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.SetLength(System.Int64)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="value">this is irrelevant, since it will always throw!</param>

        </member>

        <member name="M:Ionic.BZip2.BZip2OutputStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="buffer">this parameter is never used</param>

            <param name="offset">this parameter is never used</param>

            <param name="count">this parameter is never used</param>

            <returns>never returns anything; always throws</returns>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.BlockSize">

            <summary>

              The blocksize parameter specified at construction time.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value is always false.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value should always be true, unless and until the

            object is disposed and closed.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.BZip2OutputStream.Position">

             <summary>

             The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotImplementedException"/>. Reading will return the

               total number of uncompressed bytes written through.

             </remarks>

        </member>

        <member name="T:Ionic.BZip2.ParallelBZip2OutputStream">

             <summary>

               A write-only decorator stream that compresses data as it is

               written using the BZip2 algorithm. This stream compresses by

               block using multiple threads.

             </summary>

             <para>

               This class performs BZIP2 compression through writing.  For

               more information on the BZIP2 algorithm, see

               <see href="http://en.wikipedia.org/wiki/BZIP2"/>.

             </para>

             <para>

               This class is similar to <see cref="T:Ionic.BZip2.BZip2OutputStream"/>,

               except that this implementation uses an approach that employs multiple

               worker threads to perform the compression.  On a multi-cpu or multi-core

               computer, the performance of this class can be significantly higher than

               the single-threaded BZip2OutputStream, particularly for larger streams.

               How large?  Anything over 10mb is a good candidate for parallel

               compression.

             </para>

             <para>

               The tradeoff is that this class uses more memory and more CPU than the

               vanilla <c>BZip2OutputStream</c>. Also, for small files, the

               <c>ParallelBZip2OutputStream</c> can be much slower than the vanilla

               <c>BZip2OutputStream</c>, because of the overhead associated to using the

               thread pool.

             </para>

             <seealso cref="T:Ionic.BZip2.BZip2OutputStream"/>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.#ctor(System.IO.Stream)">

             <summary>

               Constructs a new <c>ParallelBZip2OutputStream</c>, that sends its

               compressed output to the given output stream.

             </summary>

             <param name='output'>

               The destination stream, to which compressed output will be sent.

             </param>

             <example>

               This example reads a file, then compresses it with bzip2 file,

               and writes the compressed data into a newly created file.

               <code>

               var fname = "logfile.log";

               using (var fs = File.OpenRead(fname))

               {

                   var outFname = fname + ".bz2";

                   using (var output = File.Create(outFname))

                   {

                       using (var compressor = new Ionic.BZip2.ParallelBZip2OutputStream(output))

                       {

                           byte[] buffer = new byte[2048];

                           int n;

                           while ((n = fs.Read(buffer, 0, buffer.Length)) > 0)

                           {

                               compressor.Write(buffer, 0, n);

                           }

                       }

                   }

               }

               </code>

             </example>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.#ctor(System.IO.Stream,System.Int32)">

            <summary>

              Constructs a new <c>ParallelBZip2OutputStream</c> with specified blocksize.

            </summary>

            <param name = "output">the destination stream.</param>

            <param name = "blockSize">

              The blockSize in units of 100000 bytes.

              The valid range is 1..9.

            </param>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.#ctor(System.IO.Stream,System.Boolean)">

            <summary>

              Constructs a new <c>ParallelBZip2OutputStream</c>.

            </summary>

              <param name = "output">the destination stream.</param>

            <param name = "leaveOpen">

              whether to leave the captive stream open upon closing this stream.

            </param>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.#ctor(System.IO.Stream,System.Int32,System.Boolean)">

             <summary>

               Constructs a new <c>ParallelBZip2OutputStream</c> with specified blocksize,

               and explicitly specifies whether to leave the wrapped stream open.

             </summary>

             <param name = "output">the destination stream.</param>

             <param name = "blockSize">

               The blockSize in units of 100000 bytes.

               The valid range is 1..9.

             </param>

             <param name = "leaveOpen">

               whether to leave the captive stream open upon closing this stream.

             </param>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.Close">

            <summary>

              Close the stream.

            </summary>

            <remarks>

              <para>

                This may or may not close the underlying stream.  Check the

                constructors that accept a bool value.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.Flush">

            <summary>

              Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write data to the stream.

             </summary>

             <remarks>

             <para>

               Use the <c>ParallelBZip2OutputStream</c> to compress data while

               writing: create a <c>ParallelBZip2OutputStream</c> with a writable

               output stream.  Then call <c>Write()</c> on that

               <c>ParallelBZip2OutputStream</c>, providing uncompressed data as

               input.  The data sent to the output stream will be the compressed

               form of the input data.

             </para>

             <para>

               A <c>ParallelBZip2OutputStream</c> can be used only for

               <c>Write()</c> not for <c>Read()</c>.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="offset">this is irrelevant, since it will always throw!</param>

            <param name="origin">this is irrelevant, since it will always throw!</param>

            <returns>irrelevant!</returns>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.SetLength(System.Int64)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="value">this is irrelevant, since it will always throw!</param>

        </member>

        <member name="M:Ionic.BZip2.ParallelBZip2OutputStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="buffer">this parameter is never used</param>

            <param name="offset">this parameter is never used</param>

            <param name="count">this parameter is never used</param>

            <returns>never returns anything; always throws</returns>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.MaxWorkers">

             <summary>

               The maximum number of concurrent compression worker threads to use.

             </summary>

             <remarks>

             <para>

               This property sets an upper limit on the number of concurrent worker

               threads to employ for compression. The implementation of this stream

               employs multiple threads from the .NET thread pool, via <see cref="M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback)">

               ThreadPool.QueueUserWorkItem()</see>, to compress the incoming data by

               block.  As each block of data is compressed, this stream re-orders the

               compressed blocks and writes them to the output stream.

             </para>

             <para>

               A higher number of workers enables a higher degree of

               parallelism, which tends to increase the speed of compression on

               multi-cpu computers.  On the other hand, a higher number of buffer

               pairs also implies a larger memory consumption, more active worker

               threads, and a higher cpu utilization for any compression. This

               property enables the application to limit its memory consumption and

               CPU utilization behavior depending on requirements.

             </para>

             <para>

               By default, DotNetZip allocates 4 workers per CPU core, subject to the

               upper limit specified in this property. For example, suppose the

               application sets this property to 16.  Then, on a machine with 2

               cores, DotNetZip will use 8 workers; that number does not exceed the

               upper limit specified by this property, so the actual number of

               workers used will be 4 * 2 = 8.  On a machine with 4 cores, DotNetZip

               will use 16 workers; again, the limit does not apply. On a machine

               with 8 cores, DotNetZip will use 16 workers, because of the limit.

             </para>

             <para>

               For each compression "worker thread" that occurs in parallel, there is

               up to 2mb of memory allocated, for buffering and processing. The

               actual number depends on the <see cref="P:Ionic.BZip2.ParallelBZip2OutputStream.BlockSize"/> property.

             </para>

             <para>

               CPU utilization will also go up with additional workers, because a

               larger number of buffer pairs allows a larger number of background

               threads to compress in parallel. If you find that parallel

               compression is consuming too much memory or CPU, you can adjust this

               value downward.

             </para>

             <para>

               The default value is 16. Different values may deliver better or

               worse results, depending on your priorities and the dynamic

               performance characteristics of your storage and compute resources.

             </para>

             <para>

               The application can set this value at any time, but it is effective

               only before the first call to Write(), which is when the buffers are

               allocated.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.BlockSize">

            <summary>

              The blocksize parameter specified at construction time.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value is always false.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports writing.

            </remarks>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.Position">

             <summary>

             The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotImplementedException"/>. Reading will return the

               total number of uncompressed bytes written through.

             </remarks>

        </member>

        <member name="P:Ionic.BZip2.ParallelBZip2OutputStream.BytesWrittenOut">

            <summary>

            The total number of bytes written out by the stream.

            </summary>

            <remarks>

            This value is meaningful only after a call to Close().

            </remarks>

        </member>

        <member name="M:Ionic.BZip2.Rand.Rnums(System.Int32)">

            <summary>

              Returns the "random" number at a specific index.

            </summary>

            <param name='i'>the index</param>

            <returns>the random number</returns>

        </member>

        <member name="T:Ionic.Zlib.DeflateStream">

             <summary>

             A class for compressing and decompressing streams using the Deflate algorithm.

             </summary>

             <remarks>

             <para>

               The DeflateStream is a <see href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see cref="T:System.IO.Stream"/>.  It adds DEFLATE compression or decompression to any

               stream.

             </para>

             <para>

               Using this stream, applications can compress or decompress data via stream

               <c>Read</c> and <c>Write</c> operations.  Either compresssion or decompression

               can occur through either reading or writing. The compression format used is

               DEFLATE, which is documented in <see href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE

               Compressed Data Format Specification version 1.3.".

             </para>

             <para>

               This class is similar to <see cref="T:Ionic.Zlib.ZlibStream"/>, except that

               <c>ZlibStream</c> adds the <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC

               1950 - ZLIB</see> framing bytes to a compressed stream when compressing, or

               expects the RFC1950 framing bytes when decompressing. The <c>DeflateStream</c>

               does not.

             </para>

             </remarks>

             <seealso cref="T:Ionic.Zlib.ZlibStream"/>

             <seealso cref="T:Ionic.Zlib.GZipStream"/>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode)">

             <summary>

               Create a DeflateStream using the specified CompressionMode.

             </summary>

             <remarks>

               When mode is <c>CompressionMode.Compress</c>, the DeflateStream will use

               the default compression level. The "captive" stream will be closed when

               the DeflateStream is closed.

             </remarks>

             <example>

             This example uses a DeflateStream to compress data from a file, and writes

             the compressed data to another file.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))

                 {

                     using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")

                     Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel)">

             <summary>

             Create a DeflateStream using the specified CompressionMode and the specified CompressionLevel.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Decompress</c>, the level parameter is

               ignored.  The "captive" stream will be closed when the DeflateStream is

               closed.

             </para>

             </remarks>

             <example>

               This example uses a DeflateStream to compress data from a file, and writes

               the compressed data to another file.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))

                 {

                     using (Stream compressor = new DeflateStream(raw,

                                                                  CompressionMode.Compress,

                                                                  CompressionLevel.BestCompression))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n= -1;

                         while (n != 0)

                         {

                             if (n &gt; 0)

                                 compressor.Write(buffer, 0, n);

                             n= input.Read(buffer, 0, buffer.Length);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")

                     Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream to be read or written while deflating or inflating.</param>

             <param name="mode">Indicates whether the <c>DeflateStream</c> will compress or decompress.</param>

             <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,System.Boolean)">

             <summary>

               Create a <c>DeflateStream</c> using the specified

               <c>CompressionMode</c>, and explicitly specify whether the

               stream should be left open after Deflation or Inflation.

             </summary>

             <remarks>

             <para>

               This constructor allows the application to request that the captive stream

               remain open after the deflation or inflation occurs.  By default, after

               <c>Close()</c> is called on the stream, the captive stream is also

               closed. In some cases this is not desired, for example if the stream is a

               memory stream that will be re-read after compression.  Specify true for

               the <paramref name="leaveOpen"/> parameter to leave the stream open.

             </para>

             <para>

               The <c>DeflateStream</c> will use the default compression level.

             </para>

             <para>

               See the other overloads of this constructor for example code.

             </para>

             </remarks>

             <param name="stream">

               The stream which will be read or written. This is called the

               "captive" stream in other places in this documentation.

             </param>

             <param name="mode">

               Indicates whether the <c>DeflateStream</c> will compress or decompress.

             </param>

             <param name="leaveOpen">true if the application would like the stream to

             remain open after inflation/deflation.</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel,System.Boolean)">

             <summary>

               Create a <c>DeflateStream</c> using the specified <c>CompressionMode</c>

               and the specified <c>CompressionLevel</c>, and explicitly specify whether

               the stream should be left open after Deflation or Inflation.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.

             </para>

             <para>

               This constructor allows the application to request that the captive stream

               remain open after the deflation or inflation occurs.  By default, after

               <c>Close()</c> is called on the stream, the captive stream is also

               closed. In some cases this is not desired, for example if the stream is a

               <see cref="T:System.IO.MemoryStream"/> that will be re-read after

               compression.  Specify true for the <paramref name="leaveOpen"/> parameter

               to leave the stream open.

             </para>

             </remarks>

             <example>

               This example shows how to use a <c>DeflateStream</c> to compress data from

               a file, and store the compressed data into another file.

             <code>

             using (var output = System.IO.File.Create(fileToCompress + ".deflated"))

             {

                 using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

                 {

                     using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n= -1;

                         while (n != 0)

                         {

                             if (n &gt; 0)

                                 compressor.Write(buffer, 0, n);

                             n= input.Read(buffer, 0, buffer.Length);

                         }

                     }

                 }

                 // can write additional data to the output stream here

             }

             </code>

             <code lang="VB">

             Using output As FileStream = File.Create(fileToCompress &amp; ".deflated")

                 Using input As Stream = File.OpenRead(fileToCompress)

                     Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

                 ' can write additional data to the output stream here.

             End Using

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>

             <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>

             <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.Dispose(System.Boolean)">

            <summary>

              Dispose the stream.

            </summary>

            <remarks>

              <para>

                This may or may not result in a <c>Close()</c> call on the captive

                stream.  See the constructors that have a <c>leaveOpen</c> parameter

                for more information.

              </para>

              <para>

                Application code won't call this code directly.  This method may be

                invoked in two distinct scenarios.  If disposing == true, the method

                has been called directly or indirectly by a user's code, for example

                via the public Dispose() method. In this case, both managed and

                unmanaged resources can be referenced and disposed.  If disposing ==

                false, the method has been called by the runtime from inside the

                object finalizer and this method should not reference other objects;

                in that case only unmanaged resources must be referenced or

                disposed.

              </para>

            </remarks>

            <param name="disposing">

              true if the Dispose method was invoked by user code.

            </param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.Read(System.Byte[],System.Int32,System.Int32)">

             <summary>

             Read data from the stream.

             </summary>

             <remarks>

             <para>

               If you wish to use the <c>DeflateStream</c> to compress data while

               reading, you can create a <c>DeflateStream</c> with

               <c>CompressionMode.Compress</c>, providing an uncompressed data stream.

               Then call Read() on that <c>DeflateStream</c>, and the data read will be

               compressed as you read.  If you wish to use the <c>DeflateStream</c> to

               decompress data while reading, you can create a <c>DeflateStream</c> with

               <c>CompressionMode.Decompress</c>, providing a readable compressed data

               stream.  Then call Read() on that <c>DeflateStream</c>, and the data read

               will be decompressed as you read.

             </para>

             <para>

               A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.

             </para>

             </remarks>

             <param name="buffer">The buffer into which the read data should be placed.</param>

             <param name="offset">the offset within that data array to put the first byte read.</param>

             <param name="count">the number of bytes to read.</param>

             <returns>the number of bytes actually read</returns>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="offset">this is irrelevant, since it will always throw!</param>

            <param name="origin">this is irrelevant, since it will always throw!</param>

            <returns>irrelevant!</returns>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.SetLength(System.Int64)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="value">this is irrelevant, since it will always throw!</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write data to the stream.

             </summary>

             <remarks>

             <para>

               If you wish to use the <c>DeflateStream</c> to compress data while

               writing, you can create a <c>DeflateStream</c> with

               <c>CompressionMode.Compress</c>, and a writable output stream.  Then call

               <c>Write()</c> on that <c>DeflateStream</c>, providing uncompressed data

               as input.  The data sent to the output stream will be the compressed form

               of the data written.  If you wish to use the <c>DeflateStream</c> to

               decompress data while writing, you can create a <c>DeflateStream</c> with

               <c>CompressionMode.Decompress</c>, and a writable output stream.  Then

               call <c>Write()</c> on that stream, providing previously compressed

               data. The data sent to the output stream will be the decompressed form of

               the data written.

             </para>

             <para>

               A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>,

               but not both.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.CompressString(System.String)">

             <summary>

               Compress a string into a byte array using DEFLATE (RFC 1951).

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.DeflateStream.UncompressString(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.DeflateStream.UncompressString(System.Byte[])">DeflateStream.UncompressString(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.DeflateStream.CompressBuffer(System.Byte[])">DeflateStream.CompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressString(System.String)">GZipStream.CompressString(string)</seealso>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressString(System.String)">ZlibStream.CompressString(string)</seealso>

             <param name="s">

               A string to compress. The string will first be encoded

               using UTF8, then compressed.

             </param>

             <returns>The string in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.CompressBuffer(System.Byte[])">

             <summary>

               Compress a byte array into a new byte array using DEFLATE.

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.DeflateStream.UncompressBuffer(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.DeflateStream.CompressString(System.String)">DeflateStream.CompressString(string)</seealso>

             <seealso cref="M:Ionic.Zlib.DeflateStream.UncompressBuffer(System.Byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressBuffer(System.Byte[])">GZipStream.CompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressBuffer(System.Byte[])">ZlibStream.CompressBuffer(byte[])</seealso>

             <param name="b">

               A buffer to compress.

             </param>

             <returns>The data in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.UncompressString(System.Byte[])">

             <summary>

               Uncompress a DEFLATE'd byte array into a single string.

             </summary>

             <seealso cref="M:Ionic.Zlib.DeflateStream.CompressString(System.String)">DeflateStream.CompressString(String)</seealso>

             <seealso cref="M:Ionic.Zlib.DeflateStream.UncompressBuffer(System.Byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressString(System.Byte[])">GZipStream.UncompressString(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressString(System.Byte[])">ZlibStream.UncompressString(byte[])</seealso>

             <param name="compressed">

               A buffer containing DEFLATE-compressed data.

             </param>

             <returns>The uncompressed string</returns>

        </member>

        <member name="M:Ionic.Zlib.DeflateStream.UncompressBuffer(System.Byte[])">

             <summary>

               Uncompress a DEFLATE'd byte array into a byte array.

             </summary>

             <seealso cref="M:Ionic.Zlib.DeflateStream.CompressBuffer(System.Byte[])">DeflateStream.CompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.DeflateStream.UncompressString(System.Byte[])">DeflateStream.UncompressString(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressBuffer(System.Byte[])">GZipStream.UncompressBuffer(byte[])</seealso>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressBuffer(System.Byte[])">ZlibStream.UncompressBuffer(byte[])</seealso>

             <param name="compressed">

               A buffer containing data that has been compressed with DEFLATE.

             </param>

             <returns>The data in uncompressed form</returns>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.FlushMode">

            <summary>

            This property sets the flush behavior on the stream.

            </summary>

            <remarks> See the ZLIB documentation for the meaning of the flush behavior.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.BufferSize">

             <summary>

               The size of the working buffer for the compression codec.

             </summary>

             <remarks>

             <para>

               The working buffer is used for all stream operations.  The default size is

               1024 bytes.  The minimum size is 128 bytes. You may get better performance

               with a larger buffer.  Then again, you might not.  You would have to test

               it.

             </para>

             <para>

               Set this before the first call to <c>Read()</c> or <c>Write()</c> on the

               stream. If you try to set it afterwards, it will throw.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.Strategy">

             <summary>

               The ZLIB strategy to be used during compression.

             </summary>

             <remarks>

               By tweaking this parameter, you may be able to optimize the compression for

               data with particular characteristics.

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.TotalIn">

            <summary> Returns the total number of bytes input so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.TotalOut">

            <summary> Returns the total number of bytes output so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports reading.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports writing.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.DeflateStream.Position">

             <summary>

             The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotImplementedException"/>. Reading will return the total bytes

               written out, if used in writing, or the total bytes read in, if used in

               reading.  The count may refer to compressed bytes or uncompressed bytes,

               depending on how you've used the stream.

             </remarks>

        </member>

        <member name="T:Ionic.Zlib.GZipStream">

             <summary>

               A class for compressing and decompressing GZIP streams.

             </summary>

             <remarks>

             <para>

               The <c>GZipStream</c> is a <see href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a

               <see cref="T:System.IO.Stream"/>. It adds GZIP compression or decompression to any

               stream.

             </para>

             <para>

               Like the <c>System.IO.Compression.GZipStream</c> in the .NET Base Class Library, the

               <c>Ionic.Zlib.GZipStream</c> can compress while writing, or decompress while

               reading, but not vice versa.  The compression method used is GZIP, which is

               documented in <see href="http://www.ietf.org/rfc/rfc1952.txt">IETF RFC

               1952</see>, "GZIP file format specification version 4.3".</para>

             <para>

               A <c>GZipStream</c> can be used to decompress data (through <c>Read()</c>) or

               to compress data (through <c>Write()</c>), but not both.

             </para>

             <para>

               If you wish to use the <c>GZipStream</c> to compress data, you must wrap it

               around a write-able stream. As you call <c>Write()</c> on the <c>GZipStream</c>, the

               data will be compressed into the GZIP format.  If you want to decompress data,

               you must wrap the <c>GZipStream</c> around a readable stream that contains an

               IETF RFC 1952-compliant stream.  The data will be decompressed as you call

               <c>Read()</c> on the <c>GZipStream</c>.

             </para>

             <para>

               Though the GZIP format allows data from multiple files to be concatenated

               together, this stream handles only a single segment of GZIP format, typically

               representing a single file.

             </para>

             <para>

               This class is similar to <see cref="T:Ionic.Zlib.ZlibStream"/> and <see cref="T:Ionic.Zlib.DeflateStream"/>.

               <c>ZlibStream</c> handles RFC1950-compliant streams.  <see cref="T:Ionic.Zlib.DeflateStream"/>

               handles RFC1951-compliant streams. This class handles RFC1952-compliant streams.

             </para>

             </remarks>

             <seealso cref="T:Ionic.Zlib.DeflateStream"/>

             <seealso cref="T:Ionic.Zlib.ZlibStream"/>

        </member>

        <member name="F:Ionic.Zlib.GZipStream.LastModified">

             <summary>

               The last modified time for the GZIP stream.

             </summary>

             <remarks>

               GZIP allows the storage of a last modified time with each GZIP entry.

               When compressing data, you can set this before the first call to

               <c>Write()</c>.  When decompressing, you can retrieve this value any time

               after the first call to <c>Read()</c>.

             </remarks>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode)">

             <summary>

               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Compress</c>, the <c>GZipStream</c> will use the

               default compression level.

             </para>

             <para>

               As noted in the class documentation, the <c>CompressionMode</c> (Compress

               or Decompress) also establishes the "direction" of the stream.  A

               <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through

               <c>Write()</c>.  A <c>GZipStream</c> with

               <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.

             </para>

             </remarks>

             <example>

               This example shows how to use a GZipStream to compress data.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(outputFile))

                 {

                     using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Dim outputFile As String = (fileToCompress &amp; ".compressed")

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(outputFile)

                 Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)

                     Dim buffer As Byte() = New Byte(4096) {}

                     Dim n As Integer = -1

                     Do While (n &lt;&gt; 0)

                         If (n &gt; 0) Then

                             compressor.Write(buffer, 0, n)

                         End If

                         n = input.Read(buffer, 0, buffer.Length)

                     Loop

                 End Using

                 End Using

             End Using

             </code>

             </example>

             <example>

             This example shows how to use a GZipStream to uncompress a file.

             <code>

             private void GunZipFile(string filename)

             {

                 if (!filename.EndsWith(".gz))

                     throw new ArgumentException("filename");

                 var DecompressedFile = filename.Substring(0,filename.Length-3);

                 byte[] working = new byte[WORKING_BUFFER_SIZE];

                 int n= 1;

                 using (System.IO.Stream input = System.IO.File.OpenRead(filename))

                 {

                     using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))

                     {

                         using (var output = System.IO.File.Create(DecompressedFile))

                         {

                             while (n !=0)

                             {

                                 n= decompressor.Read(working, 0, working.Length);

                                 if (n > 0)

                                 {

                                     output.Write(working, 0, n);

                                 }

                             }

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Private Sub GunZipFile(ByVal filename as String)

                 If Not (filename.EndsWith(".gz)) Then

                     Throw New ArgumentException("filename")

                 End If

                 Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)

                 Dim working(WORKING_BUFFER_SIZE) as Byte

                 Dim n As Integer = 1

                 Using input As Stream = File.OpenRead(filename)

                     Using decompressor As Stream = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, True)

                         Using output As Stream = File.Create(UncompressedFile)

                             Do

                                 n= decompressor.Read(working, 0, working.Length)

                                 If n > 0 Then

                                     output.Write(working, 0, n)

                                 End IF

                             Loop While (n  > 0)

                         End Using

                     End Using

                 End Using

             End Sub

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel)">

             <summary>

               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and

               the specified <c>CompressionLevel</c>.

             </summary>

             <remarks>

             <para>

               The <c>CompressionMode</c> (Compress or Decompress) also establishes the

               "direction" of the stream.  A <c>GZipStream</c> with

               <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A

               <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only

               through <c>Read()</c>.

             </para>

             </remarks>

             <example>

             This example shows how to use a <c>GZipStream</c> to compress a file into a .gz file.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(fileToCompress + ".gz"))

                 {

                     using (Stream compressor = new GZipStream(raw,

                                                               CompressionMode.Compress,

                                                               CompressionLevel.BestCompression))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(fileToCompress &amp; ".gz")

                     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream to be read or written while deflating or inflating.</param>

             <param name="mode">Indicates whether the <c>GZipStream</c> will compress or decompress.</param>

             <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,System.Boolean)">

             <summary>

               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>, and

               explicitly specify whether the stream should be left open after Deflation

               or Inflation.

             </summary>

             <remarks>

             <para>

               This constructor allows the application to request that the captive stream

               remain open after the deflation or inflation occurs.  By default, after

               <c>Close()</c> is called on the stream, the captive stream is also

               closed. In some cases this is not desired, for example if the stream is a

               memory stream that will be re-read after compressed data has been written

               to it.  Specify true for the <paramref name="leaveOpen"/> parameter to leave

               the stream open.

             </para>

             <para>

               The <see cref="T:Ionic.Zlib.CompressionMode"/> (Compress or Decompress) also

               establishes the "direction" of the stream.  A <c>GZipStream</c> with

               <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A <c>GZipStream</c>

               with <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.

             </para>

             <para>

               The <c>GZipStream</c> will use the default compression level. If you want

               to specify the compression level, see <see cref="M:Ionic.Zlib.GZipStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel,System.Boolean)"/>.

             </para>

             <para>

               See the other overloads of this constructor for example code.

             </para>

             </remarks>

             <param name="stream">

               The stream which will be read or written. This is called the "captive"

               stream in other places in this documentation.

             </param>

             <param name="mode">Indicates whether the GZipStream will compress or decompress.

             </param>

             <param name="leaveOpen">

               true if the application would like the base stream to remain open after

               inflation/deflation.

             </param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel,System.Boolean)">

             <summary>

               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and the

               specified <c>CompressionLevel</c>, and explicitly specify whether the

               stream should be left open after Deflation or Inflation.

             </summary>

             <remarks>

             <para>

               This constructor allows the application to request that the captive stream

               remain open after the deflation or inflation occurs.  By default, after

               <c>Close()</c> is called on the stream, the captive stream is also

               closed. In some cases this is not desired, for example if the stream is a

               memory stream that will be re-read after compressed data has been written

               to it.  Specify true for the <paramref name="leaveOpen"/> parameter to

               leave the stream open.

             </para>

             <para>

               As noted in the class documentation, the <c>CompressionMode</c> (Compress

               or Decompress) also establishes the "direction" of the stream.  A

               <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through

               <c>Write()</c>.  A <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only

               through <c>Read()</c>.

             </para>

             </remarks>

             <example>

               This example shows how to use a <c>GZipStream</c> to compress data.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(outputFile))

                 {

                     using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Dim outputFile As String = (fileToCompress &amp; ".compressed")

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(outputFile)

                 Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)

                     Dim buffer As Byte() = New Byte(4096) {}

                     Dim n As Integer = -1

                     Do While (n &lt;&gt; 0)

                         If (n &gt; 0) Then

                             compressor.Write(buffer, 0, n)

                         End If

                         n = input.Read(buffer, 0, buffer.Length)

                     Loop

                 End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>

             <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>

             <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.Dispose(System.Boolean)">

            <summary>

              Dispose the stream.

            </summary>

            <remarks>

              <para>

                This may or may not result in a <c>Close()</c> call on the captive

                stream.  See the constructors that have a <c>leaveOpen</c> parameter

                for more information.

              </para>

              <para>

                This method may be invoked in two distinct scenarios.  If disposing

                == true, the method has been called directly or indirectly by a

                user's code, for example via the public Dispose() method. In this

                case, both managed and unmanaged resources can be referenced and

                disposed.  If disposing == false, the method has been called by the

                runtime from inside the object finalizer and this method should not

                reference other objects; in that case only unmanaged resources must

                be referenced or disposed.

              </para>

            </remarks>

            <param name="disposing">

              indicates whether the Dispose method was invoked by user code.

            </param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.Read(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Read and decompress data from the source stream.

             </summary>

             <remarks>

               With a <c>GZipStream</c>, decompression is done through reading.

             </remarks>

             <example>

             <code>

             byte[] working = new byte[WORKING_BUFFER_SIZE];

             using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))

             {

                 using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))

                 {

                     using (var output = System.IO.File.Create(_DecompressedFile))

                     {

                         int n;

                         while ((n= decompressor.Read(working, 0, working.Length)) !=0)

                         {

                             output.Write(working, 0, n);

                         }

                     }

                 }

             }

             </code>

             </example>

             <param name="buffer">The buffer into which the decompressed data should be placed.</param>

             <param name="offset">the offset within that data array to put the first byte read.</param>

             <param name="count">the number of bytes to read.</param>

             <returns>the number of bytes actually read</returns>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="offset">irrelevant; it will always throw!</param>

            <param name="origin">irrelevant; it will always throw!</param>

            <returns>irrelevant!</returns>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.SetLength(System.Int64)">

            <summary>

              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

            <param name="value">irrelevant; this method will always throw!</param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write data to the stream.

             </summary>

             <remarks>

             <para>

               If you wish to use the <c>GZipStream</c> to compress data while writing,

               you can create a <c>GZipStream</c> with <c>CompressionMode.Compress</c>, and a

               writable output stream.  Then call <c>Write()</c> on that <c>GZipStream</c>,

               providing uncompressed data as input.  The data sent to the output stream

               will be the compressed form of the data written.

             </para>

             <para>

               A <c>GZipStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not

               both. Writing implies compression.  Reading implies decompression.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.CompressString(System.String)">

             <summary>

               Compress a string into a byte array using GZip.

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.GZipStream.UncompressString(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressString(System.Byte[])"/>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressBuffer(System.Byte[])"/>

             <param name="s">

               A string to compress. The string will first be encoded

               using UTF8, then compressed.

             </param>

             <returns>The string in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.CompressBuffer(System.Byte[])">

             <summary>

               Compress a byte array into a new byte array using GZip.

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.GZipStream.UncompressBuffer(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressString(System.String)"/>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressBuffer(System.Byte[])"/>

             <param name="b">

               A buffer to compress.

             </param>

             <returns>The data in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.UncompressString(System.Byte[])">

             <summary>

               Uncompress a GZip'ed byte array into a single string.

             </summary>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressString(System.String)"/>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressBuffer(System.Byte[])"/>

             <param name="compressed">

               A buffer containing GZIP-compressed data.

             </param>

             <returns>The uncompressed string</returns>

        </member>

        <member name="M:Ionic.Zlib.GZipStream.UncompressBuffer(System.Byte[])">

             <summary>

               Uncompress a GZip'ed byte array into a byte array.

             </summary>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressBuffer(System.Byte[])"/>

             <seealso cref="M:Ionic.Zlib.GZipStream.UncompressString(System.Byte[])"/>

             <param name="compressed">

               A buffer containing data that has been compressed with GZip.

             </param>

             <returns>The data in uncompressed form</returns>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.Comment">

             <summary>

               The comment on the GZIP stream.

             </summary>

             <remarks>

             <para>

               The GZIP format allows for each file to optionally have an associated

               comment stored with the file.  The comment is encoded with the ISO-8859-1

               code page.  To include a comment in a GZIP stream you create, set this

               property before calling <c>Write()</c> for the first time on the

               <c>GZipStream</c>.

             </para>

             <para>

               When using <c>GZipStream</c> to decompress, you can retrieve this property

               after the first call to <c>Read()</c>.  If no comment has been set in the

               GZIP bytestream, the Comment property will return <c>null</c>

               (<c>Nothing</c> in VB).

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.FileName">

             <summary>

               The FileName for the GZIP stream.

             </summary>

             <remarks>

             <para>

               The GZIP format optionally allows each file to have an associated

               filename.  When compressing data (through <c>Write()</c>), set this

               FileName before calling <c>Write()</c> the first time on the <c>GZipStream</c>.

               The actual filename is encoded into the GZIP bytestream with the

               ISO-8859-1 code page, according to RFC 1952. It is the application's

               responsibility to insure that the FileName can be encoded and decoded

               correctly with this code page.

             </para>

             <para>

               When decompressing (through <c>Read()</c>), you can retrieve this value

               any time after the first <c>Read()</c>.  In the case where there was no filename

               encoded into the GZIP bytestream, the property will return <c>null</c> (<c>Nothing</c>

               in VB).

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.Crc32">

            <summary>

            The CRC on the GZIP stream.

            </summary>

            <remarks>

            This is used for internal error checking. You probably don't need to look at this property.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.FlushMode">

            <summary>

            This property sets the flush behavior on the stream.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.BufferSize">

             <summary>

               The size of the working buffer for the compression codec.

             </summary>

             <remarks>

             <para>

               The working buffer is used for all stream operations.  The default size is

               1024 bytes.  The minimum size is 128 bytes. You may get better performance

               with a larger buffer.  Then again, you might not.  You would have to test

               it.

             </para>

             <para>

               Set this before the first call to <c>Read()</c> or <c>Write()</c> on the

               stream. If you try to set it afterwards, it will throw.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.TotalIn">

            <summary> Returns the total number of bytes input so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.TotalOut">

            <summary> Returns the total number of bytes output so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports reading.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports writing.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.GZipStream.Position">

             <summary>

               The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotImplementedException"/>. Reading will return the total bytes

               written out, if used in writing, or the total bytes read in, if used in

               reading.  The count may refer to compressed bytes or uncompressed bytes,

               depending on how you've used the stream.

             </remarks>

        </member>

        <member name="T:Ionic.Zlib.ParallelDeflateOutputStream">

             <summary>

               A class for compressing streams using the

               Deflate algorithm with multiple threads.

             </summary>

             <remarks>

             <para>

               This class performs DEFLATE compression through writing.  For

               more information on the Deflate algorithm, see IETF RFC 1951,

               "DEFLATE Compressed Data Format Specification version 1.3."

             </para>

             <para>

               This class is similar to <see cref="T:Ionic.Zlib.DeflateStream"/>, except

               that this class is for compression only, and this implementation uses an

               approach that employs multiple worker threads to perform the DEFLATE.  On

               a multi-cpu or multi-core computer, the performance of this class can be

               significantly higher than the single-threaded DeflateStream, particularly

               for larger streams.  How large?  Anything over 10mb is a good candidate

               for parallel compression.

             </para>

             <para>

               The tradeoff is that this class uses more memory and more CPU than the

               vanilla DeflateStream, and also is less efficient as a compressor. For

               large files the size of the compressed data stream can be less than 1%

               larger than the size of a compressed data stream from the vanialla

               DeflateStream.  For smaller files the difference can be larger.  The

               difference will also be larger if you set the BufferSize to be lower than

               the default value.  Your mileage may vary. Finally, for small files, the

               ParallelDeflateOutputStream can be much slower than the vanilla

               DeflateStream, because of the overhead associated to using the thread

               pool.

             </para>

             </remarks>

             <seealso cref="T:Ionic.Zlib.DeflateStream"/>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream)">

             <summary>

             Create a ParallelDeflateOutputStream.

             </summary>

             <remarks>

             <para>

               This stream compresses data written into it via the DEFLATE

               algorithm (see RFC 1951), and writes out the compressed byte stream.

             </para>

             <para>

               The instance will use the default compression level, the default

               buffer sizes and the default number of threads and buffers per

               thread.

             </para>

             <para>

               This class is similar to <see cref="T:Ionic.Zlib.DeflateStream"/>,

               except that this implementation uses an approach that employs

               multiple worker threads to perform the DEFLATE.  On a multi-cpu or

               multi-core computer, the performance of this class can be

               significantly higher than the single-threaded DeflateStream,

               particularly for larger streams.  How large?  Anything over 10mb is

               a good candidate for parallel compression.

             </para>

             </remarks>

             <example>

             This example shows how to use a ParallelDeflateOutputStream to compress

             data.  It reads a file, compresses it, and writes the compressed data to

             a second, output file.

             <code>

             byte[] buffer = new byte[WORKING_BUFFER_SIZE];

             int n= -1;

             String outputFile = fileToCompress + ".compressed";

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(outputFile))

                 {

                     using (Stream compressor = new ParallelDeflateOutputStream(raw))

                     {

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Dim buffer As Byte() = New Byte(4096) {}

             Dim n As Integer = -1

             Dim outputFile As String = (fileToCompress &amp; ".compressed")

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(outputFile)

                     Using compressor As Stream = New ParallelDeflateOutputStream(raw)

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream to which compressed data will be written.</param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionLevel)">

            <summary>

              Create a ParallelDeflateOutputStream using the specified CompressionLevel.

            </summary>

            <remarks>

              See the <see cref="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream)"/>

              constructor for example code.

            </remarks>

            <param name="stream">The stream to which compressed data will be written.</param>

            <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream,System.Boolean)">

            <summary>

            Create a ParallelDeflateOutputStream and specify whether to leave the captive stream open

            when the ParallelDeflateOutputStream is closed.

            </summary>

            <remarks>

              See the <see cref="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream)"/>

              constructor for example code.

            </remarks>

            <param name="stream">The stream to which compressed data will be written.</param>

            <param name="leaveOpen">

               true if the application would like the stream to remain open after inflation/deflation.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionLevel,System.Boolean)">

            <summary>

            Create a ParallelDeflateOutputStream and specify whether to leave the captive stream open

            when the ParallelDeflateOutputStream is closed.

            </summary>

            <remarks>

              See the <see cref="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream)"/>

              constructor for example code.

            </remarks>

            <param name="stream">The stream to which compressed data will be written.</param>

            <param name="level">A tuning knob to trade speed for effectiveness.</param>

            <param name="leaveOpen">

               true if the application would like the stream to remain open after inflation/deflation.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionLevel,Ionic.Zlib.CompressionStrategy,System.Boolean)">

            <summary>

            Create a ParallelDeflateOutputStream using the specified

            CompressionLevel and CompressionStrategy, and specifying whether to

            leave the captive stream open when the ParallelDeflateOutputStream is

            closed.

            </summary>

            <remarks>

              See the <see cref="M:Ionic.Zlib.ParallelDeflateOutputStream.#ctor(System.IO.Stream)"/>

              constructor for example code.

            </remarks>

            <param name="stream">The stream to which compressed data will be written.</param>

            <param name="level">A tuning knob to trade speed for effectiveness.</param>

            <param name="strategy">

              By tweaking this parameter, you may be able to optimize the compression for

              data with particular characteristics.

            </param>

            <param name="leaveOpen">

               true if the application would like the stream to remain open after inflation/deflation.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

               Write data to the stream.

             </summary>

             <remarks>

             <para>

               To use the ParallelDeflateOutputStream to compress data, create a

               ParallelDeflateOutputStream with CompressionMode.Compress, passing a

               writable output stream.  Then call Write() on that

               ParallelDeflateOutputStream, providing uncompressed data as input.  The

               data sent to the output stream will be the compressed form of the data

               written.

             </para>

             <para>

               To decompress data, use the <see cref="T:Ionic.Zlib.DeflateStream"/> class.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Close">

            <summary>

            Close the stream.

            </summary>

            <remarks>

            You must call Close on the stream to guarantee that all of the data written in has

            been compressed, and the compressed data has been written out.

            </remarks>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Dispose">

            <summary>Dispose the object</summary>

            <remarks>

              <para>

                Because ParallelDeflateOutputStream is IDisposable, the

                application must call this method when finished using the instance.

              </para>

              <para>

                This method is generally called implicitly upon exit from

                a <c>using</c> scope in C# (<c>Using</c> in VB).

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Dispose(System.Boolean)">

            <summary>The Dispose method</summary>

            <param name="disposing">

              indicates whether the Dispose method was invoked by user code.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Reset(System.IO.Stream)">

             <summary>

               Resets the stream for use with another stream.

             </summary>

             <remarks>

               Because the ParallelDeflateOutputStream is expensive to create, it

               has been designed so that it can be recycled and re-used.  You have

               to call Close() on the stream first, then you can call Reset() on

               it, to use it again on another stream.

             </remarks>

             <param name="stream">

               The new output stream for this era.

             </param>

             <example>

             <code>

             ParallelDeflateOutputStream deflater = null;

             foreach (var inputFile in listOfFiles)

             {

                 string outputFile = inputFile + ".compressed";

                 using (System.IO.Stream input = System.IO.File.OpenRead(inputFile))

                 {

                     using (var outStream = System.IO.File.Create(outputFile))

                     {

                         if (deflater == null)

                             deflater = new ParallelDeflateOutputStream(outStream,

                                                                        CompressionLevel.Best,

                                                                        CompressionStrategy.Default,

                                                                        true);

                         deflater.Reset(outStream);

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             deflater.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             </example>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="buffer">

              The buffer into which data would be read, IF THIS METHOD

              ACTUALLY DID ANYTHING.

            </param>

            <param name="offset">

              The offset within that data array at which to insert the

              data that is read, IF THIS METHOD ACTUALLY DID

              ANYTHING.

            </param>

            <param name="count">

              The number of bytes to write, IF THIS METHOD ACTUALLY DID

              ANYTHING.

            </param>

            <returns>nothing.</returns>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="offset">

              The offset to seek to....

              IF THIS METHOD ACTUALLY DID ANYTHING.

            </param>

            <param name="origin">

              The reference specifying how to apply the offset....  IF

              THIS METHOD ACTUALLY DID ANYTHING.

            </param>

            <returns>nothing. It always throws.</returns>

        </member>

        <member name="M:Ionic.Zlib.ParallelDeflateOutputStream.SetLength(System.Int64)">

            <summary>

            This method always throws a NotSupportedException.

            </summary>

            <param name="value">

              The new value for the stream length....  IF

              THIS METHOD ACTUALLY DID ANYTHING.

            </param>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.Strategy">

             <summary>

               The ZLIB strategy to be used during compression.

             </summary>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.MaxBufferPairs">

             <summary>

               The maximum number of buffer pairs to use.

             </summary>

             <remarks>

             <para>

               This property sets an upper limit on the number of memory buffer

               pairs to create.  The implementation of this stream allocates

               multiple buffers to facilitate parallel compression.  As each buffer

               fills up, this stream uses <see cref="M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback)">

               ThreadPool.QueueUserWorkItem()</see>

               to compress those buffers in a background threadpool thread. After a

               buffer is compressed, it is re-ordered and written to the output

               stream.

             </para>

             <para>

               A higher number of buffer pairs enables a higher degree of

               parallelism, which tends to increase the speed of compression on

               multi-cpu computers.  On the other hand, a higher number of buffer

               pairs also implies a larger memory consumption, more active worker

               threads, and a higher cpu utilization for any compression. This

               property enables the application to limit its memory consumption and

               CPU utilization behavior depending on requirements.

             </para>

             <para>

               For each compression "task" that occurs in parallel, there are 2

               buffers allocated: one for input and one for output.  This property

               sets a limit for the number of pairs.  The total amount of storage

               space allocated for buffering will then be (N*S*2), where N is the

               number of buffer pairs, S is the size of each buffer (<see cref="P:Ionic.Zlib.ParallelDeflateOutputStream.BufferSize"/>).  By default, DotNetZip allocates 4 buffer

               pairs per CPU core, so if your machine has 4 cores, and you retain

               the default buffer size of 128k, then the

               ParallelDeflateOutputStream will use 4 * 4 * 2 * 128kb of buffer

               memory in total, or 4mb, in blocks of 128kb.  If you then set this

               property to 8, then the number will be 8 * 2 * 128kb of buffer

               memory, or 2mb.

             </para>

             <para>

               CPU utilization will also go up with additional buffers, because a

               larger number of buffer pairs allows a larger number of background

               threads to compress in parallel. If you find that parallel

               compression is consuming too much memory or CPU, you can adjust this

               value downward.

             </para>

             <para>

               The default value is 16. Different values may deliver better or

               worse results, depending on your priorities and the dynamic

               performance characteristics of your storage and compute resources.

             </para>

             <para>

               This property is not the number of buffer pairs to use; it is an

               upper limit. An illustration: Suppose you have an application that

               uses the default value of this property (which is 16), and it runs

               on a machine with 2 CPU cores. In that case, DotNetZip will allocate

               4 buffer pairs per CPU core, for a total of 8 pairs.  The upper

               limit specified by this property has no effect.

             </para>

             <para>

               The application can set this value at any time, but it is effective

               only before the first call to Write(), which is when the buffers are

               allocated.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.BufferSize">

             <summary>

               The size of the buffers used by the compressor threads.

             </summary>

             <remarks>

             <para>

               The default buffer size is 128k. The application can set this value

               at any time, but it is effective only before the first Write().

             </para>

             <para>

               Larger buffer sizes implies larger memory consumption but allows

               more efficient compression. Using smaller buffer sizes consumes less

               memory but may result in less effective compression.  For example,

               using the default buffer size of 128k, the compression delivered is

               within 1% of the compression delivered by the single-threaded <see cref="T:Ionic.Zlib.DeflateStream"/>.  On the other hand, using a

               BufferSize of 8k can result in a compressed data stream that is 5%

               larger than that delivered by the single-threaded

               <c>DeflateStream</c>.  Excessively small buffer sizes can also cause

               the speed of the ParallelDeflateOutputStream to drop, because of

               larger thread scheduling overhead dealing with many many small

               buffers.

             </para>

             <para>

               The total amount of storage space allocated for buffering will be

               (N*S*2), where N is the number of buffer pairs, and S is the size of

               each buffer (this property). There are 2 buffers used by the

               compressor, one for input and one for output.  By default, DotNetZip

               allocates 4 buffer pairs per CPU core, so if your machine has 4

               cores, then the number of buffer pairs used will be 16. If you

               accept the default value of this property, 128k, then the

               ParallelDeflateOutputStream will use 16 * 2 * 128kb of buffer memory

               in total, or 4mb, in blocks of 128kb.  If you set this property to

               64kb, then the number will be 16 * 2 * 64kb of buffer memory, or

               2mb.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.Crc32">

            <summary>

            The CRC32 for the data that was written out, prior to compression.

            </summary>

            <remarks>

            This value is meaningful only after a call to Close().

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.BytesProcessed">

            <summary>

            The total number of uncompressed bytes processed by the ParallelDeflateOutputStream.

            </summary>

            <remarks>

            This value is meaningful only after a call to Close().

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.CanRead">

            <summary>

            Indicates whether the stream supports Read operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.CanWrite">

            <summary>

            Indicates whether the stream supports Write operations.

            </summary>

            <remarks>

            Returns true if the provided stream is writable.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.Length">

            <summary>

            Reading this property always throws a NotSupportedException.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.ParallelDeflateOutputStream.Position">

            <summary>

            Returns the current position of the output stream.

            </summary>

            <remarks>

              <para>

                Because the output gets written by a background thread,

                the value may change asynchronously.  Setting this

                property always throws a NotSupportedException.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Zlib.Tree.DistanceCode(System.Int32)">

            <summary>

            Map from a distance to a distance code.

            </summary>

            <remarks> 

            No side effects. _dist_code[256] and _dist_code[257] are never used.

            </remarks>

        </member>

        <member name="T:Ionic.Zlib.FlushType">

            <summary>

            Describes how to flush the current deflate operation.

            </summary>

            <remarks>

            The different FlushType values are useful when using a Deflate in a streaming application.

            </remarks>

        </member>

        <member name="F:Ionic.Zlib.FlushType.None">

            <summary>No flush at all.</summary>

        </member>

        <member name="F:Ionic.Zlib.FlushType.Partial">

            <summary>Closes the current block, but doesn't flush it to

            the output. Used internally only in hypothetical

            scenarios.  This was supposed to be removed by Zlib, but it is

            still in use in some edge cases.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.FlushType.Sync">

            <summary>

            Use this during compression to specify that all pending output should be

            flushed to the output buffer and the output should be aligned on a byte

            boundary.  You might use this in a streaming communication scenario, so that

            the decompressor can get all input data available so far.  When using this

            with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if

            enough output space has been provided before the call.  Flushing will

            degrade compression and so it should be used only when necessary.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.FlushType.Full">

            <summary>

            Use this during compression to specify that all output should be flushed, as

            with <c>FlushType.Sync</c>, but also, the compression state should be reset

            so that decompression can restart from this point if previous compressed

            data has been damaged or if random access is desired.  Using

            <c>FlushType.Full</c> too often can significantly degrade the compression.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.FlushType.Finish">

            <summary>Signals the end of the compression/decompression stream.</summary>

        </member>

        <member name="T:Ionic.Zlib.CompressionLevel">

            <summary>

            The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.None">

            <summary>

            None means that the data will be simply stored, with no change at all.

            If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None

            cannot be opened with the default zip reader. Use a different CompressionLevel.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level0">

            <summary>

            Same as None.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.BestSpeed">

            <summary>

            The fastest but least effective compression.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level1">

            <summary>

            A synonym for BestSpeed.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level2">

            <summary>

            A little slower, but better, than level 1.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level3">

            <summary>

            A little slower, but better, than level 2.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level4">

            <summary>

            A little slower, but better, than level 3.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level5">

            <summary>

            A little slower than level 4, but with better compression.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Default">

            <summary>

            The default compression level, with a good balance of speed and compression efficiency.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level6">

            <summary>

            A synonym for Default.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level7">

            <summary>

            Pretty good compression!

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level8">

            <summary>

             Better compression than Level7!

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.BestCompression">

            <summary>

            The "best" compression, where best means greatest reduction in size of the input data stream.

            This is also the slowest compression.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionLevel.Level9">

            <summary>

            A synonym for BestCompression.

            </summary>

        </member>

        <member name="T:Ionic.Zlib.CompressionStrategy">

            <summary>

            Describes options for how the compression algorithm is executed.  Different strategies

            work better on different sorts of data.  The strategy parameter can affect the compression

            ratio and the speed of compression but not the correctness of the compresssion.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionStrategy.Default">

            <summary>

            The default strategy is probably the best for normal data.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionStrategy.Filtered">

            <summary>

            The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a

            filter or predictor.  By this definition, filtered data consists mostly of small

            values with a somewhat random distribution.  In this case, the compression algorithm

            is tuned to compress them better.  The effect of <c>Filtered</c> is to force more Huffman

            coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionStrategy.HuffmanOnly">

            <summary>

            Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no

            string matching.

            </summary>

        </member>

        <member name="T:Ionic.Zlib.CompressionMode">

            <summary>

            An enum to specify the direction of transcoding - whether to compress or decompress.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionMode.Compress">

            <summary>

            Used to specify that the stream should compress the data.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.CompressionMode.Decompress">

            <summary>

            Used to specify that the stream should decompress the data.

            </summary>

        </member>

        <member name="T:Ionic.Zlib.ZlibException">

            <summary>

            A general purpose exception class for exceptions in the Zlib library.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.ZlibException.#ctor">

            <summary>

            The ZlibException class captures exception information generated

            by the Zlib library.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.ZlibException.#ctor(System.String)">

            <summary>

            This ctor collects a message attached to the exception.

            </summary>

            <param name="s">the message for the exception.</param>

        </member>

        <member name="M:Ionic.Zlib.SharedUtils.URShift(System.Int32,System.Int32)">

            <summary>

            Performs an unsigned bitwise right shift with the specified number

            </summary>

            <param name="number">Number to operate on</param>

            <param name="bits">Ammount of bits to shift</param>

            <returns>The resulting number from the shift operation</returns>

        </member>

        <member name="M:Ionic.Zlib.SharedUtils.ReadInput(System.IO.TextReader,System.Byte[],System.Int32,System.Int32)">

             <summary>

               Reads a number of characters from the current source TextReader and writes

               the data to the target array at the specified index.

             </summary>

             <param name="sourceTextReader">The source TextReader to read from</param>

             <param name="target">Contains the array of characteres read from the source TextReader.</param>

             <param name="start">The starting index of the target array.</param>

             <param name="count">The maximum number of characters to read from the source TextReader.</param>

             <returns>

               The number of characters read. The number will be less than or equal to

               count depending on the data available in the source TextReader. Returns -1

               if the end of the stream is reached.

             </returns>

        </member>

        <member name="T:Ionic.Zlib.Adler">

             <summary>

             Computes an Adler-32 checksum.

             </summary>

             <remarks>

             The Adler checksum is similar to a CRC checksum, but faster to compute, though less

             reliable.  It is used in producing RFC1950 compressed streams.  The Adler checksum

             is a required part of the "ZLIB" standard.  Applications will almost never need to

             use this class directly.

             </remarks>

             <exclude/>

        </member>

        <member name="M:Ionic.Zlib.Adler.Adler32(System.UInt32,System.Byte[],System.Int32,System.Int32)">

            <summary>

              Calculates the Adler32 checksum.

            </summary>

            <remarks>

              <para>

                This is used within ZLIB.  You probably don't need to use this directly.

              </para>

            </remarks>

            <example>

               To compute an Adler32 checksum on a byte array:

             <code>

               var adler = Adler.Adler32(0, null, 0, 0);

               adler = Adler.Adler32(adler, buffer, index, length);

             </code>

            </example>

        </member>

        <member name="T:Ionic.Zlib.ZlibCodec">

             <summary>

             Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).

             </summary>

             <remarks>

             This class compresses and decompresses data according to the Deflate algorithm

             and optionally, the ZLIB format, as documented in <see

             href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see

             href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.

             </remarks>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.InputBuffer">

            <summary>

            The buffer from which data is taken.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.NextIn">

            <summary>

            An index into the InputBuffer array, indicating where to start reading. 

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.AvailableBytesIn">

            <summary>

            The number of bytes available in the InputBuffer, starting at NextIn. 

            </summary>

            <remarks>

            Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 

            The class will update this number as calls to Inflate/Deflate are made.

            </remarks>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.TotalBytesIn">

            <summary>

            Total number of bytes read so far, through all calls to Inflate()/Deflate().

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.OutputBuffer">

            <summary>

            Buffer to store output data.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.NextOut">

            <summary>

            An index into the OutputBuffer array, indicating where to start writing. 

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.AvailableBytesOut">

            <summary>

            The number of bytes available in the OutputBuffer, starting at NextOut. 

            </summary>

            <remarks>

            Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 

            The class will update this number as calls to Inflate/Deflate are made.

            </remarks>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.TotalBytesOut">

            <summary>

            Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.Message">

            <summary>

            used for diagnostics, when something goes wrong!

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.CompressLevel">

            <summary>

            The compression level to use in this codec.  Useful only in compression mode.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.WindowBits">

            <summary>

            The number of Window Bits to use.  

            </summary>

            <remarks>

            This gauges the size of the sliding window, and hence the 

            compression effectiveness as well as memory consumption. It's best to just leave this 

            setting alone if you don't know what it is.  The maximum value is 15 bits, which implies

            a 32k window.  

            </remarks>

        </member>

        <member name="F:Ionic.Zlib.ZlibCodec.Strategy">

            <summary>

            The compression strategy to use.

            </summary>

            <remarks>

            This is only effective in compression.  The theory offered by ZLIB is that different

            strategies could potentially produce significant differences in compression behavior

            for different data sets.  Unfortunately I don't have any good recommendations for how

            to set it differently.  When I tested changing the strategy I got minimally different

            compression performance. It's best to leave this property alone if you don't have a

            good feel for it.  Or, you may want to produce a test harness that runs through the

            different strategy options and evaluates them on different file types. If you do that,

            let me know your results.

            </remarks>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.#ctor">

            <summary>

            Create a ZlibCodec.

            </summary>

            <remarks>

            If you use this default constructor, you will later have to explicitly call 

            InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 

            or decompress. 

            </remarks>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.#ctor(Ionic.Zlib.CompressionMode)">

            <summary>

            Create a ZlibCodec that either compresses or decompresses.

            </summary>

            <param name="mode">

            Indicates whether the codec should compress (deflate) or decompress (inflate).

            </param>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeInflate">

            <summary>

            Initialize the inflation state. 

            </summary>

            <remarks>

            It is not necessary to call this before using the ZlibCodec to inflate data; 

            It is implicitly called when you call the constructor.

            </remarks>

            <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeInflate(System.Boolean)">

             <summary>

             Initialize the inflation state with an explicit flag to

             govern the handling of RFC1950 header bytes.

             </summary>

             <remarks>

             By default, the ZLIB header defined in <see

             href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected.  If

             you want to read a zlib stream you should specify true for

             expectRfc1950Header.  If you have a deflate stream, you will want to specify

             false. It is only necessary to invoke this initializer explicitly if you

             want to specify false.

             </remarks>

             <param name="expectRfc1950Header">whether to expect an RFC1950 header byte

             pair when reading the stream of data to be inflated.</param>

             <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeInflate(System.Int32)">

            <summary>

            Initialize the ZlibCodec for inflation, with the specified number of window bits. 

            </summary>

            <param name="windowBits">The number of window bits to use. If you need to ask what that is, 

            then you shouldn't be calling this initializer.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeInflate(System.Int32,System.Boolean)">

             <summary>

             Initialize the inflation state with an explicit flag to govern the handling of

             RFC1950 header bytes. 

             </summary>

             <remarks>

             If you want to read a zlib stream you should specify true for

             expectRfc1950Header. In this case, the library will expect to find a ZLIB

             header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC

             1950</see>, in the compressed stream.  If you will be reading a DEFLATE or

             GZIP stream, which does not have such a header, you will want to specify

             false.

             </remarks>

             <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 

             the stream of data to be inflated.</param>

             <param name="windowBits">The number of window bits to use. If you need to ask what that is, 

             then you shouldn't be calling this initializer.</param>

             <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.Inflate(Ionic.Zlib.FlushType)">

             <summary>

             Inflate the data in the InputBuffer, placing the result in the OutputBuffer.

             </summary>

             <remarks>

             You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 

             AvailableBytesOut  before calling this method.

             </remarks>

             <example>

             <code>

             private void InflateBuffer()

             {

                 int bufferSize = 1024;

                 byte[] buffer = new byte[bufferSize];

                 ZlibCodec decompressor = new ZlibCodec();

                 Console.WriteLine("\n============================================");

                 Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);

                 MemoryStream ms = new MemoryStream(DecompressedBytes);

                 int rc = decompressor.InitializeInflate();

                 decompressor.InputBuffer = CompressedBytes;

                 decompressor.NextIn = 0;

                 decompressor.AvailableBytesIn = CompressedBytes.Length;

                 decompressor.OutputBuffer = buffer;

                 // pass 1: inflate 

                 do

                 {

                     decompressor.NextOut = 0;

                     decompressor.AvailableBytesOut = buffer.Length;

                     rc = decompressor.Inflate(FlushType.None);

                     if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)

                         throw new Exception("inflating: " + decompressor.Message);

                     ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);

                 }

                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);

                 // pass 2: finish and flush

                 do

                 {

                     decompressor.NextOut = 0;

                     decompressor.AvailableBytesOut = buffer.Length;

                     rc = decompressor.Inflate(FlushType.Finish);

                     if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)

                         throw new Exception("inflating: " + decompressor.Message);

                     if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)

                         ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);

                 }

                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);

                 decompressor.EndInflate();

             }

             </code>

             </example>

             <param name="flush">The flush to use when inflating.</param>

             <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.EndInflate">

            <summary>

            Ends an inflation session. 

            </summary>

            <remarks>

            Call this after successively calling Inflate().  This will cause all buffers to be flushed. 

            After calling this you cannot call Inflate() without a intervening call to one of the

            InitializeInflate() overloads.

            </remarks>

            <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.SyncInflate">

            <summary>

            I don't know what this does!

            </summary>

            <returns>Z_OK if everything goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeDeflate">

            <summary>

            Initialize the ZlibCodec for deflation operation.

            </summary>

            <remarks>

            The codec will use the MAX window bits and the default level of compression.

            </remarks>

            <example>

            <code>

             int bufferSize = 40000;

             byte[] CompressedBytes = new byte[bufferSize];

             byte[] DecompressedBytes = new byte[bufferSize];

             ZlibCodec compressor = new ZlibCodec();

             compressor.InitializeDeflate(CompressionLevel.Default);

             compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);

             compressor.NextIn = 0;

             compressor.AvailableBytesIn = compressor.InputBuffer.Length;

             compressor.OutputBuffer = CompressedBytes;

             compressor.NextOut = 0;

             compressor.AvailableBytesOut = CompressedBytes.Length;

             while (compressor.TotalBytesIn != TextToCompress.Length &amp;&amp; compressor.TotalBytesOut &lt; bufferSize)

             {

               compressor.Deflate(FlushType.None);

             }

             while (true)

             {

               int rc= compressor.Deflate(FlushType.Finish);

               if (rc == ZlibConstants.Z_STREAM_END) break;

             }

             compressor.EndDeflate();

            </code>

            </example>

            <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeDeflate(Ionic.Zlib.CompressionLevel)">

            <summary>

            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.

            </summary>

            <remarks>

            The codec will use the maximum window bits (15) and the specified

            CompressionLevel.  It will emit a ZLIB stream as it compresses.

            </remarks>

            <param name="level">The compression level for the codec.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeDeflate(Ionic.Zlib.CompressionLevel,System.Boolean)">

            <summary>

            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 

            and the explicit flag governing whether to emit an RFC1950 header byte pair.

            </summary>

            <remarks>

            The codec will use the maximum window bits (15) and the specified CompressionLevel.

            If you want to generate a zlib stream, you should specify true for

            wantRfc1950Header. In this case, the library will emit a ZLIB

            header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC

            1950</see>, in the compressed stream.  

            </remarks>

            <param name="level">The compression level for the codec.</param>

            <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeDeflate(Ionic.Zlib.CompressionLevel,System.Int32)">

            <summary>

            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 

            and the specified number of window bits. 

            </summary>

            <remarks>

            The codec will use the specified number of window bits and the specified CompressionLevel.

            </remarks>

            <param name="level">The compression level for the codec.</param>

            <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.InitializeDeflate(Ionic.Zlib.CompressionLevel,System.Int32,System.Boolean)">

             <summary>

             Initialize the ZlibCodec for deflation operation, using the specified

             CompressionLevel, the specified number of window bits, and the explicit flag

             governing whether to emit an RFC1950 header byte pair.

             </summary>

             <param name="level">The compression level for the codec.</param>

             <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>

             <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>

             <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.Deflate(Ionic.Zlib.FlushType)">

            <summary>

            Deflate one batch of data.

            </summary>

            <remarks>

            You must have set InputBuffer and OutputBuffer before calling this method.

            </remarks>

            <example>

            <code>

            private void DeflateBuffer(CompressionLevel level)

            {

                int bufferSize = 1024;

                byte[] buffer = new byte[bufferSize];

                ZlibCodec compressor = new ZlibCodec();

                Console.WriteLine("\n============================================");

                Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);

                MemoryStream ms = new MemoryStream();

                int rc = compressor.InitializeDeflate(level);

                compressor.InputBuffer = UncompressedBytes;

                compressor.NextIn = 0;

                compressor.AvailableBytesIn = UncompressedBytes.Length;

                compressor.OutputBuffer = buffer;

                // pass 1: deflate 

                do

                {

                    compressor.NextOut = 0;

                    compressor.AvailableBytesOut = buffer.Length;

                    rc = compressor.Deflate(FlushType.None);

                    if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)

                        throw new Exception("deflating: " + compressor.Message);

                    ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);

                }

                while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);

                // pass 2: finish and flush

                do

                {

                    compressor.NextOut = 0;

                    compressor.AvailableBytesOut = buffer.Length;

                    rc = compressor.Deflate(FlushType.Finish);

                    if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)

                        throw new Exception("deflating: " + compressor.Message);

                    if (buffer.Length - compressor.AvailableBytesOut &gt; 0)

                        ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);

                }

                while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);

                compressor.EndDeflate();

                ms.Seek(0, SeekOrigin.Begin);

                CompressedBytes = new byte[compressor.TotalBytesOut];

                ms.Read(CompressedBytes, 0, CompressedBytes.Length);

            }

            </code>

            </example>

            <param name="flush">whether to flush all data as you deflate. Generally you will want to 

            use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to 

            flush everything. 

            </param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.EndDeflate">

            <summary>

            End a deflation session.

            </summary>

            <remarks>

            Call this after making a series of one or more calls to Deflate(). All buffers are flushed.

            </remarks>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.ResetDeflate">

            <summary>

            Reset a codec for another deflation session.

            </summary>

            <remarks>

            Call this to reset the deflation state.  For example if a thread is deflating

            non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first

            block and before the next Deflate(None) of the second block.

            </remarks>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.SetDeflateParams(Ionic.Zlib.CompressionLevel,Ionic.Zlib.CompressionStrategy)">

            <summary>

            Set the CompressionStrategy and CompressionLevel for a deflation session.

            </summary>

            <param name="level">the level of compression to use.</param>

            <param name="strategy">the strategy to use for compression.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibCodec.SetDictionary(System.Byte[])">

            <summary>

            Set the dictionary to be used for either Inflation or Deflation.

            </summary>

            <param name="dictionary">The dictionary bytes to use.</param>

            <returns>Z_OK if all goes well.</returns>

        </member>

        <member name="P:Ionic.Zlib.ZlibCodec.Adler32">

            <summary>

            The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.

            </summary>

        </member>

        <member name="T:Ionic.Zlib.ZlibConstants">

            <summary>

            A bunch of constants used in the Zlib interface.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.WindowBitsMax">

            <summary>

            The maximum number of window bits for the Deflate algorithm.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.WindowBitsDefault">

            <summary>

            The default number of window bits for the Deflate algorithm.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_OK">

            <summary>

            indicates everything is A-OK

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_STREAM_END">

            <summary>

            Indicates that the last operation reached the end of the stream.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_NEED_DICT">

            <summary>

            The operation ended in need of a dictionary. 

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_STREAM_ERROR">

            <summary>

            There was an error with the stream - not enough data, not open and readable, etc.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_DATA_ERROR">

            <summary>

            There was an error with the data - not enough data, bad data, etc.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.Z_BUF_ERROR">

            <summary>

            There was an error with the working buffer.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.WorkingBufferSizeDefault">

            <summary>

            The size of the working buffer used in the ZlibCodec class. Defaults to 8192 bytes.

            </summary>

        </member>

        <member name="F:Ionic.Zlib.ZlibConstants.WorkingBufferSizeMin">

            <summary>

            The minimum size of the working buffer used in the ZlibCodec class.  Currently it is 128 bytes.

            </summary>

        </member>

        <member name="T:Ionic.Zlib.ZlibStream">

             <summary>

             Represents a Zlib stream for compression or decompression.

             </summary>

             <remarks>

             <para>

             The ZlibStream is a <see href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see cref="T:System.IO.Stream"/>.  It adds ZLIB compression or decompression to any

             stream.

             </para>

             <para> Using this stream, applications can compress or decompress data via

             stream <c>Read()</c> and <c>Write()</c> operations.  Either compresssion or

             decompression can occur through either reading or writing. The compression

             format used is ZLIB, which is documented in <see href="http://www.ietf.org/rfc/rfc1950.txt">IETF RFC 1950</see>, "ZLIB Compressed

             Data Format Specification version 3.3". This implementation of ZLIB always uses

             DEFLATE as the compression method.  (see <see href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE

             Compressed Data Format Specification version 1.3.") </para>

             <para>

             The ZLIB format allows for varying compression methods, window sizes, and dictionaries.

             This implementation always uses the DEFLATE compression method, a preset dictionary,

             and 15 window bits by default.

             </para>

             <para>

             This class is similar to <see cref="T:Ionic.Zlib.DeflateStream"/>, except that it adds the

             RFC1950 header and trailer bytes to a compressed stream when compressing, or expects

             the RFC1950 header and trailer bytes when decompressing.  It is also similar to the

             <see cref="T:Ionic.Zlib.GZipStream"/>.

             </para>

             </remarks>

             <seealso cref="T:Ionic.Zlib.DeflateStream"/>

             <seealso cref="T:Ionic.Zlib.GZipStream"/>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode)">

             <summary>

             Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c>

               will use the default compression level. The "captive" stream will be

               closed when the <c>ZlibStream</c> is closed.

             </para>

             </remarks>

             <example>

             This example uses a <c>ZlibStream</c> to compress a file, and writes the

             compressed data to another file.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))

                 {

                     using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")

                 Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)

                     Dim buffer As Byte() = New Byte(4096) {}

                     Dim n As Integer = -1

                     Do While (n &lt;&gt; 0)

                         If (n &gt; 0) Then

                             compressor.Write(buffer, 0, n)

                         End If

                         n = input.Read(buffer, 0, buffer.Length)

                     Loop

                 End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel)">

             <summary>

               Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c> and

               the specified <c>CompressionLevel</c>.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.

               The "captive" stream will be closed when the <c>ZlibStream</c> is closed.

             </para>

             </remarks>

             <example>

               This example uses a <c>ZlibStream</c> to compress data from a file, and writes the

               compressed data to another file.

             <code>

             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

             {

                 using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))

                 {

                     using (Stream compressor = new ZlibStream(raw,

                                                               CompressionMode.Compress,

                                                               CompressionLevel.BestCompression))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

             }

             </code>

             <code lang="VB">

             Using input As Stream = File.OpenRead(fileToCompress)

                 Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")

                     Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

             End Using

             </code>

             </example>

             <param name="stream">The stream to be read or written while deflating or inflating.</param>

             <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>

             <param name="level">A tuning knob to trade speed for effectiveness.</param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,System.Boolean)">

             <summary>

               Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>, and

               explicitly specify whether the captive stream should be left open after

               Deflation or Inflation.

             </summary>

             <remarks>

             <para>

               When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c> will use

               the default compression level.

             </para>

             <para>

               This constructor allows the application to request that the captive stream

               remain open after the deflation or inflation occurs.  By default, after

               <c>Close()</c> is called on the stream, the captive stream is also

               closed. In some cases this is not desired, for example if the stream is a

               <see cref="T:System.IO.MemoryStream"/> that will be re-read after

               compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream

               open.

             </para>

             <para>

             See the other overloads of this constructor for example code.

             </para>

             </remarks>

             <param name="stream">The stream which will be read or written. This is called the

             "captive" stream in other places in this documentation.</param>

             <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>

             <param name="leaveOpen">true if the application would like the stream to remain

             open after inflation/deflation.</param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.#ctor(System.IO.Stream,Ionic.Zlib.CompressionMode,Ionic.Zlib.CompressionLevel,System.Boolean)">

             <summary>

               Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>

               and the specified <c>CompressionLevel</c>, and explicitly specify

               whether the stream should be left open after Deflation or Inflation.

             </summary>

             <remarks>

             <para>

               This constructor allows the application to request that the captive

               stream remain open after the deflation or inflation occurs.  By

               default, after <c>Close()</c> is called on the stream, the captive

               stream is also closed. In some cases this is not desired, for example

               if the stream is a <see cref="T:System.IO.MemoryStream"/> that will be

               re-read after compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream open.

             </para>

             <para>

               When mode is <c>CompressionMode.Decompress</c>, the level parameter is

               ignored.

             </para>

             </remarks>

             <example>

             This example shows how to use a ZlibStream to compress the data from a file,

             and store the result into another file. The filestream remains open to allow

             additional data to be written to it.

             <code>

             using (var output = System.IO.File.Create(fileToCompress + ".zlib"))

             {

                 using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))

                 {

                     using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))

                     {

                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];

                         int n;

                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)

                         {

                             compressor.Write(buffer, 0, n);

                         }

                     }

                 }

                 // can write additional data to the output stream here

             }

             </code>

             <code lang="VB">

             Using output As FileStream = File.Create(fileToCompress &amp; ".zlib")

                 Using input As Stream = File.OpenRead(fileToCompress)

                     Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)

                         Dim buffer As Byte() = New Byte(4096) {}

                         Dim n As Integer = -1

                         Do While (n &lt;&gt; 0)

                             If (n &gt; 0) Then

                                 compressor.Write(buffer, 0, n)

                             End If

                             n = input.Read(buffer, 0, buffer.Length)

                         Loop

                     End Using

                 End Using

                 ' can write additional data to the output stream here.

             End Using

             </code>

             </example>

             <param name="stream">The stream which will be read or written.</param>

             <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>

             <param name="leaveOpen">

             true if the application would like the stream to remain open after

             inflation/deflation.

             </param>

             <param name="level">

             A tuning knob to trade speed for effectiveness. This parameter is

             effective only when mode is <c>CompressionMode.Compress</c>.

             </param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.Dispose(System.Boolean)">

            <summary>

              Dispose the stream.

            </summary>

            <remarks>

              <para>

                This may or may not result in a <c>Close()</c> call on the captive

                stream.  See the constructors that have a <c>leaveOpen</c> parameter

                for more information.

              </para>

              <para>

                This method may be invoked in two distinct scenarios.  If disposing

                == true, the method has been called directly or indirectly by a

                user's code, for example via the public Dispose() method. In this

                case, both managed and unmanaged resources can be referenced and

                disposed.  If disposing == false, the method has been called by the

                runtime from inside the object finalizer and this method should not

                reference other objects; in that case only unmanaged resources must

                be referenced or disposed.

              </para>

            </remarks>

            <param name="disposing">

              indicates whether the Dispose method was invoked by user code.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.Read(System.Byte[],System.Int32,System.Int32)">

             <summary>

             Read data from the stream.

             </summary>

             <remarks>

             <para>

               If you wish to use the <c>ZlibStream</c> to compress data while reading,

               you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,

               providing an uncompressed data stream.  Then call <c>Read()</c> on that

               <c>ZlibStream</c>, and the data read will be compressed.  If you wish to

               use the <c>ZlibStream</c> to decompress data while reading, you can create

               a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, providing a

               readable compressed data stream.  Then call <c>Read()</c> on that

               <c>ZlibStream</c>, and the data will be decompressed as it is read.

             </para>

             <para>

               A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but

               not both.

             </para>

             </remarks>

             <param name="buffer">

             The buffer into which the read data should be placed.</param>

             <param name="offset">

             the offset within that data array to put the first byte read.</param>

             <param name="count">the number of bytes to read.</param>

             <returns>the number of bytes read</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.Seek(System.Int64,System.IO.SeekOrigin)">

             <summary>

             Calling this method always throws a <see cref="T:System.NotSupportedException"/>.

             </summary>

             <param name="offset">

               The offset to seek to....

               IF THIS METHOD ACTUALLY DID ANYTHING.

             </param>

             <param name="origin">

               The reference specifying how to apply the offset....  IF

               THIS METHOD ACTUALLY DID ANYTHING.

             </param>

             <returns>nothing. This method always throws.</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.SetLength(System.Int64)">

            <summary>

            Calling this method always throws a <see cref="T:System.NotSupportedException"/>.

            </summary>

            <param name="value">

              The new value for the stream length....  IF

              THIS METHOD ACTUALLY DID ANYTHING.

            </param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.Write(System.Byte[],System.Int32,System.Int32)">

             <summary>

             Write data to the stream.

             </summary>

             <remarks>

             <para>

               If you wish to use the <c>ZlibStream</c> to compress data while writing,

               you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,

               and a writable output stream.  Then call <c>Write()</c> on that

               <c>ZlibStream</c>, providing uncompressed data as input.  The data sent to

               the output stream will be the compressed form of the data written.  If you

               wish to use the <c>ZlibStream</c> to decompress data while writing, you

               can create a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, and a

               writable output stream.  Then call <c>Write()</c> on that stream,

               providing previously compressed data. The data sent to the output stream

               will be the decompressed form of the data written.

             </para>

             <para>

               A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.

             </para>

             </remarks>

             <param name="buffer">The buffer holding data to write to the stream.</param>

             <param name="offset">the offset within that data array to find the first byte to write.</param>

             <param name="count">the number of bytes to write.</param>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.CompressString(System.String)">

             <summary>

               Compress a string into a byte array using ZLIB.

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.ZlibStream.UncompressString(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressString(System.Byte[])"/>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressBuffer(System.Byte[])"/>

             <seealso cref="M:Ionic.Zlib.GZipStream.CompressString(System.String)"/>

             <param name="s">

               A string to compress.  The string will first be encoded

               using UTF8, then compressed.

             </param>

             <returns>The string in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.CompressBuffer(System.Byte[])">

             <summary>

               Compress a byte array into a new byte array using ZLIB.

             </summary>

             <remarks>

               Uncompress it with <see cref="M:Ionic.Zlib.ZlibStream.UncompressBuffer(System.Byte[])"/>.

             </remarks>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressString(System.String)"/>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressBuffer(System.Byte[])"/>

             <param name="b">

             A buffer to compress.

             </param>

             <returns>The data in compressed form</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.UncompressString(System.Byte[])">

             <summary>

               Uncompress a ZLIB-compressed byte array into a single string.

             </summary>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressString(System.String)"/>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressBuffer(System.Byte[])"/>

             <param name="compressed">

               A buffer containing ZLIB-compressed data.

             </param>

             <returns>The uncompressed string</returns>

        </member>

        <member name="M:Ionic.Zlib.ZlibStream.UncompressBuffer(System.Byte[])">

             <summary>

               Uncompress a ZLIB-compressed byte array into a byte array.

             </summary>

             <seealso cref="M:Ionic.Zlib.ZlibStream.CompressBuffer(System.Byte[])"/>

             <seealso cref="M:Ionic.Zlib.ZlibStream.UncompressString(System.Byte[])"/>

             <param name="compressed">

               A buffer containing ZLIB-compressed data.

             </param>

             <returns>The data in uncompressed form</returns>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.FlushMode">

            <summary>

            This property sets the flush behavior on the stream.

            Sorry, though, not sure exactly how to describe all the various settings.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.BufferSize">

             <summary>

               The size of the working buffer for the compression codec.

             </summary>

             <remarks>

             <para>

               The working buffer is used for all stream operations.  The default size is

               1024 bytes. The minimum size is 128 bytes. You may get better performance

               with a larger buffer.  Then again, you might not.  You would have to test

               it.

             </para>

             <para>

               Set this before the first call to <c>Read()</c> or <c>Write()</c> on the

               stream. If you try to set it afterwards, it will throw.

             </para>

             </remarks>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.TotalIn">

            <summary> Returns the total number of bytes input so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.TotalOut">

            <summary> Returns the total number of bytes output so far.</summary>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.CanRead">

            <summary>

            Indicates whether the stream can be read.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports reading.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.CanSeek">

            <summary>

            Indicates whether the stream supports Seek operations.

            </summary>

            <remarks>

            Always returns false.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.CanWrite">

            <summary>

            Indicates whether the stream can be written.

            </summary>

            <remarks>

            The return value depends on whether the captive stream supports writing.

            </remarks>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.Length">

            <summary>

            Reading this property always throws a <see cref="T:System.NotSupportedException"/>.

            </summary>

        </member>

        <member name="P:Ionic.Zlib.ZlibStream.Position">

             <summary>

               The position of the stream pointer.

             </summary>

             <remarks>

               Setting this property always throws a <see cref="T:System.NotSupportedException"/>. Reading will return the total bytes

               written out, if used in writing, or the total bytes read in, if used in

               reading.  The count may refer to compressed bytes or uncompressed bytes,

               depending on how you've used the stream.

             </remarks>

        </member>

        <member name="T:Ionic.Crc.CRC32">

            <summary>

              Computes a CRC-32. The CRC-32 algorithm is parameterized - you

              can set the polynomial and enable or disable bit

              reversal. This can be used for GZIP, BZip2, or ZIP.

            </summary>

            <remarks>

              This type is used internally by DotNetZip; it is generally not used

              directly by applications wishing to create, read, or manipulate zip

              archive files.

            </remarks>

        </member>

        <member name="M:Ionic.Crc.CRC32.GetCrc32(System.IO.Stream)">

            <summary>

            Returns the CRC32 for the specified stream.

            </summary>

            <param name="input">The stream over which to calculate the CRC32</param>

            <returns>the CRC32 calculation</returns>

        </member>

        <member name="M:Ionic.Crc.CRC32.GetCrc32AndCopy(System.IO.Stream,System.IO.Stream)">

            <summary>

            Returns the CRC32 for the specified stream, and writes the input into the

            output stream.

            </summary>

            <param name="input">The stream over which to calculate the CRC32</param>

            <param name="output">The stream into which to deflate the input</param>

            <returns>the CRC32 calculation</returns>

        </member>

        <member name="M:Ionic.Crc.CRC32.ComputeCrc32(System.Int32,System.Byte)">

            <summary>

              Get the CRC32 for the given (word,byte) combo.  This is a

              computation defined by PKzip for PKZIP 2.0 (weak) encryption.

            </summary>

            <param name="W">The word to start with.</param>

            <param name="B">The byte to combine it with.</param>

            <returns>The CRC-ized result.</returns>

        </member>

        <member name="M:Ionic.Crc.CRC32.SlurpBlock(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Update the value for the running CRC32 using the given block of bytes.

            This is useful when using the CRC32() class in a Stream.

            </summary>

            <param name="block">block of bytes to slurp</param>

            <param name="offset">starting point in the block</param>

            <param name="count">how many bytes within the block to slurp</param>

        </member>

        <member name="M:Ionic.Crc.CRC32.UpdateCRC(System.Byte)">

            <summary>

              Process one byte in the CRC.

            </summary>

            <param name = "b">the byte to include into the CRC .  </param>

        </member>

        <member name="M:Ionic.Crc.CRC32.UpdateCRC(System.Byte,System.Int32)">

            <summary>

              Process a run of N identical bytes into the CRC.

            </summary>

            <remarks>

              <para>

                This method serves as an optimization for updating the CRC when a

                run of identical bytes is found. Rather than passing in a buffer of

                length n, containing all identical bytes b, this method accepts the

                byte value and the length of the (virtual) buffer - the length of

                the run.

              </para>

            </remarks>

            <param name = "b">the byte to include into the CRC.  </param>

            <param name = "n">the number of times that byte should be repeated. </param>

        </member>

        <member name="M:Ionic.Crc.CRC32.Combine(System.Int32,System.Int32)">

            <summary>

              Combines the given CRC32 value with the current running total.

            </summary>

            <remarks>

              This is useful when using a divide-and-conquer approach to

              calculating a CRC.  Multiple threads can each calculate a

              CRC32 on a segment of the data, and then combine the

              individual CRC32 values at the end.

            </remarks>

            <param name="crc">the crc value to be combined with this one</param>

            <param name="length">the length of data the CRC value was calculated on</param>

        </member>

        <member name="M:Ionic.Crc.CRC32.#ctor">

            <summary>

              Create an instance of the CRC32 class using the default settings: no

              bit reversal, and a polynomial of 0xEDB88320.

            </summary>

        </member>

        <member name="M:Ionic.Crc.CRC32.#ctor(System.Boolean)">

            <summary>

              Create an instance of the CRC32 class, specifying whether to reverse

              data bits or not.

            </summary>

            <param name='reverseBits'>

              specify true if the instance should reverse data bits.

            </param>

            <remarks>

              <para>

                In the CRC-32 used by BZip2, the bits are reversed. Therefore if you

                want a CRC32 with compatibility with BZip2, you should pass true

                here. In the CRC-32 used by GZIP and PKZIP, the bits are not

                reversed; Therefore if you want a CRC32 with compatibility with

                those, you should pass false.

              </para>

            </remarks>

        </member>

        <member name="M:Ionic.Crc.CRC32.#ctor(System.Int32,System.Boolean)">

             <summary>

               Create an instance of the CRC32 class, specifying the polynomial and

               whether to reverse data bits or not.

             </summary>

             <param name='polynomial'>

               The polynomial to use for the CRC, expressed in the reversed (LSB)

               format: the highest ordered bit in the polynomial value is the

               coefficient of the 0th power; the second-highest order bit is the

               coefficient of the 1 power, and so on. Expressed this way, the

               polynomial for the CRC-32C used in IEEE 802.3, is 0xEDB88320.

             </param>

             <param name='reverseBits'>

               specify true if the instance should reverse data bits.

             </param>

             <remarks>

               <para>

                 In the CRC-32 used by BZip2, the bits are reversed. Therefore if you

                 want a CRC32 with compatibility with BZip2, you should pass true

                 here for the <c>reverseBits</c> parameter. In the CRC-32 used by

                 GZIP and PKZIP, the bits are not reversed; Therefore if you want a

                 CRC32 with compatibility with those, you should pass false for the

                 <c>reverseBits</c> parameter.

               </para>

             </remarks>

        </member>

        <member name="M:Ionic.Crc.CRC32.Reset">

            <summary>

              Reset the CRC-32 class - clear the CRC "remainder register."

            </summary>

            <remarks>

              <para>

                Use this when employing a single instance of this class to compute

                multiple, distinct CRCs on multiple, distinct data blocks.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Crc.CRC32.TotalBytesRead">

            <summary>

              Indicates the total number of bytes applied to the CRC.

            </summary>

        </member>

        <member name="P:Ionic.Crc.CRC32.Crc32Result">

            <summary>

            Indicates the current CRC for all blocks slurped in.

            </summary>

        </member>

        <member name="T:Ionic.Crc.CrcCalculatorStream">

             <summary>

             A Stream that calculates a CRC32 (a checksum) on all bytes read,

             or on all bytes written.

             </summary>

             <remarks>

             <para>

             This class can be used to verify the CRC of a ZipEntry when

             reading from a stream, or to calculate a CRC when writing to a

             stream.  The stream should be used to either read, or write, but

             not both.  If you intermix reads and writes, the results are not

             defined.

             </para>

             <para>

             This class is intended primarily for use internally by the

             DotNetZip library.

             </para>

             </remarks>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.#ctor(System.IO.Stream)">

            <summary>

            The default constructor.

            </summary>

            <remarks>

              <para>

                Instances returned from this constructor will leave the underlying

                stream open upon Close().  The stream uses the default CRC32

                algorithm, which implies a polynomial of 0xEDB88320.

              </para>

            </remarks>

            <param name="stream">The underlying stream</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.#ctor(System.IO.Stream,System.Boolean)">

            <summary>

              The constructor allows the caller to specify how to handle the

              underlying stream at close.

            </summary>

            <remarks>

              <para>

                The stream uses the default CRC32 algorithm, which implies a

                polynomial of 0xEDB88320.

              </para>

            </remarks>

            <param name="stream">The underlying stream</param>

            <param name="leaveOpen">true to leave the underlying stream

            open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.#ctor(System.IO.Stream,System.Int64)">

            <summary>

              A constructor allowing the specification of the length of the stream

              to read.

            </summary>

            <remarks>

              <para>

                The stream uses the default CRC32 algorithm, which implies a

                polynomial of 0xEDB88320.

              </para>

              <para>

                Instances returned from this constructor will leave the underlying

                stream open upon Close().

              </para>

            </remarks>

            <param name="stream">The underlying stream</param>

            <param name="length">The length of the stream to slurp</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.#ctor(System.IO.Stream,System.Int64,System.Boolean)">

            <summary>

              A constructor allowing the specification of the length of the stream

              to read, as well as whether to keep the underlying stream open upon

              Close().

            </summary>

            <remarks>

              <para>

                The stream uses the default CRC32 algorithm, which implies a

                polynomial of 0xEDB88320.

              </para>

            </remarks>

            <param name="stream">The underlying stream</param>

            <param name="length">The length of the stream to slurp</param>

            <param name="leaveOpen">true to leave the underlying stream

            open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.#ctor(System.IO.Stream,System.Int64,System.Boolean,Ionic.Crc.CRC32)">

            <summary>

              A constructor allowing the specification of the length of the stream

              to read, as well as whether to keep the underlying stream open upon

              Close(), and the CRC32 instance to use.

            </summary>

            <remarks>

              <para>

                The stream uses the specified CRC32 instance, which allows the

                application to specify how the CRC gets calculated.

              </para>

            </remarks>

            <param name="stream">The underlying stream</param>

            <param name="length">The length of the stream to slurp</param>

            <param name="leaveOpen">true to leave the underlying stream

            open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>

            <param name="crc32">the CRC32 instance to use to calculate the CRC32</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.Read(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Read from the stream

            </summary>

            <param name="buffer">the buffer to read</param>

            <param name="offset">the offset at which to start</param>

            <param name="count">the number of bytes to read</param>

            <returns>the number of bytes actually read</returns>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.Write(System.Byte[],System.Int32,System.Int32)">

            <summary>

            Write to the stream.

            </summary>

            <param name="buffer">the buffer from which to write</param>

            <param name="offset">the offset at which to start writing</param>

            <param name="count">the number of bytes to write</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.Flush">

            <summary>

            Flush the stream.

            </summary>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.Seek(System.Int64,System.IO.SeekOrigin)">

            <summary>

            Seeking is not supported on this stream. This method always throws

            <see cref="T:System.NotSupportedException"/>

            </summary>

            <param name="offset">N/A</param>

            <param name="origin">N/A</param>

            <returns>N/A</returns>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.SetLength(System.Int64)">

            <summary>

            This method always throws

            <see cref="T:System.NotSupportedException"/>

            </summary>

            <param name="value">N/A</param>

        </member>

        <member name="M:Ionic.Crc.CrcCalculatorStream.Close">

            <summary>

            Closes the stream.

            </summary>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.TotalBytesSlurped">

             <summary>

               Gets the total number of bytes run through the CRC32 calculator.

             </summary>

             <remarks>

               This is either the total number of bytes read, or the total number of

               bytes written, depending on the direction of this stream.

             </remarks>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.Crc">

            <summary>

              Provides the current CRC for all blocks slurped in.

            </summary>

            <remarks>

              <para>

                The running total of the CRC is kept as data is written or read

                through the stream.  read this property after all reads or writes to

                get an accurate CRC for the entire stream.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.LeaveOpen">

            <summary>

              Indicates whether the underlying stream will be left open when the

              <c>CrcCalculatorStream</c> is Closed.

            </summary>

            <remarks>

              <para>

                Set this at any point before calling <see cref="M:Ionic.Crc.CrcCalculatorStream.Close"/>.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.CanRead">

            <summary>

            Indicates whether the stream supports reading.

            </summary>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.CanSeek">

            <summary>

              Indicates whether the stream supports seeking.

            </summary>

            <remarks>

              <para>

                Always returns false.

              </para>

            </remarks>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.CanWrite">

            <summary>

            Indicates whether the stream supports writing.

            </summary>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.Length">

            <summary>

              Returns the length of the underlying stream.

            </summary>

        </member>

        <member name="P:Ionic.Crc.CrcCalculatorStream.Position">

            <summary>

              The getter for this property returns the total bytes read.

              If you use the setter, it will throw

            <see cref="T:System.NotSupportedException"/>.

            </summary>

        </member>

    </members>

</doc>