dotnet-core/release-notes/1.0/1.0.0-api/1.0.0-api_System.IO.md

# System.IO

``` diff
+namespace System.IO {
+    public class BinaryReader : IDisposable {
+        public BinaryReader(Stream input);
+        public BinaryReader(Stream input, Encoding encoding);
+        public BinaryReader(Stream input, Encoding encoding, bool leaveOpen);
+        public virtual Stream BaseStream { get; }
+        public virtual void Close();
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        protected virtual void FillBuffer(int numBytes);
+        public virtual int PeekChar();
+        public virtual int Read();
+        public virtual int Read(byte[] buffer, int index, int count);
+        public virtual int Read(char[] buffer, int index, int count);
+        protected internal int Read7BitEncodedInt();
+        public virtual bool ReadBoolean();
+        public virtual byte ReadByte();
+        public virtual byte[] ReadBytes(int count);
+        public virtual char ReadChar();
+        public virtual char[] ReadChars(int count);
+        public virtual decimal ReadDecimal();
+        public virtual double ReadDouble();
+        public virtual short ReadInt16();
+        public virtual int ReadInt32();
+        public virtual long ReadInt64();
+        public virtual sbyte ReadSByte();
+        public virtual float ReadSingle();
+        public virtual string ReadString();
+        public virtual ushort ReadUInt16();
+        public virtual uint ReadUInt32();
+        public virtual ulong ReadUInt64();
+    }
+    public class BinaryWriter : IDisposable {
+        public static readonly BinaryWriter Null;
+        protected Stream OutStream;
+        protected BinaryWriter();
+        public BinaryWriter(Stream output);
+        public BinaryWriter(Stream output, Encoding encoding);
+        public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen);
+        public virtual Stream BaseStream { get; }
+        public virtual void Close();
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public virtual void Flush();
+        public virtual long Seek(int offset, SeekOrigin origin);
+        public virtual void Write(bool value);
+        public virtual void Write(byte value);
+        public virtual void Write(byte[] buffer);
+        public virtual void Write(byte[] buffer, int index, int count);
+        public virtual void Write(char ch);
+        public virtual void Write(char[] chars);
+        public virtual void Write(char[] chars, int index, int count);
+        public virtual void Write(decimal value);
+        public virtual void Write(double value);
+        public virtual void Write(short value);
+        public virtual void Write(int value);
+        public virtual void Write(long value);
+        public virtual void Write(sbyte value);
+        public virtual void Write(float value);
+        public virtual void Write(string value);
+        public virtual void Write(ushort value);
+        public virtual void Write(uint value);
+        public virtual void Write(ulong value);
+        protected void Write7BitEncodedInt(int value);
+    }
+    public sealed class BufferedStream : Stream {
+        public BufferedStream(Stream stream);
+        public BufferedStream(Stream stream, int bufferSize);
+        public override bool CanRead { get; }
+        public override bool CanSeek { get; }
+        public override bool CanWrite { get; }
+        public override long Length { get; }
+        public override long Position { get; set; }
+        protected override void Dispose(bool disposing);
+        public override void Flush();
+        public override Task FlushAsync(CancellationToken cancellationToken);
+        public override int Read(byte[] array, int offset, int count);
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override int ReadByte();
+        public override long Seek(long offset, SeekOrigin origin);
+        public override void SetLength(long value);
+        public override void Write(byte[] array, int offset, int count);
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override void WriteByte(byte value);
+    }
+    public static class Directory {
+        public static DirectoryInfo CreateDirectory(string path);
+        public static void Delete(string path);
+        public static void Delete(string path, bool recursive);
+        public static IEnumerable<string> EnumerateDirectories(string path);
+        public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern);
+        public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern, SearchOption searchOption);
+        public static IEnumerable<string> EnumerateFiles(string path);
+        public static IEnumerable<string> EnumerateFiles(string path, string searchPattern);
+        public static IEnumerable<string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption);
+        public static IEnumerable<string> EnumerateFileSystemEntries(string path);
+        public static IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern);
+        public static IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption);
+        public static bool Exists(string path);
+        public static DateTime GetCreationTime(string path);
+        public static DateTime GetCreationTimeUtc(string path);
+        public static string GetCurrentDirectory();
+        public static string[] GetDirectories(string path);
+        public static string[] GetDirectories(string path, string searchPattern);
+        public static string[] GetDirectories(string path, string searchPattern, SearchOption searchOption);
+        public static string GetDirectoryRoot(string path);
+        public static string[] GetFiles(string path);
+        public static string[] GetFiles(string path, string searchPattern);
+        public static string[] GetFiles(string path, string searchPattern, SearchOption searchOption);
+        public static string[] GetFileSystemEntries(string path);
+        public static string[] GetFileSystemEntries(string path, string searchPattern);
+        public static string[] GetFileSystemEntries(string path, string searchPattern, SearchOption searchOption);
+        public static DateTime GetLastAccessTime(string path);
+        public static DateTime GetLastAccessTimeUtc(string path);
+        public static DateTime GetLastWriteTime(string path);
+        public static DateTime GetLastWriteTimeUtc(string path);
+        public static DirectoryInfo GetParent(string path);
+        public static void Move(string sourceDirName, string destDirName);
+        public static void SetCreationTime(string path, DateTime creationTime);
+        public static void SetCreationTimeUtc(string path, DateTime creationTimeUtc);
+        public static void SetCurrentDirectory(string path);
+        public static void SetLastAccessTime(string path, DateTime lastAccessTime);
+        public static void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc);
+        public static void SetLastWriteTime(string path, DateTime lastWriteTime);
+        public static void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc);
+    }
+    public sealed class DirectoryInfo : FileSystemInfo {
+        public DirectoryInfo(string path);
+        public override bool Exists { get; }
+        public override string Name { get; }
+        public DirectoryInfo Parent { get; }
+        public DirectoryInfo Root { get; }
+        public void Create();
+        public DirectoryInfo CreateSubdirectory(string path);
+        public override void Delete();
+        public void Delete(bool recursive);
+        public IEnumerable<DirectoryInfo> EnumerateDirectories();
+        public IEnumerable<DirectoryInfo> EnumerateDirectories(string searchPattern);
+        public IEnumerable<DirectoryInfo> EnumerateDirectories(string searchPattern, SearchOption searchOption);
+        public IEnumerable<FileInfo> EnumerateFiles();
+        public IEnumerable<FileInfo> EnumerateFiles(string searchPattern);
+        public IEnumerable<FileInfo> EnumerateFiles(string searchPattern, SearchOption searchOption);
+        public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos();
+        public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern);
+        public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, SearchOption searchOption);
+        public DirectoryInfo[] GetDirectories();
+        public DirectoryInfo[] GetDirectories(string searchPattern);
+        public DirectoryInfo[] GetDirectories(string searchPattern, SearchOption searchOption);
+        public FileInfo[] GetFiles();
+        public FileInfo[] GetFiles(string searchPattern);
+        public FileInfo[] GetFiles(string searchPattern, SearchOption searchOption);
+        public FileSystemInfo[] GetFileSystemInfos();
+        public FileSystemInfo[] GetFileSystemInfos(string searchPattern);
+        public FileSystemInfo[] GetFileSystemInfos(string searchPattern, SearchOption searchOption);
+        public void MoveTo(string destDirName);
+        public override string ToString();
+    }
+    public class DirectoryNotFoundException : IOException {
+        public DirectoryNotFoundException();
+        public DirectoryNotFoundException(string message);
+        public DirectoryNotFoundException(string message, Exception innerException);
+    }
+    public sealed class DriveInfo {
+        public DriveInfo(string driveName);
+        public long AvailableFreeSpace { get; }
+        public string DriveFormat { get; }
+        public DriveType DriveType { get; }
+        public bool IsReady { get; }
+        public string Name { get; }
+        public DirectoryInfo RootDirectory { get; }
+        public long TotalFreeSpace { get; }
+        public long TotalSize { get; }
+        public string VolumeLabel { get; set; }
+        public static DriveInfo[] GetDrives();
+        public override string ToString();
+    }
+    public class DriveNotFoundException : IOException {
+        public DriveNotFoundException();
+        public DriveNotFoundException(string message);
+        public DriveNotFoundException(string message, Exception innerException);
+    }
+    public enum DriveType {
+        CDRom = 5,
+        Fixed = 3,
+        Network = 4,
+        NoRootDirectory = 1,
+        Ram = 6,
+        Removable = 2,
+        Unknown = 0,
+    }
+    public class EndOfStreamException : IOException {
+        public EndOfStreamException();
+        public EndOfStreamException(string message);
+        public EndOfStreamException(string message, Exception innerException);
+    }
+    public class ErrorEventArgs : EventArgs {
+        public ErrorEventArgs(Exception exception);
+        public virtual Exception GetException();
+    }
+    public delegate void ErrorEventHandler(object sender, ErrorEventArgs e);
+    public static class File {
+        public static void AppendAllLines(string path, IEnumerable<string> contents);
+        public static void AppendAllLines(string path, IEnumerable<string> contents, Encoding encoding);
+        public static void AppendAllText(string path, string contents);
+        public static void AppendAllText(string path, string contents, Encoding encoding);
+        public static StreamWriter AppendText(string path);
+        public static void Copy(string sourceFileName, string destFileName);
+        public static void Copy(string sourceFileName, string destFileName, bool overwrite);
+        public static FileStream Create(string path);
+        public static FileStream Create(string path, int bufferSize);
+        public static FileStream Create(string path, int bufferSize, FileOptions options);
+        public static StreamWriter CreateText(string path);
+        public static void Delete(string path);
+        public static bool Exists(string path);
+        public static FileAttributes GetAttributes(string path);
+        public static DateTime GetCreationTime(string path);
+        public static DateTime GetCreationTimeUtc(string path);
+        public static DateTime GetLastAccessTime(string path);
+        public static DateTime GetLastAccessTimeUtc(string path);
+        public static DateTime GetLastWriteTime(string path);
+        public static DateTime GetLastWriteTimeUtc(string path);
+        public static void Move(string sourceFileName, string destFileName);
+        public static FileStream Open(string path, FileMode mode);
+        public static FileStream Open(string path, FileMode mode, FileAccess access);
+        public static FileStream Open(string path, FileMode mode, FileAccess access, FileShare share);
+        public static FileStream OpenRead(string path);
+        public static StreamReader OpenText(string path);
+        public static FileStream OpenWrite(string path);
+        public static byte[] ReadAllBytes(string path);
+        public static string[] ReadAllLines(string path);
+        public static string[] ReadAllLines(string path, Encoding encoding);
+        public static string ReadAllText(string path);
+        public static string ReadAllText(string path, Encoding encoding);
+        public static IEnumerable<string> ReadLines(string path);
+        public static IEnumerable<string> ReadLines(string path, Encoding encoding);
+        public static void SetAttributes(string path, FileAttributes fileAttributes);
+        public static void SetCreationTime(string path, DateTime creationTime);
+        public static void SetCreationTimeUtc(string path, DateTime creationTimeUtc);
+        public static void SetLastAccessTime(string path, DateTime lastAccessTime);
+        public static void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc);
+        public static void SetLastWriteTime(string path, DateTime lastWriteTime);
+        public static void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc);
+        public static void WriteAllBytes(string path, byte[] bytes);
+        public static void WriteAllLines(string path, IEnumerable<string> contents);
+        public static void WriteAllLines(string path, IEnumerable<string> contents, Encoding encoding);
+        public static void WriteAllText(string path, string contents);
+        public static void WriteAllText(string path, string contents, Encoding encoding);
+    }
+    public enum FileAccess {
+        Read = 1,
+        ReadWrite = 3,
+        Write = 2,
+    }
+    public enum FileAttributes {
+        Archive = 32,
+        Compressed = 2048,
+        Device = 64,
+        Directory = 16,
+        Encrypted = 16384,
+        Hidden = 2,
+        IntegrityStream = 32768,
+        Normal = 128,
+        NoScrubData = 131072,
+        NotContentIndexed = 8192,
+        Offline = 4096,
+        ReadOnly = 1,
+        ReparsePoint = 1024,
+        SparseFile = 512,
+        System = 4,
+        Temporary = 256,
+    }
+    public class FileFormatException : FormatException {
+        public FileFormatException();
+        public FileFormatException(string message);
+        public FileFormatException(string message, Exception innerException);
+        public FileFormatException(Uri sourceUri);
+        public FileFormatException(Uri sourceUri, Exception innerException);
+        public FileFormatException(Uri sourceUri, string message);
+        public FileFormatException(Uri sourceUri, string message, Exception innerException);
+        public Uri SourceUri { get; }
+    }
+    public sealed class FileInfo : FileSystemInfo {
+        public FileInfo(string fileName);
+        public DirectoryInfo Directory { get; }
+        public string DirectoryName { get; }
+        public override bool Exists { get; }
+        public bool IsReadOnly { get; set; }
+        public long Length { get; }
+        public override string Name { get; }
+        public StreamWriter AppendText();
+        public FileInfo CopyTo(string destFileName);
+        public FileInfo CopyTo(string destFileName, bool overwrite);
+        public FileStream Create();
+        public StreamWriter CreateText();
+        public override void Delete();
+        public void MoveTo(string destFileName);
+        public FileStream Open(FileMode mode);
+        public FileStream Open(FileMode mode, FileAccess access);
+        public FileStream Open(FileMode mode, FileAccess access, FileShare share);
+        public FileStream OpenRead();
+        public StreamReader OpenText();
+        public FileStream OpenWrite();
+        public override string ToString();
+    }
+    public class FileLoadException : IOException {
+        public FileLoadException();
+        public FileLoadException(string message);
+        public FileLoadException(string message, Exception inner);
+        public FileLoadException(string message, string fileName);
+        public FileLoadException(string message, string fileName, Exception inner);
+        public string FileName { get; }
+        public override string Message { get; }
+        public override string ToString();
+    }
+    public enum FileMode {
+        Append = 6,
+        Create = 2,
+        CreateNew = 1,
+        Open = 3,
+        OpenOrCreate = 4,
+        Truncate = 5,
+    }
+    public class FileNotFoundException : IOException {
+        public FileNotFoundException();
+        public FileNotFoundException(string message);
+        public FileNotFoundException(string message, Exception innerException);
+        public FileNotFoundException(string message, string fileName);
+        public FileNotFoundException(string message, string fileName, Exception innerException);
+        public string FileName { get; }
+        public override string Message { get; }
+        public override string ToString();
+    }
+    public enum FileOptions {
+        Asynchronous = 1073741824,
+        DeleteOnClose = 67108864,
+        Encrypted = 16384,
+        None = 0,
+        RandomAccess = 268435456,
+        SequentialScan = 134217728,
+        WriteThrough = -2147483648,
+    }
+    public enum FileShare {
+        Delete = 4,
+        Inheritable = 16,
+        None = 0,
+        Read = 1,
+        ReadWrite = 3,
+        Write = 2,
+    }
+    public class FileStream : Stream {
+        public FileStream(SafeFileHandle handle, FileAccess access);
+        public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize);
+        public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync);
+        public FileStream(string path, FileMode mode);
+        public FileStream(string path, FileMode mode, FileAccess access);
+        public FileStream(string path, FileMode mode, FileAccess access, FileShare share);
+        public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize);
+        public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool useAsync);
+        public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options);
+        public override bool CanRead { get; }
+        public override bool CanSeek { get; }
+        public override bool CanWrite { get; }
+        public virtual bool IsAsync { get; }
+        public override long Length { get; }
+        public string Name { get; }
+        public override long Position { get; set; }
+        public virtual SafeFileHandle SafeFileHandle { get; }
+        protected override void Dispose(bool disposing);
+        ~FileStream();
+        public override void Flush();
+        public virtual void Flush(bool flushToDisk);
+        public override Task FlushAsync(CancellationToken cancellationToken);
+        public override int Read(byte[] array, int offset, int count);
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override int ReadByte();
+        public override long Seek(long offset, SeekOrigin origin);
+        public override void SetLength(long value);
+        public override void Write(byte[] array, int offset, int count);
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override void WriteByte(byte value);
+    }
+    public static class FileSystemAclExtensions {
+        public static DirectorySecurity GetAccessControl(this DirectoryInfo directoryInfo);
+        public static DirectorySecurity GetAccessControl(this DirectoryInfo directoryInfo, AccessControlSections includeSections);
+        public static FileSecurity GetAccessControl(this FileInfo fileInfo);
+        public static FileSecurity GetAccessControl(this FileInfo fileInfo, AccessControlSections includeSections);
+        public static FileSecurity GetAccessControl(this FileStream fileStream);
+        public static void SetAccessControl(this DirectoryInfo directoryInfo, DirectorySecurity directorySecurity);
+        public static void SetAccessControl(this FileInfo fileInfo, FileSecurity fileSecurity);
+        public static void SetAccessControl(this FileStream fileStream, FileSecurity fileSecurity);
+    }
+    public class FileSystemEventArgs : EventArgs {
+        public FileSystemEventArgs(WatcherChangeTypes changeType, string directory, string name);
+        public WatcherChangeTypes ChangeType { get; }
+        public string FullPath { get; }
+        public string Name { get; }
+    }
+    public delegate void FileSystemEventHandler(object sender, FileSystemEventArgs e);
+    public abstract class FileSystemInfo {
+        protected string FullPath;
+        protected string OriginalPath;
+        protected FileSystemInfo();
+        public FileAttributes Attributes { get; set; }
+        public DateTime CreationTime { get; set; }
+        public DateTime CreationTimeUtc { get; set; }
+        public abstract bool Exists { get; }
+        public string Extension { get; }
+        public virtual string FullName { get; }
+        public DateTime LastAccessTime { get; set; }
+        public DateTime LastAccessTimeUtc { get; set; }
+        public DateTime LastWriteTime { get; set; }
+        public DateTime LastWriteTimeUtc { get; set; }
+        public abstract string Name { get; }
+        public abstract void Delete();
+        public void Refresh();
+    }
+    public class FileSystemWatcher : IDisposable {
+        public FileSystemWatcher();
+        public FileSystemWatcher(string path);
+        public FileSystemWatcher(string path, string filter);
+        public bool EnableRaisingEvents { get; set; }
+        public string Filter { get; set; }
+        public bool IncludeSubdirectories { get; set; }
+        public int InternalBufferSize { get; set; }
+        public NotifyFilters NotifyFilter { get; set; }
+        public string Path { get; set; }
+        public event FileSystemEventHandler Changed;
+        public event FileSystemEventHandler Created;
+        public event FileSystemEventHandler Deleted;
+        public event ErrorEventHandler Error;
+        public event RenamedEventHandler Renamed;
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        protected void OnChanged(FileSystemEventArgs e);
+        protected void OnCreated(FileSystemEventArgs e);
+        protected void OnDeleted(FileSystemEventArgs e);
+        protected void OnError(ErrorEventArgs e);
+        protected void OnRenamed(RenamedEventArgs e);
+        public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType);
+        public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType, int timeout);
+    }
+    public enum HandleInheritability {
+        Inheritable = 1,
+        None = 0,
+    }
+    public sealed class InvalidDataException : Exception {
+        public InvalidDataException();
+        public InvalidDataException(string message);
+        public InvalidDataException(string message, Exception innerException);
+    }
+    public class IOException : Exception {
+        public IOException();
+        public IOException(string message);
+        public IOException(string message, Exception innerException);
+        public IOException(string message, int hresult);
+    }
+    public class MemoryStream : Stream {
+        public MemoryStream();
+        public MemoryStream(byte[] buffer);
+        public MemoryStream(byte[] buffer, bool writable);
+        public MemoryStream(byte[] buffer, int index, int count);
+        public MemoryStream(byte[] buffer, int index, int count, bool writable);
+        public MemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible);
+        public MemoryStream(int capacity);
+        public override bool CanRead { get; }
+        public override bool CanSeek { get; }
+        public override bool CanWrite { get; }
+        public virtual int Capacity { get; set; }
+        public override long Length { get; }
+        public override long Position { get; set; }
+        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
+        protected override void Dispose(bool disposing);
+        public override void Flush();
+        public override Task FlushAsync(CancellationToken cancellationToken);
+        public virtual byte[] GetBuffer();
+        public override int Read(byte[] buffer, int offset, int count);
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override int ReadByte();
+        public override long Seek(long offset, SeekOrigin loc);
+        public override void SetLength(long value);
+        public virtual byte[] ToArray();
+        public virtual bool TryGetBuffer(out ArraySegment<byte> buffer);
+        public override void Write(byte[] buffer, int offset, int count);
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override void WriteByte(byte value);
+        public virtual void WriteTo(Stream stream);
+    }
+    public enum NotifyFilters {
+        Attributes = 4,
+        CreationTime = 64,
+        DirectoryName = 2,
+        FileName = 1,
+        LastAccess = 32,
+        LastWrite = 16,
+        Security = 256,
+        Size = 8,
+    }
+    public static class Path {
+        public static readonly char AltDirectorySeparatorChar;
+        public static readonly char DirectorySeparatorChar;
+        public static readonly char PathSeparator;
+        public static readonly char VolumeSeparatorChar;
+        public static string ChangeExtension(string path, string extension);
+        public static string Combine(string path1, string path2);
+        public static string Combine(string path1, string path2, string path3);
+        public static string Combine(params string[] paths);
+        public static string GetDirectoryName(string path);
+        public static string GetExtension(string path);
+        public static string GetFileName(string path);
+        public static string GetFileNameWithoutExtension(string path);
+        public static string GetFullPath(string path);
+        public static char[] GetInvalidFileNameChars();
+        public static char[] GetInvalidPathChars();
+        public static string GetPathRoot(string path);
+        public static string GetRandomFileName();
+        public static string GetTempFileName();
+        public static string GetTempPath();
+        public static bool HasExtension(string path);
+        public static bool IsPathRooted(string path);
+    }
+    public class PathTooLongException : IOException {
+        public PathTooLongException();
+        public PathTooLongException(string message);
+        public PathTooLongException(string message, Exception innerException);
+    }
+    public class RenamedEventArgs : FileSystemEventArgs {
+        public RenamedEventArgs(WatcherChangeTypes changeType, string directory, string name, string oldName);
+        public string OldFullPath { get; }
+        public string OldName { get; }
+    }
+    public delegate void RenamedEventHandler(object sender, RenamedEventArgs e);
+    public enum SearchOption {
+        AllDirectories = 1,
+        TopDirectoryOnly = 0,
+    }
+    public enum SeekOrigin {
+        Begin = 0,
+        Current = 1,
+        End = 2,
+    }
+    public abstract class Stream : IDisposable {
+        public static readonly Stream Null;
+        protected Stream();
+        public abstract bool CanRead { get; }
+        public abstract bool CanSeek { get; }
+        public virtual bool CanTimeout { get; }
+        public abstract bool CanWrite { get; }
+        public abstract long Length { get; }
+        public abstract long Position { get; set; }
+        public virtual int ReadTimeout { get; set; }
+        public virtual int WriteTimeout { get; set; }
+        public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+        public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+        public virtual void Close();
+        public void CopyTo(Stream destination);
+        public void CopyTo(Stream destination, int bufferSize);
+        public Task CopyToAsync(Stream destination);
+        public Task CopyToAsync(Stream destination, int bufferSize);
+        public virtual Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public virtual int EndRead(IAsyncResult asyncResult);
+        public virtual void EndWrite(IAsyncResult asyncResult);
+        public abstract void Flush();
+        public Task FlushAsync();
+        public virtual Task FlushAsync(CancellationToken cancellationToken);
+        public abstract int Read(byte[] buffer, int offset, int count);
+        public Task<int> ReadAsync(byte[] buffer, int offset, int count);
+        public virtual Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public virtual int ReadByte();
+        public abstract long Seek(long offset, SeekOrigin origin);
+        public abstract void SetLength(long value);
+        public abstract void Write(byte[] buffer, int offset, int count);
+        public Task WriteAsync(byte[] buffer, int offset, int count);
+        public virtual Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public virtual void WriteByte(byte value);
+    }
+    public class StreamReader : TextReader {
+        public static readonly new StreamReader Null;
+        public StreamReader(Stream stream);
+        public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks);
+        public StreamReader(Stream stream, Encoding encoding);
+        public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks);
+        public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
+        public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen);
+        public StreamReader(string path);
+        public StreamReader(string path, bool detectEncodingFromByteOrderMarks);
+        public StreamReader(string path, Encoding encoding);
+        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks);
+        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
+        public virtual Stream BaseStream { get; }
+        public virtual Encoding CurrentEncoding { get; }
+        public bool EndOfStream { get; }
+        public override void Close();
+        public void DiscardBufferedData();
+        protected override void Dispose(bool disposing);
+        public override int Peek();
+        public override int Read();
+        public override int Read(char[] buffer, int index, int count);
+        public override Task<int> ReadAsync(char[] buffer, int index, int count);
+        public override int ReadBlock(char[] buffer, int index, int count);
+        public override Task<int> ReadBlockAsync(char[] buffer, int index, int count);
+        public override string ReadLine();
+        public override Task<string> ReadLineAsync();
+        public override string ReadToEnd();
+        public override Task<string> ReadToEndAsync();
+    }
+    public class StreamWriter : TextWriter {
+        public static readonly new StreamWriter Null;
+        public StreamWriter(Stream stream);
+        public StreamWriter(Stream stream, Encoding encoding);
+        public StreamWriter(Stream stream, Encoding encoding, int bufferSize);
+        public StreamWriter(Stream stream, Encoding encoding, int bufferSize, bool leaveOpen);
+        public StreamWriter(string path);
+        public StreamWriter(string path, bool append);
+        public StreamWriter(string path, bool append, Encoding encoding);
+        public StreamWriter(string path, bool append, Encoding encoding, int bufferSize);
+        public virtual bool AutoFlush { get; set; }
+        public virtual Stream BaseStream { get; }
+        public override Encoding Encoding { get; }
+        public override void Close();
+        protected override void Dispose(bool disposing);
+        public override void Flush();
+        public override Task FlushAsync();
+        public override void Write(char value);
+        public override void Write(char[] buffer);
+        public override void Write(char[] buffer, int index, int count);
+        public override void Write(string value);
+        public override Task WriteAsync(char value);
+        public override Task WriteAsync(char[] buffer, int index, int count);
+        public override Task WriteAsync(string value);
+        public override Task WriteLineAsync();
+        public override Task WriteLineAsync(char value);
+        public override Task WriteLineAsync(char[] buffer, int index, int count);
+        public override Task WriteLineAsync(string value);
+    }
+    public class StringReader : TextReader {
+        public StringReader(string s);
+        public override void Close();
+        protected override void Dispose(bool disposing);
+        public override int Peek();
+        public override int Read();
+        public override int Read(char[] buffer, int index, int count);
+        public override Task<int> ReadAsync(char[] buffer, int index, int count);
+        public override Task<int> ReadBlockAsync(char[] buffer, int index, int count);
+        public override string ReadLine();
+        public override Task<string> ReadLineAsync();
+        public override string ReadToEnd();
+        public override Task<string> ReadToEndAsync();
+    }
+    public class StringWriter : TextWriter {
+        public StringWriter();
+        public StringWriter(IFormatProvider formatProvider);
+        public StringWriter(StringBuilder sb);
+        public StringWriter(StringBuilder sb, IFormatProvider formatProvider);
+        public override Encoding Encoding { get; }
+        public override void Close();
+        protected override void Dispose(bool disposing);
+        public override Task FlushAsync();
+        public virtual StringBuilder GetStringBuilder();
+        public override string ToString();
+        public override void Write(char value);
+        public override void Write(char[] buffer, int index, int count);
+        public override void Write(string value);
+        public override Task WriteAsync(char value);
+        public override Task WriteAsync(char[] buffer, int index, int count);
+        public override Task WriteAsync(string value);
+        public override Task WriteLineAsync(char value);
+        public override Task WriteLineAsync(char[] buffer, int index, int count);
+        public override Task WriteLineAsync(string value);
+    }
+    public abstract class TextReader : IDisposable {
+        public static readonly TextReader Null;
+        protected TextReader();
+        public virtual void Close();
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public virtual int Peek();
+        public virtual int Read();
+        public virtual int Read(char[] buffer, int index, int count);
+        public virtual Task<int> ReadAsync(char[] buffer, int index, int count);
+        public virtual int ReadBlock(char[] buffer, int index, int count);
+        public virtual Task<int> ReadBlockAsync(char[] buffer, int index, int count);
+        public virtual string ReadLine();
+        public virtual Task<string> ReadLineAsync();
+        public virtual string ReadToEnd();
+        public virtual Task<string> ReadToEndAsync();
+    }
+    public abstract class TextWriter : IDisposable {
+        protected char[] CoreNewLine;
+        public static readonly TextWriter Null;
+        protected TextWriter();
+        protected TextWriter(IFormatProvider formatProvider);
+        public abstract Encoding Encoding { get; }
+        public virtual IFormatProvider FormatProvider { get; }
+        public virtual string NewLine { get; set; }
+        public virtual void Close();
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public virtual void Flush();
+        public virtual Task FlushAsync();
+        public virtual void Write(bool value);
+        public virtual void Write(char value);
+        public virtual void Write(char[] buffer);
+        public virtual void Write(char[] buffer, int index, int count);
+        public virtual void Write(decimal value);
+        public virtual void Write(double value);
+        public virtual void Write(int value);
+        public virtual void Write(long value);
+        public virtual void Write(object value);
+        public virtual void Write(float value);
+        public virtual void Write(string value);
+        public virtual void Write(string format, object arg0);
+        public virtual void Write(string format, object arg0, object arg1);
+        public virtual void Write(string format, object arg0, object arg1, object arg2);
+        public virtual void Write(string format, params object[] arg);
+        public virtual void Write(uint value);
+        public virtual void Write(ulong value);
+        public virtual Task WriteAsync(char value);
+        public Task WriteAsync(char[] buffer);
+        public virtual Task WriteAsync(char[] buffer, int index, int count);
+        public virtual Task WriteAsync(string value);
+        public virtual void WriteLine();
+        public virtual void WriteLine(bool value);
+        public virtual void WriteLine(char value);
+        public virtual void WriteLine(char[] buffer);
+        public virtual void WriteLine(char[] buffer, int index, int count);
+        public virtual void WriteLine(decimal value);
+        public virtual void WriteLine(double value);
+        public virtual void WriteLine(int value);
+        public virtual void WriteLine(long value);
+        public virtual void WriteLine(object value);
+        public virtual void WriteLine(float value);
+        public virtual void WriteLine(string value);
+        public virtual void WriteLine(string format, object arg0);
+        public virtual void WriteLine(string format, object arg0, object arg1);
+        public virtual void WriteLine(string format, object arg0, object arg1, object arg2);
+        public virtual void WriteLine(string format, params object[] arg);
+        public virtual void WriteLine(uint value);
+        public virtual void WriteLine(ulong value);
+        public virtual Task WriteLineAsync();
+        public virtual Task WriteLineAsync(char value);
+        public Task WriteLineAsync(char[] buffer);
+        public virtual Task WriteLineAsync(char[] buffer, int index, int count);
+        public virtual Task WriteLineAsync(string value);
+    }
+    public class UnmanagedMemoryAccessor : IDisposable {
+        protected UnmanagedMemoryAccessor();
+        public UnmanagedMemoryAccessor(SafeBuffer buffer, long offset, long capacity);
+        public UnmanagedMemoryAccessor(SafeBuffer buffer, long offset, long capacity, FileAccess access);
+        public bool CanRead { get; }
+        public bool CanWrite { get; }
+        public long Capacity { get; }
+        protected bool IsOpen { get; }
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        protected void Initialize(SafeBuffer buffer, long offset, long capacity, FileAccess access);
+        public bool ReadBoolean(long position);
+        public byte ReadByte(long position);
+        public char ReadChar(long position);
+        public decimal ReadDecimal(long position);
+        public double ReadDouble(long position);
+        public short ReadInt16(long position);
+        public int ReadInt32(long position);
+        public long ReadInt64(long position);
+        public sbyte ReadSByte(long position);
+        public float ReadSingle(long position);
+        public ushort ReadUInt16(long position);
+        public uint ReadUInt32(long position);
+        public ulong ReadUInt64(long position);
+        public void Write(long position, bool value);
+        public void Write(long position, byte value);
+        public void Write(long position, char value);
+        public void Write(long position, decimal value);
+        public void Write(long position, double value);
+        public void Write(long position, short value);
+        public void Write(long position, int value);
+        public void Write(long position, long value);
+        public void Write(long position, sbyte value);
+        public void Write(long position, float value);
+        public void Write(long position, ushort value);
+        public void Write(long position, uint value);
+        public void Write(long position, ulong value);
+    }
+    public class UnmanagedMemoryStream : Stream {
+        protected UnmanagedMemoryStream();
+        public unsafe UnmanagedMemoryStream(byte* pointer, long length);
+        public unsafe UnmanagedMemoryStream(byte* pointer, long length, long capacity, FileAccess access);
+        public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length);
+        public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length, FileAccess access);
+        public override bool CanRead { get; }
+        public override bool CanSeek { get; }
+        public override bool CanWrite { get; }
+        public long Capacity { get; }
+        public override long Length { get; }
+        public override long Position { get; set; }
+        public unsafe byte* PositionPointer { get; set; }
+        protected override void Dispose(bool disposing);
+        public override void Flush();
+        public override Task FlushAsync(CancellationToken cancellationToken);
+        protected unsafe void Initialize(byte* pointer, long length, long capacity, FileAccess access);
+        protected void Initialize(SafeBuffer buffer, long offset, long length, FileAccess access);
+        public override int Read(byte[] buffer, int offset, int count);
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override int ReadByte();
+        public override long Seek(long offset, SeekOrigin loc);
+        public override void SetLength(long value);
+        public override void Write(byte[] buffer, int offset, int count);
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        public override void WriteByte(byte value);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct WaitForChangedResult {
+        public WatcherChangeTypes ChangeType { get; set; }
+        public string Name { get; set; }
+        public string OldName { get; set; }
+        public bool TimedOut { get; set; }
+    }
+    public enum WatcherChangeTypes {
+        All = 15,
+        Changed = 4,
+        Created = 1,
+        Deleted = 2,
+        Renamed = 8,
+    }
+}
```