BCL mscorlib [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ] 1.0.5000.0 2.0.0.0 4.0.0.0 All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe. System.MarshalByRefObject System.IDisposable System.Runtime.InteropServices.ComVisible(true)

is the abstract base class of all streams. A stream is an abstraction of a sequence of bytes, such as a file, an input/output device, an inter-process communication pipe, or a TCP/IP socket. The class and its derived classes provide a generic view of these different types of input and output, and isolate the programmer from the specific details of the operating system and the underlying devices.

Streams involve three fundamental operations:

You can read from streams. Reading is the transfer of data from a stream into a data structure, such as an array of bytes.

You can write to streams. Writing is the transfer of data from a data structure into a stream.

Streams can support seeking. Seeking refers to querying and modifying the current position within a stream. Seek capability depends on the kind of backing store a stream has. For example, network streams have no unified concept of a current position, and therefore typically do not support seeking.

Some of the more commonly used streams that inherit from are , and .

Depending on the underlying data source or repository, streams might support only some of these capabilities. You can query a stream for its capabilities by using the , , and properties of the class.

The and methods read and write data in a variety of formats. For streams that support seeking, use the and methods and the and properties to query and modify the current position and length of a stream.

Starting with the net_v45, the class includes async methods to simplify asynchronous operations. An async method contains Async in its name, such as , , , and . These methods enable you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

When used in a win8_appname_long app, includes two extension methods: and . These methods convert a object to a stream in the wrt. You can also convert a stream in the wrt to a object by using the and methods. For more information, see How to: Convert Between .NET Framework Streams and Windows Runtime Streams

Some stream implementations perform local buffering of the underlying data to improve performance. For such streams, you can use the or method to clear any internal buffers and ensure that all data has been written to the underlying data source or repository.

Disposing a object flushes any buffered data, and essentially calls the method for you. also releases operating system resources such as file handles, network connections, or memory used for any internal buffering. The class provides the capability of wrapping a buffered stream around another stream in order to improve read and write performance.

If you need a stream with no backing store (also known as a bit bucket), use the field to retrieve an instance of a stream that is designed for this purpose.

Provides a generic view of a sequence of bytes. This is an abstract class.

- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  is the abstract base class of all streams.

  Some of the more commonly used streams that inherit from are , and .

  Initializes a new instance of the class.

  0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.IAsyncResult `` `` `` `` `` An I/O error occurred. The current does not support reading. The stream is closed.

  In the .NET Framework 4 and earlier versions, you have to use methods such as and to implement asynchronous I/O operations. These methods are still available in the net_v45 to support legacy code; however, the new async methods, such as , , , and , help you implement asynchronous I/O operations more easily.

  The default implementation of BeginRead on a stream calls the method synchronously, which means that Read might block on some streams. However, instances of classes such as FileStream and NetworkStream fully support asynchronous operations if the instances have been opened asynchronously. Therefore, calls to BeginRead will not block on those streams. You can override BeginRead (by using async delegates, for example) to provide asynchronous behavior.

  Pass the IAsyncResult return value to the method of the stream to determine how many bytes were read and to release operating system resources used for reading. must be called once for every call to . You can do this either by using the same code that called BeginRead or in a callback passed to BeginRead.

  The current position in the stream is updated when the asynchronous read or write is issued, not when the I/O operation completes.

  Multiple simultaneous asynchronous requests render the request completion order uncertain.

  Use the property to determine whether the current instance supports reading.

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

  Begins an asynchronous read operation. (Consider using instead; see the Remarks section.)

  An that represents the asynchronous read, which could still be pending.

  The buffer to read the data into. The byte offset in at which to begin writing data read from the stream. The maximum number of bytes to read. An optional asynchronous callback, to be called when the read is complete. A user-provided object that distinguishes this particular asynchronous read request from other requests. 0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.IAsyncResult `` `` `` `` `` The current does not support writing. An I/O error occurred. The stream is closed.

  In the .NET Framework 4 and earlier versions, you have to use methods such as and to implement asynchronous I/O operations. These methods are still available in the net_v45 to support legacy code; however, the new async methods, such as , , , and , help you implement asynchronous I/O operations more easily.

  The default implementation of BeginWrite on a stream calls the method synchronously, which means that Write might block on some streams. However, instances of classes such as FileStream and NetworkStream fully support asynchronous operations if the instances have been opened asynchronously. Therefore, calls to BeginWrite will not block on those streams. You can override BeginWrite (by using async delegates, for example) to provide asynchronous behavior.

  Pass the IAsyncResult returned by the current method to to ensure that the write completes and frees resources appropriately. must be called once for every call to . 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 property to determine whether the current instance 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.

  Begins an asynchronous write operation. (Consider using instead; see the Remarks section.)

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

  The buffer to write data from. The byte offset in from which to begin writing. The maximum number of bytes to write. An optional asynchronous callback, to be called when the write is complete. A user-provided object that distinguishes this particular asynchronous write request from other requests. 0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean

  if the stream supports reading; otherwise, .

  If a class derived from does not support reading, calls to the , , and methods throw a .

  If the stream is closed, this property returns false.

  When overridden in a derived class, gets a value indicating whether the current stream supports reading.

  0
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean

  if the stream supports seeking; otherwise, .

  If a class derived from does not support seeking, calls to , , , and throw a .

  If the stream is closed, this property returns false.

  When overridden in a derived class, gets a value indicating whether the current stream supports seeking.

  0
- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Boolean To be added.

  The property always returns false. Some stream implementations require different behavior, such as , which times out if network connectivity is interrupted or lost. If you are implementing a stream that must be able to time out, this property should be overridden to return true.

  Gets a value that determines whether the current stream can time out.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean

  if the stream supports writing; otherwise, .

  If a class derived from does not support writing, a call to , , or throws a .

  If the stream is closed, this property returns false.

  When overridden in a derived class, gets a value indicating whether the current stream supports writing.

  0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  This method calls , specifying true to release all resources. You do not have to specifically call the method. Instead, ensure that every object is properly disposed. You can declare objects within a using block (or Using block in Visual Basic) to ensure that the stream and all of its resources are disposed, or you can explicitly call the method.

  Flushing the stream will not flush its underlying encoder unless you explicitly call an implementation of or Close. Setting to true means that data will be flushed from the buffer to the stream, but the encoder state will not be flushed. This allows the encoder to keep its state (partial characters) so that it can encode the next block of characters correctly. This scenario affects UTF8 and UTF7 where certain characters can be encoded only after the encoder receives the adjacent character or characters.

  Attempts to manipulate the stream after the stream has been closed might throw an .

  Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Instead of calling this method, ensure that the stream is properly disposed.

  0
- Method
  4.0.0.0
  System.Void ``

  Copying begins at the current position in the current stream, and does not reset the position of the destination stream after the copy operation is complete.

  Reads the bytes from the current stream and writes them to another stream.

  The stream to which the contents of the current stream will be copied.
- Method
  4.0.0.0
  System.Void `` ``

  Copying begins at the current position in the current stream, and does not reset the position of the destination stream after the copy operation is complete.

  Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

  The stream to which the contents of the current stream will be copied. The size of the buffer. This value must be greater than zero. The default size is 4096.
- Method
  4.0.0.0
  System.Threading.Tasks.Task ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Copying begins at the current position in the current stream.

  Asynchronously reads the bytes from the current stream and writes them to another stream.

  A task that represents the asynchronous copy operation.

  The stream to which the contents of the current stream will be copied.
- Method
  4.0.0.0
  System.Threading.Tasks.Task `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Copying begins at the current position in the current stream.

  For an example of copying between two streams, see the overload.

  Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

  A task that represents the asynchronous copy operation.

  The stream to which the contents of the current stream will be copied. The size, in bytes, of the buffer. This value must be greater than zero. The default size is 4096.
- Method
  4.0.0.0
  System.Threading.Tasks.Task `` `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  If the operation is canceled before it completes, the returned task contains the value for the property.

  Copying begins at the current position in the current stream.

  For an example of copying between two streams, see the overload.

  Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

  A task that represents the asynchronous copy operation.

  The stream to which the contents of the current stream will be copied. The size, in bytes, of the buffer. This value must be greater than zero. The default size is 4096. The token to monitor for cancellation requests. The default value is .
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Obsolete("CreateWaitHandle is due for removal. Use "new ManualResetEvent(false)" instead.")
  System.Threading.WaitHandle

  When called for the first time, the current method creates a WaitHandle object and returns it. On subsequent calls, CreateWaitHandle returns a reference to a new wait handle.

  Use this method if you implement the asynchronous methods and require a way of blocking in or until the asynchronous operation is complete.

  Allocates a object.

  A reference to the allocated WaitHandle.

  0
- Method
  2.0.0.0
  4.0.0.0
  System.Void

  This method disposes the stream, by writing any changes to the backing store and closing the stream to release resources.

  Calling Dispose allows the resources used by the to be reallocated for other purposes. For more information about Dispose, see Cleaning Up Unmanaged Resources.

  Releases all resources used by the .

- Method
  2.0.0.0
  4.0.0.0
  System.Void ``

  You should release all resources by specifying true for . When is true, the stream can also ensure data is flushed to the underlying buffer, and access other finalizable objects. This may not be possible when called from a finalizer due a lack of ordering among finalizers.

  If your stream is using an operating system handle to communicate with its source, consider using a subclass of for this purpose.

  This method is called by the public method and the method. invokes the protected method with the parameter set to true. invokes with set to false.

  Releases the unmanaged resources used by the and optionally releases the managed resources.

  true to release both managed and unmanaged resources; false to release only unmanaged resources.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 `` is . did not originate from a method on the current stream.

  In the .NET Framework 4 and earlier versions, you have to use methods such as and to implement asynchronous I/O operations. These methods are still available in the net_v45 to support legacy code; however, the new async methods, such as , , , and , help you implement asynchronous I/O operations more easily.

  Call EndRead to determine how many bytes were read from the stream.

  EndRead can be called once on every from .

  This method blocks until the I/O operation has completed.

  Waits for the pending asynchronous read to complete. (Consider using instead; see the Remarks section.)

  The number of bytes read from the stream, between zero (0) and the number of bytes you requested. Streams return zero (0) only at the end of the stream, otherwise, they should block until at least one byte is available.

  The reference to the pending asynchronous request to finish. 0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` The parameter is . did not originate from a method on the current stream.

  In the .NET Framework 4 and earlier versions, you have to use methods such as and to implement asynchronous I/O operations. These methods are still available in the net_v45 to support legacy code; however, the new async methods, such as , , , and , help you implement asynchronous I/O operations more easily.

  EndWrite must be called exactly once on every from .

  This method blocks until the I/O operation has completed. 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 become visible upon a call to EndWrite. Exceptions thrown by the thread pool thread will not be visible when calling EndWrite.

  Ends an asynchronous write operation. (Consider using instead; see the Remarks section.)

  A reference to the outstanding asynchronous I/O request. 0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void An I/O error occurs. The stream is closed.

  Override Flush on streams that implement a buffer. Use this method to move any information from an underlying buffer to its destination, clear the buffer, or both. Depending upon the state of the object, you might have to modify the current position within the stream (for example, if the underlying stream supports seeking). For additional information see .

  When using the or class, do not flush the base object. Instead, use the class's or method, which makes sure that the data is flushed to the underlying stream first and then written to the file.

  When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.

  0
- Method
  4.0.0.0
  System.Threading.Tasks.Task

  If a derived class, such as or , does not flush the buffer in its implementation of the method, the method will not flush the buffer.

  Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

  A task that represents the asynchronous flush operation.

- Method
  4.0.0.0
  System.Threading.Tasks.Task ``

  If the operation is canceled before it completes, the returned task contains the value for the property.

  If a derived class, such as or , does not flush the buffer in its implementation of the method, the method will not flush the buffer.

  Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

  A task that represents the asynchronous flush operation.

  The token to monitor for cancellation requests. The default value is .
- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int64

  A value representing the length of the stream in bytes.

  Use the property to determine whether the current instance supports seeking.

  This property is read-only.

  The stream does not support seeking. The stream is closed.

  When overridden in a derived class, gets the length in bytes of the stream.

  0
- Field
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.IO.Stream

  Use Null to redirect output to a stream that will not consume any operating system resources. When the methods of Stream that provide writing are invoked on Null, the call simply returns, and no data is written. Null also implements a Read method that returns zero without reading data.

  A Stream with no backing store.

  0
- Method
  4.0.0.0
  System.Obsolete("Do not call or override this method")
  System.Void To be added.

  Provides support for a .

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int64

  A that specifies the current position within the stream.

  An I/O error has occurred. The stream does not support seeking. The stream is closed.

  The stream must support seeking to get or set the position. Use the property to determine whether the stream supports seeking.

  Seeking to any location beyond the length of the stream is supported.

  The Position property does not keep track of the number of bytes from the stream that have been consumed, skipped, or both.

  When overridden in a derived class, gets or sets the position within the current stream.

  0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 `` `` `` ( + - 1) is greater than the length of . is . or is less than zero. An I/O error occurred. The current stream does not support reading. The stream is closed.

  Use the property to determine whether the current instance supports reading. Use the method to read asynchronously from the current stream.

  Implementations of this method read a maximum of bytes from the current stream and store them in beginning at . The current position within the stream is advanced by the number of bytes read; however, if an exception occurs, the current position within the stream remains unchanged. Implementations return the number of bytes read. The implementation will block until at least one byte of data can be read, in the event that no data is available. Read returns 0 only when there is no more data in the stream and no more is expected (such as a closed socket or end of file). An implementation is free to return fewer bytes than requested even if the end of the stream has not been reached.

  Use for reading primitive data types.

  When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

  The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.

  An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. The zero-based byte offset in at which to begin storing the data read from the current stream. The maximum number of bytes to be read from the current stream. 0
- Method
  4.0.0.0
  System.Threading.Tasks.Task<System.Int32> `` `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Use the property to determine whether the current instance supports reading.

  Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

  A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached.

  The buffer to write the data into. The byte offset in at which to begin writing data from the stream. The maximum number of bytes to read.
- Method
  4.0.0.0
  System.Threading.Tasks.Task<System.Int32> `` `` `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Use the property to determine whether the current instance supports reading.

  If the operation is canceled before it completes, the returned task contains the value for the property.

  For an example, see the overload.

  Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

  A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached.

  The buffer to write the data into. The byte offset in at which to begin writing data from the stream. The maximum number of bytes to read. The token to monitor for cancellation requests. The default value is .
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int32 An I/O error has occurred. The stream does not support reading. The stream is closed.

  Use the property to determine whether the current instance supports reading.

  Attempts to manipulate the stream after the stream has been closed could throw an .

  Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

  The unsigned byte cast to an Int32, or -1 if at the end of the stream.

  0
- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Int32 To be added. To be added.

  Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Int64 `` `` The stream does not support seeking, such as if the stream is constructed from a pipe or console output. The stream is closed. An I/O error has occurred.

  Use the property to determine whether the current instance supports seeking.

  If is negative, the new position is required to precede the position specified by by the number of bytes specified by . If is zero (0), the new position is required to be the position specified by . If is positive, the new position is required to follow the position specified by by the number of bytes specified by .

  Classes derived from Stream that support seeking must override this method to provide the functionality described above.

  Seeking to any location beyond the length of the stream is supported.

  When overridden in a derived class, sets the position within the current stream.

  The new position within the current stream.

  A byte offset relative to the parameter. A value of type indicating the reference point used to obtain the new position. 0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. The stream is closed. An I/O error occurred.

  If the specified value is less than the current length of the stream, the stream is truncated. If the specified value is larger than the current length of the stream, the stream is expanded. If the stream is expanded, the contents of the stream between the old and the new length are not defined.

  A stream must support both writing and seeking for SetLength to work.

  Use the property to determine whether the current instance supports writing, and the property to determine whether seeking is supported.

  When overridden in a derived class, sets the length of the current stream.

  The desired length of the current stream in bytes. 0
- Method
  2.0.0.0
  4.0.0.0
  System.IO.Stream ``

  This method returns a class that wraps the specified object and restricts access to it from multiple threads. All access to the object will be thread safe.

  Creates a thread-safe (synchronized) wrapper around the specified object.

  A thread-safe object.

  The object to synchronize.
- Method
  System.Void Implemented to support the interface. [Note: For more information, see .] To be added. 1.0.5000.0
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` `` `` ( + ) is greater than the length of . is . or is negative. An I/O error occurred. The stream does not support writing. The stream is closed.

  Use the property to determine whether the current instance supports writing. Use the method to write asynchronously to the current stream.

  If the write operation is successful, the position within the stream advances by the number of bytes written. If an exception occurs, the position within the stream remains unchanged.

  When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

  An array of bytes. This method copies bytes from to the current stream. The zero-based byte offset in at which to begin copying bytes to the current stream. The number of bytes to be written to the current stream. 0
- Method
  4.0.0.0
  System.Threading.Tasks.Task `` `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Use the property to determine whether the current instance supports writing.

  Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

  A task that represents the asynchronous write operation.

  The buffer to write data from. The zero-based byte offset in from which to begin copying bytes to the stream. The maximum number of bytes to write.
- Method
  4.0.0.0
  System.Threading.Tasks.Task `` `` `` ``

  The method enables you to perform resource-intensive I/O operations without blocking the main thread. This performance consideration is particularly important in a win8_appname_long app or desktop_appname app where a time-consuming stream operation can block the UI thread and make your app appear as if it is not working. The async methods are used in conjunction with the async and await keywords in Visual Basic and C#.

  Use the property to determine whether the current instance supports writing.

  If the operation is canceled before it completes, the returned task contains the value for the property.

  For an example, see the overload.

  Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

  A task that represents the asynchronous write operation.

  The buffer to write data from. The zero-based byte offset in from which to begin copying bytes to the stream. The maximum number of bytes to write. The token to monitor for cancellation requests. The default value is .
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void `` An I/O error has occurred. The stream does not support writing. The stream is closed.

  Use the property to determine whether the current instance supports writing.

  Writes a byte to the current position in the stream and advances the position within the stream by one byte.

  The byte to write to the stream. 0
- Property
  2.0.0.0
  4.0.0.0
  System.Runtime.InteropServices.ComVisible(false)
  System.Int32 To be added. To be added.

  Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out.

0