Inheritance: System.IO.Stream
Exemplo n.º 1
0
 /// <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="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>
 public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _innerStream = stream;
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen);
 }
 /// <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="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>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
 }
 /// <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>
 public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
 }
Exemplo n.º 4
0
 /// <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="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>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
 }
 internal ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, true, leaveOpen);
 }
Exemplo n.º 6
0
 /// <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="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="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>
 public DeflateStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     //_innerStream = stream;
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen);
 }
Exemplo n.º 7
0
 /// <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="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>
 /// <param name="sharedDictionary">
 /// Shared dictionary to use for compression or decompression
 /// </param>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, byte[] sharedDictionary)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen, sharedDictionary);
 }
Exemplo n.º 8
0
 /// <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>
 public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
 }