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: 0x020002B4 RID: 692 [Token(Token = "0x20002B4")] [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: 0x0600195D RID: 6493 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600195D")] [Address(RVA = "0x2938D60", Offset = "0x2937B60", VA = "0x182938D60")] [Obsolete] public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize) { } // Token: 0x0600195E RID: 6494 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600195E")] [Address(RVA = "0x2938FA0", Offset = "0x2937DA0", VA = "0x182938FA0")] 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: 0x0600195F RID: 6495 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600195F")] [Address(RVA = "0x2938F20", Offset = "0x2937D20", VA = "0x182938F20")] 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: 0x06001963 RID: 6499 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001963")] [Address(RVA = "0x2938ED0", Offset = "0x2937CD0", VA = "0x182938ED0")] 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: 0x06001964 RID: 6500 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001964")] [Address(RVA = "0x29398B0", Offset = "0x29386B0", VA = "0x1829398B0")] public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options) { } // Token: 0x06001965 RID: 6501 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001965")] [Address(RVA = "0x2938CB0", Offset = "0x2937AB0", VA = "0x182938CB0")] 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: 0x06001966 RID: 6502 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001966")] [Address(RVA = "0x2938C50", Offset = "0x2937A50", VA = "0x182938C50")] internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool isAsync, bool anonymous) { } // Token: 0x06001967 RID: 6503 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001967")] [Address(RVA = "0x2939110", Offset = "0x2937F10", VA = "0x182939110")] internal FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool anonymous, FileOptions options) { } // Token: 0x06001968 RID: 6504 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001968")] [Address(RVA = "0x2937630", Offset = "0x2936430", VA = "0x182937630")] 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: 0x17000306 RID: 774 // (get) Token: 0x06001969 RID: 6505 RVA: 0x00010AA0 File Offset: 0x0000ECA0 [Token(Token = "0x17000306")] public override bool CanRead { [Token(Token = "0x6001969")] [Address(RVA = "0x29398F0", Offset = "0x29386F0", VA = "0x1829398F0", 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: 0x17000307 RID: 775 // (get) Token: 0x0600196A RID: 6506 RVA: 0x00010AB8 File Offset: 0x0000ECB8 [Token(Token = "0x17000307")] public override bool CanWrite { [Token(Token = "0x600196A")] [Address(RVA = "0x2939900", Offset = "0x2938700", VA = "0x182939900", 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: 0x17000308 RID: 776 // (get) Token: 0x0600196B RID: 6507 RVA: 0x00010AD0 File Offset: 0x0000ECD0 [Token(Token = "0x17000308")] public override bool CanSeek { [Token(Token = "0x600196B")] [Address(RVA = "0xD52990", Offset = "0xD51790", VA = "0x180D52990", Slot = "8")] get { return default(bool); } } ///

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: 0x17000309 RID: 777 // (get) Token: 0x0600196C RID: 6508 RVA: 0x00010AE8 File Offset: 0x0000ECE8 [Token(Token = "0x17000309")] public override long Length { [Token(Token = "0x600196C")] [Address(RVA = "0x2939920", Offset = "0x2938720", VA = "0x182939920", 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: 0x1700030A RID: 778 // (get) Token: 0x0600196D RID: 6509 RVA: 0x00010B00 File Offset: 0x0000ED00 // (set) Token: 0x0600196E RID: 6510 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x1700030A")] public override long Position { [Token(Token = "0x600196D")] [Address(RVA = "0x2939AA0", Offset = "0x29388A0", VA = "0x182939AA0", Slot = "11")] get { return 0L; } [Token(Token = "0x600196E")] [Address(RVA = "0x2939C70", Offset = "0x2938A70", VA = "0x182939C70", 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: 0x1700030B RID: 779 // (get) Token: 0x0600196F RID: 6511 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x1700030B")] public virtual SafeFileHandle SafeFileHandle { [Token(Token = "0x600196F")] [Address(RVA = "0x2939C30", Offset = "0x2938A30", VA = "0x182939C30", Slot = "31")] get { return null; } } // Token: 0x06001970 RID: 6512 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001970")] [Address(RVA = "0x2936CA0", Offset = "0x2935AA0", VA = "0x182936CA0")] 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: 0x06001971 RID: 6513 RVA: 0x00010B18 File Offset: 0x0000ED18 [Token(Token = "0x6001971")] [Address(RVA = "0x2937940", Offset = "0x2936740", VA = "0x182937940", 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: 0x06001972 RID: 6514 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001972")] [Address(RVA = "0x2938590", Offset = "0x2937390", VA = "0x182938590", 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: 0x06001973 RID: 6515 RVA: 0x00010B30 File Offset: 0x0000ED30 [Token(Token = "0x6001973")] [Address(RVA = "0x2937D70", Offset = "0x2936B70", VA = "0x182937D70", Slot = "27")] public override int Read([In] [Out] byte[] array, int offset, int count) { return 0; } // Token: 0x06001974 RID: 6516 RVA: 0x00010B48 File Offset: 0x0000ED48 [Token(Token = "0x6001974")] [Address(RVA = "0x2937BE0", Offset = "0x29369E0", VA = "0x182937BE0")] 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: 0x06001975 RID: 6517 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x6001975")] [Address(RVA = "0x2935FF0", Offset = "0x2934DF0", VA = "0x182935FF0", 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: 0x06001976 RID: 6518 RVA: 0x00010B60 File Offset: 0x0000ED60 [Token(Token = "0x6001976")] [Address(RVA = "0x2936990", Offset = "0x2935790", VA = "0x182936990", 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: 0x06001977 RID: 6519 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001977")] [Address(RVA = "0x29389B0", Offset = "0x29377B0", VA = "0x1829389B0", Slot = "29")] public override void Write(byte[] array, int offset, int count) { } // Token: 0x06001978 RID: 6520 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001978")] [Address(RVA = "0x2938700", Offset = "0x2937500", VA = "0x182938700")] 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: 0x06001979 RID: 6521 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x6001979")] [Address(RVA = "0x29362E0", Offset = "0x29350E0", VA = "0x1829362E0", 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: 0x0600197A RID: 6522 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600197A")] [Address(RVA = "0x2936B20", Offset = "0x2935920", VA = "0x182936B20", 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: 0x0600197B RID: 6523 RVA: 0x00010B78 File Offset: 0x0000ED78 [Token(Token = "0x600197B")] [Address(RVA = "0x29380C0", Offset = "0x2936EC0", VA = "0x1829380C0", 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: 0x0600197C RID: 6524 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600197C")] [Address(RVA = "0x2938350", Offset = "0x2937150", VA = "0x182938350", 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: 0x0600197D RID: 6525 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600197D")] [Address(RVA = "0x29371D0", Offset = "0x2935FD0", VA = "0x1829371D0", Slot = "17")] public override void Flush() { } ///

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

// Token: 0x0600197E RID: 6526 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600197E")] [Address(RVA = "0x2936CD0", Offset = "0x2935AD0", VA = "0x182936CD0", 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: 0x0600197F RID: 6527 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x600197F")] [Address(RVA = "0x2936680", Offset = "0x2935480", VA = "0x182936680", 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: 0x06001980 RID: 6528 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x6001980")] [Address(RVA = "0x2936D50", Offset = "0x2935B50", VA = "0x182936D50", 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: 0x06001981 RID: 6529 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x6001981")] [Address(RVA = "0x2937930", Offset = "0x2936730", VA = "0x182937930", 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: 0x06001982 RID: 6530 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x6001982")] [Address(RVA = "0x2938580", Offset = "0x2937380", VA = "0x182938580", Slot = "24")] public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { return null; } // Token: 0x06001983 RID: 6531 RVA: 0x00010B90 File Offset: 0x0000ED90 [Token(Token = "0x6001983")] [Address(RVA = "0x2937CB0", Offset = "0x2936AB0", VA = "0x182937CB0")] private int ReadSegment(byte[] dest, int dest_offset, int count) { return 0; } // Token: 0x06001984 RID: 6532 RVA: 0x00010BA8 File Offset: 0x0000EDA8 [Token(Token = "0x6001984")] [Address(RVA = "0x2938940", Offset = "0x2937740", VA = "0x182938940")] private int WriteSegment(byte[] src, int src_offset, int count) { return 0; } // Token: 0x06001985 RID: 6533 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001985")] [Address(RVA = "0x2936FE0", Offset = "0x2935DE0", VA = "0x182936FE0")] private void FlushBuffer() { } // Token: 0x06001986 RID: 6534 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001986")] [Address(RVA = "0x2936FD0", Offset = "0x2935DD0", VA = "0x182936FD0")] private void FlushBufferIfDirty() { } // Token: 0x06001987 RID: 6535 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001987")] [Address(RVA = "0x2938080", Offset = "0x2936E80", VA = "0x182938080")] private void RefillBuffer() { } // Token: 0x06001988 RID: 6536 RVA: 0x00010BC0 File Offset: 0x0000EDC0 [Token(Token = "0x6001988")] [Address(RVA = "0x2937AB0", Offset = "0x29368B0", VA = "0x182937AB0")] private int ReadData(SafeHandle safeHandle, byte[] buf, int offset, int count) { return 0; } // Token: 0x06001989 RID: 6537 RVA: 0x00002050 File Offset: 0x00000250 [Token(Token = "0x6001989")] [Address(RVA = "0x29373F0", Offset = "0x29361F0", VA = "0x1829373F0")] private void InitBuffer(int size, bool isZeroSize) { } // Token: 0x0600198A RID: 6538 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x600198A")] [Address(RVA = "0x2937250", Offset = "0x2936050", VA = "0x182937250")] private string GetSecureFileName(string filename) { return null; } // Token: 0x0600198B RID: 6539 RVA: 0x00002082 File Offset: 0x00000282 [Token(Token = "0x600198B")] [Address(RVA = "0x2937330", Offset = "0x2936130", VA = "0x182937330")] private string GetSecureFileName(string filename, bool full) { return null; } // Token: 0x04000D82 RID: 3458 [Token(Token = "0x4000D82")] internal const int DefaultBufferSize = 4096; // Token: 0x04000D83 RID: 3459 [Token(Token = "0x4000D83")] private static byte[] buf_recycle; // Token: 0x04000D84 RID: 3460 [Token(Token = "0x4000D84")] private static readonly object buf_recycle_lock; // Token: 0x04000D85 RID: 3461 [global::Cpp2IlInjected.FieldOffset(Offset = "0x28")] [Token(Token = "0x4000D85")] private byte[] buf; // Token: 0x04000D86 RID: 3462 [global::Cpp2IlInjected.FieldOffset(Offset = "0x30")] [Token(Token = "0x4000D86")] private string name; // Token: 0x04000D87 RID: 3463 [global::Cpp2IlInjected.FieldOffset(Offset = "0x38")] [Token(Token = "0x4000D87")] private SafeFileHandle safeHandle; // Token: 0x04000D88 RID: 3464 [global::Cpp2IlInjected.FieldOffset(Offset = "0x40")] [Token(Token = "0x4000D88")] private bool isExposed; // Token: 0x04000D89 RID: 3465 [global::Cpp2IlInjected.FieldOffset(Offset = "0x48")] [Token(Token = "0x4000D89")] private long append_startpos; // Token: 0x04000D8A RID: 3466 [global::Cpp2IlInjected.FieldOffset(Offset = "0x50")] [Token(Token = "0x4000D8A")] private FileAccess access; // Token: 0x04000D8B RID: 3467 [global::Cpp2IlInjected.FieldOffset(Offset = "0x54")] [Token(Token = "0x4000D8B")] private bool owner; // Token: 0x04000D8C RID: 3468 [global::Cpp2IlInjected.FieldOffset(Offset = "0x55")] [Token(Token = "0x4000D8C")] private bool async; // Token: 0x04000D8D RID: 3469 [global::Cpp2IlInjected.FieldOffset(Offset = "0x56")] [Token(Token = "0x4000D8D")] private bool canseek; // Token: 0x04000D8E RID: 3470 [global::Cpp2IlInjected.FieldOffset(Offset = "0x57")] [Token(Token = "0x4000D8E")] private bool anonymous; // Token: 0x04000D8F RID: 3471 [global::Cpp2IlInjected.FieldOffset(Offset = "0x58")] [Token(Token = "0x4000D8F")] private bool buf_dirty; // Token: 0x04000D90 RID: 3472 [global::Cpp2IlInjected.FieldOffset(Offset = "0x5C")] [Token(Token = "0x4000D90")] private int buf_size; // Token: 0x04000D91 RID: 3473 [global::Cpp2IlInjected.FieldOffset(Offset = "0x60")] [Token(Token = "0x4000D91")] private int buf_length; // Token: 0x04000D92 RID: 3474 [global::Cpp2IlInjected.FieldOffset(Offset = "0x64")] [Token(Token = "0x4000D92")] private int buf_offset; // Token: 0x04000D93 RID: 3475 [global::Cpp2IlInjected.FieldOffset(Offset = "0x68")] [Token(Token = "0x4000D93")] private long buf_start; // Token: 0x020002B5 RID: 693 // (Invoke) Token: 0x0600198E RID: 6542 [Token(Token = "0x20002B5")] private delegate int ReadDelegate(byte[] buffer, int offset, int count); // Token: 0x020002B6 RID: 694 // (Invoke) Token: 0x06001992 RID: 6546 [Token(Token = "0x20002B6")] private delegate void WriteDelegate(byte[] buffer, int offset, int count); } }