public void CallbackForCompletedReadAtEndOfEmptyFile() { FileAsyncIOResult result; using (var io = new IOCompletionManager()) using (var target = new BlockingCompletionTarget(bufferSize: 10)) using ( SafeFileHandle handle = CreateOrOpenFile( GetFullPath("emptyFile"), FileDesiredAccess.GenericWrite | FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Create)) { io.BindFileHandle(handle); unsafe { io.ReadFileOverlapped(target, handle, target.PinBuffer(), target.Buffer.Length, fileOffset: 0); } result = target.Wait(); } XAssert.IsTrue(result.ErrorIndicatesEndOfFile, "File is empty; EOF read expected"); XAssert.AreEqual(FileAsyncIOStatus.Failed, result.Status); }
private static void WithReadableStream(string path, Func <AsyncFileStream, Task> action) { #if NET_FRAMEWORK using (var io = new IOCompletionManager()) #else IIOCompletionManager io = null; #endif { using ( IAsyncFile file = AsyncFileFactory.CreateOrOpen( path, FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Open, FileFlagsAndAttributes.None, io)) { using (AsyncFileStream stream = file.CreateReadableStream()) { XAssert.IsTrue(stream.CanRead); XAssert.IsTrue(stream.CanSeek); XAssert.IsFalse(stream.CanWrite); action(stream).GetAwaiter().GetResult(); } } } }
public async Task ReadEmptyFile() { string path = GetFullPath("file"); using (File.Create(path)) { } #if NET_FRAMEWORK using (var io = new IOCompletionManager()) #else IIOCompletionManager io = null; #endif { using ( IAsyncFile file = AsyncFileFactory.CreateOrOpen( path, FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Open, FileFlagsAndAttributes.None, io)) { XAssert.IsTrue(file.CanRead); XAssert.IsFalse(file.CanWrite); var buffer = new byte[10]; FileAsyncIOResult result = await file.ReadAsync(buffer, buffer.Length, 0); XAssert.AreEqual(FileAsyncIOStatus.Failed, result.Status); XAssert.IsTrue(result.ErrorIndicatesEndOfFile); result = await file.ReadAsync(buffer, buffer.Length, 16); XAssert.AreEqual(FileAsyncIOStatus.Failed, result.Status); XAssert.IsTrue(result.ErrorIndicatesEndOfFile); } } }
public void ReadFileToEnd() { const int NumberOfWords = 1024 * 1024; const int TotalSize = NumberOfWords * 4; string path = GetFullPath("file"); using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Delete)) using (var writer = new BinaryWriter(fs, Encoding.UTF8, leaveOpen: true)) { for (int i = 0; i < NumberOfWords; i++) { writer.Write((int)i); } } using (var memoryStream = new MemoryStream(capacity: NumberOfWords * 4)) { using (var io = new IOCompletionManager()) using (var target = new BlockingCompletionTarget(bufferSize: 64 * 1024)) using ( SafeFileHandle handle = CreateOrOpenFile( path, FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Open)) { io.BindFileHandle(handle); while (true) { unsafe { io.ReadFileOverlapped(target, handle, target.PinBuffer(), target.Buffer.Length, fileOffset: memoryStream.Length); } FileAsyncIOResult result = target.Wait(); if (result.Status == FileAsyncIOStatus.Failed) { XAssert.IsTrue(result.ErrorIndicatesEndOfFile, "Unexpected non-EOF read failure."); break; } else { XAssert.AreEqual(FileAsyncIOStatus.Succeeded, result.Status); } XAssert.AreNotEqual(0, result.BytesTransferred); XAssert.IsTrue( memoryStream.Length + result.BytesTransferred <= TotalSize, "Too many bytes read; Read {0} so far and just got another {1} bytes", memoryStream.Length, result.BytesTransferred); memoryStream.Write(target.Buffer, 0, result.BytesTransferred); } } memoryStream.Position = 0; using (var reader = new BinaryReader(memoryStream, Encoding.UTF8, leaveOpen: true)) { for (int i = 0; i < NumberOfWords; i++) { XAssert.AreEqual(i, reader.ReadInt32(), "File contents read incorrectly; offset {0}", i * 4); } } } }
public void ConcurrentReadsSingleBatch() { const int NumberOfConcurrentReads = 128; // This should be larger than the batch size at which we allocate OVERLAPPED structures. WithPipePair( (server, client) => { using (var io = new IOCompletionManager()) { io.BindFileHandle(client); var targets = new BlockingCompletionTarget[NumberOfConcurrentReads]; var completions = new bool[NumberOfConcurrentReads]; var bufferToWrite = new byte[NumberOfConcurrentReads * 4]; using (var writeBufferStream = new MemoryStream(bufferToWrite, writable: true)) { using (var writer = new BinaryWriter(writeBufferStream)) { for (int i = 0; i < NumberOfConcurrentReads; i++) { writer.Write((int)i); } } } try { for (int i = 0; i < targets.Length; i++) { targets[i] = new BlockingCompletionTarget(bufferSize: 8); unsafe { // Note that non-seekable streams mandate an offset of 0 for all requests. // https://msdn.microsoft.com/en-us/library/windows/desktop/ms684342%28v=vs.85%29.aspx io.ReadFileOverlapped(targets[i], client, targets[i].PinBuffer(), 4, fileOffset: 0); } } server.Write(bufferToWrite, 0, bufferToWrite.Length); server.Flush(); for (int i = 0; i < targets.Length; i++) { FileAsyncIOResult result = targets[i].Wait(); XAssert.AreEqual(FileAsyncIOStatus.Succeeded, result.Status); XAssert.AreEqual(result.BytesTransferred, 4); int completedValue = BitConverter.ToInt32(targets[i].Buffer, 0); XAssert.IsTrue(completedValue >= 0 && completedValue < completions.Length); XAssert.IsFalse(completions[completedValue], "Value {0} completed multiple times", completedValue); completions[completedValue] = true; } } finally { foreach (BlockingCompletionTarget target in targets) { if (target != null) { target.Dispose(); } } } } }); }
public async Task ReadFileRandomAccess() { const int NumberOfReads = 16; const int NumberOfWordsPerRead = 64 * 1024; const int NumberOfBytesPerRead = NumberOfWordsPerRead * 4; const int NumberOfWords = NumberOfWordsPerRead * NumberOfReads; const int TotalSize = NumberOfWords * 4; string path = GetFullPath("file"); using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Delete)) { using (var writer = new BinaryWriter(fs, Encoding.UTF8, leaveOpen: true)) { for (int i = 0; i < NumberOfWords; i++) { writer.Write((int)i); } } } #if NET_FRAMEWORK using (var io = new IOCompletionManager()) #else IIOCompletionManager io = null; #endif { using ( IAsyncFile file = AsyncFileFactory.CreateOrOpen( path, FileDesiredAccess.GenericRead, FileShare.Read | FileShare.Delete, FileMode.Open, FileFlagsAndAttributes.None, io)) { XAssert.IsTrue(file.CanRead); XAssert.IsFalse(file.CanWrite); var readBuffer = new byte[TotalSize]; var readTasks = new Task[NumberOfReads]; for (int i = 0; i < readTasks.Length; i++) { int offset = NumberOfBytesPerRead * i; readTasks[i] = Task.Run( async() => { byte[] localBuffer = new byte[NumberOfBytesPerRead]; int readSoFar = 0; while (readSoFar < NumberOfBytesPerRead) { FileAsyncIOResult result = await file.ReadAsync(localBuffer, bytesToRead: NumberOfBytesPerRead - readSoFar, fileOffset: offset + readSoFar); XAssert.AreEqual(FileAsyncIOStatus.Succeeded, result.Status); XAssert.IsTrue(result.BytesTransferred > 0); XAssert.IsTrue(readSoFar + result.BytesTransferred <= NumberOfBytesPerRead); Buffer.BlockCopy(localBuffer, 0, readBuffer, offset + readSoFar, result.BytesTransferred); readSoFar += result.BytesTransferred; } Contract.Assert(readSoFar == NumberOfBytesPerRead); }); } for (int i = 0; i < readTasks.Length; i++) { await readTasks[i]; } using (var reader = new BinaryReader(new MemoryStream(readBuffer, writable: false), Encoding.UTF8, leaveOpen: false)) { for (int i = 0; i < NumberOfWords; i++) { XAssert.AreEqual(i, reader.ReadInt32()); } } } } }