using System; using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; using Cpp2IlInjected; using Microsoft.Win32.SafeHandles; namespace System.IO { ///

Provides a for a file, supporting both synchronous and asynchronous read and write operations.

// Token: 0x020002BB RID: 699 [Token(Token = "0x20002BB")] [ComVisible(true)] public class FileStream : Stream { ///

Initializes a new instance of the class for the specified file handle, with the specified read/write permission, instance ownership, and buffer size.

/// A file handle for the file that this object will encapsulate. /// A constant that sets the and properties of the object. /// /// if the file handle will be owned by this instance; otherwise, . /// A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. /// /// is negative. /// An I/O error, such as a disk error, occurred. /// -or- /// The stream has been closed. /// The caller does not have the required permission. /// The requested is not permitted by the operating system for the specified file handle, such as when is or and the file handle is set for read-only access. // Token: 0x0600199E RID: 6558 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600199E")] [Address(RVA = "0x2BAFE60", Offset = "0x2BAEE60", VA = "0x182BAFE60")] [Obsolete] public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize) { } // Token: 0x0600199F RID: 6559 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600199F")] [Address(RVA = "0x2BB00A0", Offset = "0x2BAF0A0", VA = "0x182BB00A0")] internal FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize, bool isAsync, bool isConsoleWrapper) { } ///

Initializes a new instance of the class with the specified path and creation mode.

/// A relative or absolute path for the file that the current object will encapsulate. /// A constant that determines how to open or create the file. /// /// is an empty string (""), contains only white space, or contains one or more invalid characters. /// -or- /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in an NTFS environment. /// /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in a non-NTFS environment. /// /// is . /// The caller does not have the required permission. /// The file cannot be found, such as when is or , and the file specified by does not exist. The file must already exist in these modes. /// An I/O error, such as specifying when the file specified by already exists, occurred. /// -or- /// The stream has been closed. /// The specified path is invalid, such as being on an unmapped drive. /// The specified path, file name, or both exceed the system-defined maximum length. /// /// contains an invalid value. // Token: 0x060019A0 RID: 6560 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A0")] [Address(RVA = "0x2BB0020", Offset = "0x2BAF020", VA = "0x182BB0020")] public FileStream(string path, FileMode mode) { } ///

Initializes a new instance of the class with the specified path, creation mode, and read/write permission.

Initializes a new instance of the class with the specified path, creation mode, read/write permission, and sharing permission.

Initializes a new instance of the class with the specified path, creation mode, read/write and sharing permission, and buffer size.

Initializes a new instance of the class with the specified path, creation mode, read/write and sharing permission, buffer size, and synchronous or asynchronous state.

/// A relative or absolute path for the file that the current object will encapsulate. /// A constant that determines how to open or create the file. /// A constant that determines how the file can be accessed by the object. This also determines the values returned by the and properties of the object. is if specifies a disk file. /// A constant that determines how the file will be shared by processes. /// A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. /// Specifies whether to use asynchronous I/O or synchronous I/O. However, note that the underlying operating system might not support asynchronous I/O, so when specifying , the handle might be opened synchronously depending on the platform. When opened asynchronously, the and methods perform better on large reads or writes, but they might be much slower for small reads or writes. If the application is designed to take advantage of asynchronous I/O, set the parameter to . Using asynchronous I/O correctly can speed up applications by as much as a factor of 10, but using it without redesigning the application for asynchronous I/O can decrease performance by as much as a factor of 10. /// /// is . /// /// is an empty string (""), contains only white space, or contains one or more invalid characters. /// -or- /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in an NTFS environment. /// /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in a non-NTFS environment. /// /// is negative or zero. /// -or- /// , , or contain an invalid value. /// The file cannot be found, such as when is or , and the file specified by does not exist. The file must already exist in these modes. /// An I/O error, such as specifying when the file specified by already exists, occurred. /// -or- /// The system is running Windows 98 or Windows 98 Second Edition and is set to . /// -or- /// The stream has been closed. /// The caller does not have the required permission. /// The specified path is invalid, such as being on an unmapped drive. /// The requested is not permitted by the operating system for the specified , such as when is or and the file or directory is set for read-only access. /// The specified path, file name, or both exceed the system-defined maximum length. // Token: 0x060019A4 RID: 6564 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A4")] [Address(RVA = "0x2BAFFD0", Offset = "0x2BAEFD0", VA = "0x182BAFFD0")] public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool useAsync) { } ///

Initializes a new instance of the class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, and additional file options.

/// A relative or absolute path for the file that the current object will encapsulate. /// A constant that determines how to open or create the file. /// A constant that determines how the file can be accessed by the object. This also determines the values returned by the and properties of the object. is if specifies a disk file. /// A constant that determines how the file will be shared by processes. /// A positive value greater than 0 indicating the buffer size. The default buffer size is 4096. /// A value that specifies additional file options. /// /// is . /// /// is an empty string (""), contains only white space, or contains one or more invalid characters. /// -or- /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in an NTFS environment. /// /// refers to a non-file device, such as "con:", "com1:", "lpt1:", etc. in a non-NTFS environment. /// /// is negative or zero. /// -or- /// , , or contain an invalid value. /// The file cannot be found, such as when is or , and the file specified by does not exist. The file must already exist in these modes. /// An I/O error, such as specifying when the file specified by already exists, occurred. /// -or- /// The stream has been closed. /// The caller does not have the required permission. /// The specified path is invalid, such as being on an unmapped drive. /// The requested is not permitted by the operating system for the specified , such as when is or and the file or directory is set for read-only access. /// -or- /// is specified for , but file encryption is not supported on the current platform. /// The specified path, file name, or both exceed the system-defined maximum length. // Token: 0x060019A5 RID: 6565 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A5")] [Address(RVA = "0x2BB09B0", Offset = "0x2BAF9B0", VA = "0x182BB09B0")] public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { } // Token: 0x060019A6 RID: 6566 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A6")] [Address(RVA = "0x2BAFDB0", Offset = "0x2BAEDB0", VA = "0x182BAFDB0")] internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, string msgPath, bool bFromProxy, bool useLongPath = false, bool checkHost = false) { } // Token: 0x060019A7 RID: 6567 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A7")] [Address(RVA = "0x2BAFD50", Offset = "0x2BAED50", VA = "0x182BAFD50")] internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool isAsync, bool anonymous) { } // Token: 0x060019A8 RID: 6568 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A8")] [Address(RVA = "0x2BB0210", Offset = "0x2BAF210", VA = "0x182BB0210")] internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool anonymous, FileOptions options) { } // Token: 0x060019A9 RID: 6569 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019A9")] [Address(RVA = "0x2BAE730", Offset = "0x2BAD730", VA = "0x182BAE730")] private void Init(SafeFileHandle safeHandle, FileAccess access, bool ownsHandle, int bufferSize, bool isAsync, bool isConsoleWrapper) { } ///

Gets a value that indicates whether the current stream supports reading.

/// /// if the stream supports reading; if the stream is closed or was opened with write-only access. // Token: 0x17000313 RID: 787 // (get) Token: 0x060019AA RID: 6570 RVA: 0x00010E00 File Offset: 0x0000F000 [Token(Token = "0x17000313")] public override bool CanRead { [Token(Token = "0x60019AA")] [Address(RVA = "0x2BB09F0", Offset = "0x2BAF9F0", VA = "0x182BB09F0", Slot = "7")] get { return default(bool); } } ///

Gets a value that indicates whether the current stream supports writing.

/// /// if the stream supports writing; if the stream is closed or was opened with read-only access. // Token: 0x17000314 RID: 788 // (get) Token: 0x060019AB RID: 6571 RVA: 0x00010E18 File Offset: 0x0000F018 [Token(Token = "0x17000314")] public override bool CanWrite { [Token(Token = "0x60019AB")] [Address(RVA = "0x2BB0A00", Offset = "0x2BAFA00", VA = "0x182BB0A00", Slot = "9")] get { return default(bool); } } ///

Gets a value that indicates whether the current stream supports seeking.

/// /// if the stream supports seeking; if the stream is closed or if the was constructed from an operating-system handle such as a pipe or output to the console. // Token: 0x17000315 RID: 789 // (get) Token: 0x060019AC RID: 6572 RVA: 0x00010E30 File Offset: 0x0000F030 [Token(Token = "0x17000315")] public override bool CanSeek { [Token(Token = "0x60019AC")] [Address(RVA = "0x1837450", Offset = "0x1836450", VA = "0x181837450", Slot = "8")] get { return default(bool); } } ///

Gets the absolute path of the file opened in the .

/// A string that is the absolute path of the file. // Token: 0x17000316 RID: 790 // (get) Token: 0x060019AD RID: 6573 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x17000316")] public string Name { [Token(Token = "0x60019AD")] [Address(RVA = "0x4157E0", Offset = "0x4147E0", VA = "0x1804157E0")] get { return null; } } ///

Gets the length in bytes of the stream.

/// A long value representing the length of the stream in bytes. /// /// for this stream is . /// An I/O error, such as the file being closed, occurred. // Token: 0x17000317 RID: 791 // (get) Token: 0x060019AE RID: 6574 RVA: 0x00010E48 File Offset: 0x0000F048 [Token(Token = "0x17000317")] public override long Length { [Token(Token = "0x60019AE")] [Address(RVA = "0x2BB0A20", Offset = "0x2BAFA20", VA = "0x182BB0A20", Slot = "10")] get { return 0L; } } ///

Gets or sets the current position of this stream.

/// The current position of this stream. /// The stream does not support seeking. /// An I/O error occurred. /// -or- /// The position was set to a very large value beyond the end of the stream in Windows 98 or earlier. /// Attempted to set the position to a negative value. /// Attempted seeking past the end of a stream that does not support this. // Token: 0x17000318 RID: 792 // (get) Token: 0x060019AF RID: 6575 RVA: 0x00010E60 File Offset: 0x0000F060 // (set) Token: 0x060019B0 RID: 6576 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x17000318")] public override long Position { [Token(Token = "0x60019AF")] [Address(RVA = "0x2BB0BA0", Offset = "0x2BAFBA0", VA = "0x182BB0BA0", Slot = "11")] get { return 0L; } [Token(Token = "0x60019B0")] [Address(RVA = "0x2BB0D70", Offset = "0x2BAFD70", VA = "0x182BB0D70", Slot = "12")] set { } } ///

Gets a object that represents the operating system file handle for the file that the current object encapsulates.

/// An object that represents the operating system file handle for the file that the current object encapsulates. // Token: 0x17000319 RID: 793 // (get) Token: 0x060019B1 RID: 6577 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x17000319")] public virtual SafeFileHandle SafeFileHandle { [Token(Token = "0x60019B1")] [Address(RVA = "0x2BB0D30", Offset = "0x2BAFD30", VA = "0x182BB0D30", Slot = "31")] get { return null; } } // Token: 0x060019B2 RID: 6578 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019B2")] [Address(RVA = "0x2BADFE0", Offset = "0x2BACFE0", VA = "0x182BADFE0")] private void ExposeHandle() { } ///

Reads a byte from the file and advances the read position one byte.

/// The byte, cast to an , or -1 if the end of the stream has been reached. /// The current stream does not support reading. /// The current stream is closed. // Token: 0x060019B3 RID: 6579 RVA: 0x00010E78 File Offset: 0x0000F078 [Token(Token = "0x60019B3")] [Address(RVA = "0x2BAEA40", Offset = "0x2BADA40", VA = "0x182BAEA40", Slot = "28")] public override int ReadByte() { return 0; } ///

Writes a byte to the current position in the file stream.

/// A byte to write to the stream. /// The stream is closed. /// The stream does not support writing. // Token: 0x060019B4 RID: 6580 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019B4")] [Address(RVA = "0x2BAF690", Offset = "0x2BAE690", VA = "0x182BAF690", Slot = "30")] public override void WriteByte(byte value) { } ///

Reads a block of bytes from the stream and writes the data in a given buffer.

/// When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. /// The byte offset in at which the read bytes will be placed. /// The maximum number of bytes to read. /// The total number of bytes read into the buffer. This might be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached. /// /// is . /// /// or is negative. /// The stream does not support reading. /// An I/O error occurred. /// /// and describe an invalid range in . /// Methods were called after the stream was closed. // Token: 0x060019B5 RID: 6581 RVA: 0x00010E90 File Offset: 0x0000F090 [Token(Token = "0x60019B5")] [Address(RVA = "0x2BAEE70", Offset = "0x2BADE70", VA = "0x182BAEE70", Slot = "27")] public override int Read([In] [Out] byte[] array, int offset, int count) { return 0; } // Token: 0x060019B6 RID: 6582 RVA: 0x00010EA8 File Offset: 0x0000F0A8 [Token(Token = "0x60019B6")] [Address(RVA = "0x2BAECE0", Offset = "0x2BADCE0", VA = "0x182BAECE0")] private int ReadInternal(byte[] dest, int offset, int count) { return 0; } ///

Begins an asynchronous read operation. Consider using instead.

/// The buffer to read data into. /// The byte offset in at which to begin reading. /// The maximum number of bytes to read. /// The method to be called when the asynchronous read operation is completed. /// A user-provided object that distinguishes this particular asynchronous read request from other requests. /// An object that references the asynchronous read. /// The array length minus is less than . /// /// is . /// /// or is negative. /// An asynchronous read was attempted past the end of the file. // Token: 0x060019B7 RID: 6583 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019B7")] [Address(RVA = "0x2BAD480", Offset = "0x2BAC480", VA = "0x182BAD480", Slot = "19")] public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject) { return null; } ///

Waits for the pending asynchronous read operation to complete. (Consider using instead.)

/// The reference to the pending asynchronous request to wait for. /// The number of bytes read from the stream, between 0 and the number of bytes you requested. Streams only return 0 at the end of the stream, otherwise, they should block until at least 1 byte is available. /// /// is . /// This object was not created by calling on this class. /// /// is called multiple times. /// The stream is closed or an internal error has occurred. // Token: 0x060019B8 RID: 6584 RVA: 0x00010EC0 File Offset: 0x0000F0C0 [Token(Token = "0x60019B8")] [Address(RVA = "0x2BADCE0", Offset = "0x2BACCE0", VA = "0x182BADCE0", Slot = "20")] public override int EndRead(IAsyncResult asyncResult) { return 0; } ///

Writes a block of bytes to the file stream.

/// The buffer containing data to write to the stream. /// The zero-based byte offset in from which to begin copying bytes to the stream. /// The maximum number of bytes to write. /// /// is . /// /// and describe an invalid range in . /// /// or is negative. /// An I/O error occurred. /// -or- /// Another thread may have caused an unexpected change in the position of the operating system's file handle. /// The stream is closed. /// The current stream instance does not support writing. // Token: 0x060019B9 RID: 6585 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019B9")] [Address(RVA = "0x2BAFAB0", Offset = "0x2BAEAB0", VA = "0x182BAFAB0", Slot = "29")] public override void Write(byte[] array, int offset, int count) { } // Token: 0x060019BA RID: 6586 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019BA")] [Address(RVA = "0x2BAF800", Offset = "0x2BAE800", VA = "0x182BAF800")] private void WriteInternal(byte[] src, int offset, int count) { } ///

Begins an asynchronous write operation. Consider using instead.

/// The buffer containing data to write to the current stream. /// The zero-based byte offset in at which to begin copying bytes to the current stream. /// The maximum number of bytes to write. /// The method to be called when the asynchronous write operation is completed. /// A user-provided object that distinguishes this particular asynchronous write request from other requests. /// An object that references the asynchronous write. /// /// length minus is less than . /// /// is . /// /// or is negative. /// The stream does not support writing. /// The stream is closed. /// An I/O error occurred. // Token: 0x060019BB RID: 6587 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019BB")] [Address(RVA = "0x2BAD700", Offset = "0x2BAC700", VA = "0x182BAD700", Slot = "22")] public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject) { return null; } ///

Ends an asynchronous write operation and blocks until the I/O operation is complete. (Consider using instead.)

/// The pending asynchronous I/O request. /// /// is . /// This object was not created by calling on this class. /// /// is called multiple times. /// The stream is closed or an internal error has occurred. // Token: 0x060019BC RID: 6588 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019BC")] [Address(RVA = "0x2BADE60", Offset = "0x2BACE60", VA = "0x182BADE60", Slot = "23")] public override void EndWrite(IAsyncResult asyncResult) { } ///

Sets the current position of this stream to the given value.

/// The point relative to from which to begin seeking. /// Specifies the beginning, the end, or the current position as a reference point for , using a value of type . /// The new position in the stream. /// An I/O error occurred. /// The stream does not support seeking, such as if the is constructed from a pipe or console output. /// Seeking is attempted before the beginning of the stream. /// Methods were called after the stream was closed. // Token: 0x060019BD RID: 6589 RVA: 0x00010ED8 File Offset: 0x0000F0D8 [Token(Token = "0x60019BD")] [Address(RVA = "0x2BAF1C0", Offset = "0x2BAE1C0", VA = "0x182BAF1C0", Slot = "25")] public override long Seek(long offset, SeekOrigin origin) { return 0L; } ///

Sets the length of this stream to the given value.

/// The new length of the stream. /// An I/O error has occurred. /// The stream does not support both writing and seeking. /// Attempted to set the parameter to less than 0. // Token: 0x060019BE RID: 6590 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019BE")] [Address(RVA = "0x2BAF450", Offset = "0x2BAE450", VA = "0x182BAF450", Slot = "26")] public override void SetLength(long value) { } ///

Clears buffers for this stream and causes any buffered data to be written to the file.

/// An I/O error occurred. /// The stream is closed. // Token: 0x060019BF RID: 6591 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019BF")] [Address(RVA = "0x2BAE320", Offset = "0x2BAD320", VA = "0x182BAE320", Slot = "17")] public override void Flush() { } ///

Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the .

// Token: 0x060019C0 RID: 6592 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019C0")] [Address(RVA = "0x2BAE010", Offset = "0x2BAD010", VA = "0x182BAE010", Slot = "1")] protected override void Finalize() { } ///

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

/// /// to release both managed and unmanaged resources; to release only unmanaged resources. // Token: 0x060019C1 RID: 6593 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019C1")] [Address(RVA = "0x2BAD9D0", Offset = "0x2BAC9D0", VA = "0x182BAD9D0", Slot = "16")] protected override void Dispose(bool disposing) { } ///

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

/// The token to monitor for cancellation requests. /// A task that represents the asynchronous flush operation. /// The stream has been disposed. // Token: 0x060019C2 RID: 6594 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019C2")] [Address(RVA = "0x2BAE090", Offset = "0x2BAD090", VA = "0x182BAE090", Slot = "18")] public override Task FlushAsync(CancellationToken cancellationToken) { return null; } ///

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.

/// 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. /// 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. /// /// is . /// /// or is negative. /// The sum of and is larger than the buffer length. /// The stream does not support reading. /// The stream has been disposed. /// The stream is currently in use by a previous read operation. // Token: 0x060019C3 RID: 6595 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019C3")] [Address(RVA = "0x2BAEA30", Offset = "0x2BADA30", VA = "0x182BAEA30", Slot = "21")] public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { return null; } ///

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.

/// 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. /// A task that represents the asynchronous write operation. /// /// is . /// /// or is negative. /// The sum of and is larger than the buffer length. /// The stream does not support writing. /// The stream has been disposed. /// The stream is currently in use by a previous write operation. // Token: 0x060019C4 RID: 6596 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019C4")] [Address(RVA = "0x2BAF680", Offset = "0x2BAE680", VA = "0x182BAF680", Slot = "24")] public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { return null; } // Token: 0x060019C5 RID: 6597 RVA: 0x00010EF0 File Offset: 0x0000F0F0 [Token(Token = "0x60019C5")] [Address(RVA = "0x2BAEDB0", Offset = "0x2BADDB0", VA = "0x182BAEDB0")] private int ReadSegment(byte[] dest, int dest_offset, int count) { return 0; } // Token: 0x060019C6 RID: 6598 RVA: 0x00010F08 File Offset: 0x0000F108 [Token(Token = "0x60019C6")] [Address(RVA = "0x2BAFA40", Offset = "0x2BAEA40", VA = "0x182BAFA40")] private int WriteSegment(byte[] src, int src_offset, int count) { return 0; } // Token: 0x060019C7 RID: 6599 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019C7")] [Address(RVA = "0x2BAE130", Offset = "0x2BAD130", VA = "0x182BAE130")] private void FlushBuffer() { } // Token: 0x060019C8 RID: 6600 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019C8")] [Address(RVA = "0x2BAE120", Offset = "0x2BAD120", VA = "0x182BAE120")] private void FlushBufferIfDirty() { } // Token: 0x060019C9 RID: 6601 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019C9")] [Address(RVA = "0x2BAF180", Offset = "0x2BAE180", VA = "0x182BAF180")] private void RefillBuffer() { } // Token: 0x060019CA RID: 6602 RVA: 0x00010F20 File Offset: 0x0000F120 [Token(Token = "0x60019CA")] [Address(RVA = "0x2BAEBB0", Offset = "0x2BADBB0", VA = "0x182BAEBB0")] private int ReadData(SafeHandle safeHandle, byte[] buf, int offset, int count) { return 0; } // Token: 0x060019CB RID: 6603 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x60019CB")] [Address(RVA = "0x2BAE4F0", Offset = "0x2BAD4F0", VA = "0x182BAE4F0")] private void InitBuffer(int size, bool isZeroSize) { } // Token: 0x060019CC RID: 6604 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019CC")] [Address(RVA = "0x2BAE3A0", Offset = "0x2BAD3A0", VA = "0x182BAE3A0")] private string GetSecureFileName(string filename) { return null; } // Token: 0x060019CD RID: 6605 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x60019CD")] [Address(RVA = "0x2BAE430", Offset = "0x2BAD430", VA = "0x182BAE430")] private string GetSecureFileName(string filename, bool full) { return null; } // Token: 0x04000D8C RID: 3468 [Token(Token = "0x4000D8C")] internal const int DefaultBufferSize = 4096; // Token: 0x04000D8D RID: 3469 [Token(Token = "0x4000D8D")] private static byte[] buf_recycle; // Token: 0x04000D8E RID: 3470 [Token(Token = "0x4000D8E")] private static readonly object buf_recycle_lock; // Token: 0x04000D8F RID: 3471 [global::Cpp2IlInjected.FieldOffset(Offset = "0x28")] [Token(Token = "0x4000D8F")] private byte[] buf; // Token: 0x04000D90 RID: 3472 [global::Cpp2IlInjected.FieldOffset(Offset = "0x30")] [Token(Token = "0x4000D90")] private string name; // Token: 0x04000D91 RID: 3473 [global::Cpp2IlInjected.FieldOffset(Offset = "0x38")] [Token(Token = "0x4000D91")] private SafeFileHandle safeHandle; // Token: 0x04000D92 RID: 3474 [global::Cpp2IlInjected.FieldOffset(Offset = "0x40")] [Token(Token = "0x4000D92")] private bool isExposed; // Token: 0x04000D93 RID: 3475 [global::Cpp2IlInjected.FieldOffset(Offset = "0x48")] [Token(Token = "0x4000D93")] private long append_startpos; // Token: 0x04000D94 RID: 3476 [global::Cpp2IlInjected.FieldOffset(Offset = "0x50")] [Token(Token = "0x4000D94")] private FileAccess access; // Token: 0x04000D95 RID: 3477 [global::Cpp2IlInjected.FieldOffset(Offset = "0x54")] [Token(Token = "0x4000D95")] private bool owner; // Token: 0x04000D96 RID: 3478 [global::Cpp2IlInjected.FieldOffset(Offset = "0x55")] [Token(Token = "0x4000D96")] private bool async; // Token: 0x04000D97 RID: 3479 [global::Cpp2IlInjected.FieldOffset(Offset = "0x56")] [Token(Token = "0x4000D97")] private bool canseek; // Token: 0x04000D98 RID: 3480 [global::Cpp2IlInjected.FieldOffset(Offset = "0x57")] [Token(Token = "0x4000D98")] private bool anonymous; // Token: 0x04000D99 RID: 3481 [global::Cpp2IlInjected.FieldOffset(Offset = "0x58")] [Token(Token = "0x4000D99")] private bool buf_dirty; // Token: 0x04000D9A RID: 3482 [global::Cpp2IlInjected.FieldOffset(Offset = "0x5C")] [Token(Token = "0x4000D9A")] private int buf_size; // Token: 0x04000D9B RID: 3483 [global::Cpp2IlInjected.FieldOffset(Offset = "0x60")] [Token(Token = "0x4000D9B")] private int buf_length; // Token: 0x04000D9C RID: 3484 [global::Cpp2IlInjected.FieldOffset(Offset = "0x64")] [Token(Token = "0x4000D9C")] private int buf_offset; // Token: 0x04000D9D RID: 3485 [global::Cpp2IlInjected.FieldOffset(Offset = "0x68")] [Token(Token = "0x4000D9D")] private long buf_start; // Token: 0x020002BC RID: 700 // (Invoke) Token: 0x060019D0 RID: 6608 [Token(Token = "0x20002BC")] private delegate int ReadDelegate(byte[] buffer, int offset, int count); // Token: 0x020002BD RID: 701 // (Invoke) Token: 0x060019D4 RID: 6612 [Token(Token = "0x20002BD")] private delegate void WriteDelegate(byte[] buffer, int offset, int count); } }