C# (CSharp) System.IO Namespace

Nested Namespaces

System.IO.Abstractions
System.IO.BACnet
System.IO.Compression
System.IO.FileFormats
System.IO.FileSystem
System.IO.IsolatedStorage
System.IO.Log
System.IO.MemoryMappedFiles
System.IO.Packaging
System.IO.Pipelines
System.IO.Pipes
System.IO.Ports
System.IO.Preparations
System.IO.Strategies
System.IO.Tests

Сlasses

Name Description
@__FileStream
@__FileStream.ContructionHelper
@__IOException
@__IOException.ContructionHelper
@__Stream
@__Stream.ContructionHelper
@__TextReader
@__TextReader.ContructionHelper
@__TextWriter
@__TextWriter.ContructionHelper
BigEndianWriter A class for writing to BigEndian streams (i.e. Network or Video). Designed to be a drop-in replacement for System.IO.BinaryWriter
BinaryReader
BinaryWriter
BinaryWriterExtensions
BitSplitter Splits a byte array into values, based on a series of bit lengths Translations are done from network byte order.
Blob
BlobEvent
BlobEventInit
BlobPropertyBag
BufferedStream One of the design goals here is to prevent the buffer from getting in the way and slowing down underlying stream accesses when it is not needed. If you always read & write for sizes greater than the internal buffer size, then this class may not even allocate the internal buffer. See a large comment in Write for the details of the write buffer heuristic. This class buffers reads & writes in a shared buffer. (If you maintained two buffers separately, one operation would always trash the other buffer anyways, so we might as well use one buffer.) The assumption here is you will almost always be doing a series of reads or writes, but rarely alternate between the two of them on the same stream. Class Invariants: The class has one buffer, shared for reading & writing. It can only be used for one or the other at any point in time - not both. The following should be true: 0 implies the read buffer is valid, but we're at the end of the buffer. * _readPos == _readLen == 0 means the read buffer contains garbage. * Either _writePos can be greater than 0, or _readLen & _readPos can be greater than zero, but neither can be greater than zero at the same time. ]]> This class will never cache more bytes than the max specified buffer size. However, it may use a temporary buffer of up to twice the size in order to combine several IO operations on the underlying stream into a single operation. This is because we assume that memory copies are significantly faster than IO operations on the underlying stream (if this was not true, using buffering is never appropriate). The max size of this "shadow" buffer is limited as to not allocate it on the LOH. Shadowing is always transient. Even when using this technique, this class still guarantees that the number of bytes cached (not yet written to the target stream or not yet consumed by the user) is never larger than the actual specified buffer size.
ByteBufferAllocator
ByteBufferPool
CStreamReader
CStreamWriter
ChunkedMemoryStream Provides an in-memory stream composed of non-contiguous chunks.
Directory
Directory.SearchData
DirectoryExtensions Directory extensions.
DirectoryInfo
DirectoryNotFoundException
DriveInfo
DriveInfoInternal Contains internal volume helpers that are shared between many projects.
DriveNotFoundException
EncodingCache
EndOfStreamException
Error
ErrorEventArgs
File
FileCleanupTestBase Base class for test classes the use temporary files that need to be cleaned up.
FileExtensions
FileHandling
FileInfo
FileList
FileLoadException
FileNotFoundException
FilePropertyBag
FileReader
FileReaderSync
FileStream
FileStream.AsyncCopyToAwaitable Used by CopyToAsync to enable awaiting the result of an overlapped I/O operation with minimal overhead.
FileStream.AsyncState State used when the stream is in async mode.
FileStreamAsyncResult
FileStreamEx
FileStreamHelpers
FileStream_
FileSystem
FileSystemAclExtensions
FileSystemEventArgs
FileSystemInfo
FileSystemInfo.FileSystemInfo
FileSystemWatcher
FileSystemWatcher.AsyncReadState State information used by the ReadDirectoryChangesW callback. A single instance of this is used for an entire session, getting passed to each iterative call to ReadDirectoryChangesW.
FileSystemWatcher.RunningInstance State and processing associatd with an active watch operation. This state is kept separate from FileSystemWatcher to avoid race conditions when a user starts/stops/starts/stops/etc. in quick succession, resulting in the potential for multiple active operations. It also helps with avoiding rooted cycles and enabling proper finalization.
FileSystemWatcher.RunningInstance.NotifyEvent An event read and translated from the inotify handle.
FileSystemWatcher.RunningInstance.WatchedDirectory State associated with a watched directory.
IOException
IOException_
InTheHandRuntimeStorageExtensions Contains extension methods for the IStorageFile and IStorageFolder interfaces for .NET interop.
InternalBufferOverflowException
InvalidDataException
KeventWatcher
KqueueMonitor
MemoryStream
MonoIO
MonoIOStat
MultiplexingWin32WinRTFileSystem
NetFxToWinRtStreamAdapter An wrapper for a managed stream that implements all WinRT stream operations. This class must not implement any WinRT stream interfaces directly. We never create instances of this class directly; instead we use classes defined in the region Interface adapters to implement WinRT ifaces and create instances of those types. See comment in that region for technical details.
NetFxToWinRtStreamAdapter.InputOutputStream
NetFxToWinRtStreamAdapter.InputStream
NetFxToWinRtStreamAdapter.OutputStream
NetFxToWinRtStreamAdapter.RandomAccessStream
Path
Path.Path
PathData
PathHelper Wrapper to help with path normalization.
PathInternal Contains internal path helpers that are shared between many projects.
PathTooLongException
PinnedBufferMemoryStream
ProxyStream
RenamedEventArgs
SearchPattern
SearchPattern.Op
Shell
Stream
Stream.NullStream
Stream.Stream
Stream.SyncStream
StreamExtension Extension methods any kind of streams
StreamExtensions
StreamOperationAsyncResult
StreamOperationsImplementation Depending on the concrete type of the stream managed by a NetFxToWinRtStreamAdapter, we want the ReadAsync / WriteAsync / FlushAsync / etc. operation to be implemented differently. This is for best performance as we can take advantage of the specifics of particular stream types. For instance, ReadAsync currently has a special implementation for memory streams. Moreover, knowledge about the actual runtime type of the IBuffer can also help chosing the optimal implementation. This type provides static methods that encapsulate the performance logic and can be used by NetFxToWinRtStreamAdapter.
StreamReader
StreamReader.NullStreamReader
StreamWriter
Stream_
StringReader
StringWriter
TextReader
TextReader.NullTextReader
TextReader.SyncTextReader
TextReader.SynchronizedReader
TextReader.TextReader
TextReader.TextReader.NullTextReader
TextReader_
TextWriter
TextWriter.NullTextWriter
TextWriter.SyncTextWriter
TextWriter.SynchronizedWriter
TextWriter.TextWriter
TextWriter.TextWriter.NullTextWriter
TextWriter_
UnmanagedMemoryAccessor
UnmanagedMemoryStream
UnmanagedMemoryStream.UnmanagedMemoryStream
UnmanagedMemoryStreamWrapper
WaitForChangedResult
Win32Directory
Win32File
Win32FileSystem
Win32Marshal Provides static methods for converting from Win32 errors codes to exceptions, HRESULTS and error messages.
WinRTFileStream
WindowsRuntimeStreamExtensions
_Proxy
__ConsoleStream
__DebugOutputTextWriter
__Error
__HResults
kevent
timespec