Export (0) Print
Expand All

DeflateStream.BeginWrite Method

Note: This method is new in the .NET Framework version 2.0.

Begins an asynchronous write operation.

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

public:
virtual IAsyncResult^ BeginWrite (
	array<unsigned char>^ array, 
	int offset, 
	int count, 
	AsyncCallback^ asyncCallback, 
	Object^ asyncState
) override
public IAsyncResult BeginWrite (
	byte[] array, 
	int offset, 
	int count, 
	AsyncCallback asyncCallback, 
	Object asyncState
)
public override function BeginWrite (
	array : byte[], 
	offset : int, 
	count : int, 
	asyncCallback : AsyncCallback, 
	asyncState : Object
) : IAsyncResult

Parameters

array

The buffer to write data from

offset

The byte offset in buffer to begin writing from.

count

The maximum number of bytes to write.

asyncCallback

An optional asynchronous callback, to be called when the write is complete.

asyncState

A user-provided object that distinguishes this particular asynchronous write request from other requests.

Return Value

An IAsyncResult object that represents the asynchronous write, which could still be pending.

Exception typeCondition

IOException

An asynchronous write past the end of the stream was attempted, or a disk error occurred.

ArgumentException

One or more of the arguments is invalid.

ObjectDisposedException

Methods were called after the stream was closed.

NotSupportedException

The current DeflateStream implementation does not support the write operation.

Pass the IAsyncResult object returned by the current method to EndWrite to ensure that the write completes and frees resources appropriately. You can do this either by using the same code that called BeginWrite or in a callback passed to BeginWrite. If an error occurs during an asynchronous write, an exception will not be thrown until EndWrite is called with the IAsyncResult returned by this method.

If a stream is writable, writing at the end of the stream expands the stream.

The current position in the stream is updated when you issue the asynchronous read or write, not when the I/O operation completes. Multiple simultaneous asynchronous requests render the request completion order uncertain.

Use the CanWrite property to determine whether the current DeflateStream object supports writing.

If a stream is closed or you pass an invalid argument, exceptions are thrown immediately from BeginWrite. Errors that occur during an asynchronous write request, such as a disk failure during the I/O request, occur on the thread pool thread and throw exceptions when calling EndWrite.

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

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::IO::Compression;
int ReadAllBytesFromStream( Stream^ stream, array<Byte>^buffer )
{
   
   // Use this method is used to read all bytes from a stream.
   int offset = 0;
   int totalCount = 0;
   for ( ; ;  )
   {
      int bytesRead = stream->Read( buffer, offset, 100 );
      if ( bytesRead == 0 )
      {
         break;
      }

      offset += bytesRead;
      totalCount += bytesRead;

   }
   return totalCount;
}

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

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

   }
   Console::WriteLine( "All bytes compare." );
   return true;
}

void DeflateCompressDecompress( String^ filename )
{
   Console::WriteLine( "Test compression and decompression on file {0}", filename );
   FileStream^ infile;
   try
   {
      
      // Open the file as a FileStream object.
      infile = gcnew FileStream( filename,FileMode::Open,FileAccess::Read,FileShare::Read );
      array<Byte>^buffer = gcnew array<Byte>((int)infile->Length);
      
      // Read the file to ensure it is readable.
      int count = infile->Read( buffer, 0, buffer->Length );
      if ( count != buffer->Length )
      {
         infile->Close();
         Console::WriteLine( "Test Failed: Unable to read data from file" );
         return;
      }
      infile->Close();
      MemoryStream^ ms = gcnew MemoryStream;
      
      // Use the newly created memory stream for the compressed data.
      DeflateStream ^ compressedzipStream = gcnew DeflateStream( ms,CompressionMode::Compress,true );
      Console::WriteLine( "Compression" );
      compressedzipStream->Write( buffer, 0, buffer->Length );
      
      // Close the stream.
      compressedzipStream->Close();
      Console::WriteLine( "Original size: {0}, Compressed size: {1}", buffer->Length, ms->Length );
      
      // Reset the memory stream position to begin decompression.
      ms->Position = 0;
      DeflateStream ^ zipStream = gcnew DeflateStream( ms,CompressionMode::Decompress );
      Console::WriteLine( "Decompression" );
      array<Byte>^decompressedBuffer = gcnew array<Byte>(buffer->Length + 100);
      
      // Use the ReadAllBytesFromStream to read the stream.
      int totalCount = ReadAllBytesFromStream( zipStream, decompressedBuffer );
      Console::WriteLine( "Decompressed {0} bytes", totalCount );
      if (  !CompareData( buffer, buffer->Length, decompressedBuffer, totalCount ) )
      {
         Console::WriteLine( "Error. The two buffers did not compare." );
      }
      zipStream->Close();
   }
   catch ( InvalidDataException ^ ) 
   {
      Console::WriteLine( "Error: The file being read contains invalid data." );
   }
   catch ( FileNotFoundException^ ) 
   {
      Console::WriteLine( "Error:The file specified was not found." );
   }
   catch ( ArgumentException^ ) 
   {
      Console::WriteLine( "Error: path is a zero-length string, contains only white space, or contains one or more invalid characters" );
   }
   catch ( PathTooLongException^ ) 
   {
      Console::WriteLine( "Error: The specified path, file name, or both exceed the system-defined maximum length."
      " For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters." );
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The specified path is invalid, such as being on an unmapped drive." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: An I/O error occurred while opening the file." );
   }
   catch ( UnauthorizedAccessException^ ) 
   {
      Console::WriteLine( "Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions." );
   }
   catch ( IndexOutOfRangeException^ ) 
   {
      Console::WriteLine( "Error: You must provide parameters for MyGZIP." );
   }

}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: DeflateTest <inputfilename>";
   
   //If no file name is specified, write usage text.
   if ( args->Length == 1 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      if ( File::Exists( args[ 1 ] ) )
            DeflateCompressDecompress( args[ 1 ] );
   }
}


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

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

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

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

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

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

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

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

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

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

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

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

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

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0

Community Additions

ADD
Show:
© 2014 Microsoft