| public EndRead ( IAsyncResult asyncResult ) : int | ||
| asyncResult | IAsyncResult | |
| return | int | |
static void Main(string[] args)
{
//AsyncReadOneFile();
//AsyncReadMultiplyFiles();
FileStream fs = new FileStream(@"../../Program.cs", FileMode.Open,
FileAccess.Read, FileShare.Read, 1024,
FileOptions.Asynchronous);
Byte[] data = new Byte[100];
IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
while (!ar.IsCompleted)
{
Console.WriteLine("Операция не завершена, ожидайте...");
Thread.Sleep(10);
}
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Количество считаных байт = {0}", bytesRead);
Console.WriteLine(Encoding.UTF8.GetString(data).Remove(0, 1));
}
private static void AsyncReadOneFileCallBackAnonimus()
{
Byte[] data = new Byte[100];
Console.WriteLine("Основной поток ID = {0}",
Thread.CurrentThread.ManagedThreadId);
FileStream fs = new FileStream(@"../../Program.cs", FileMode.Open,
FileAccess.Read, FileShare.Read, 1024,
FileOptions.Asynchronous);
fs.BeginRead(data, 0, data.Length, delegate(IAsyncResult ar)
{
Console.WriteLine("Чтение в потоке {0} закончено",
Thread.CurrentThread.ManagedThreadId);
Int32 bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Количество считаных байт = {0}", bytesRead);
Console.WriteLine(Encoding.UTF8.GetString(data).Remove(0, 1));
Console.ReadLine();
}, null);
Console.ReadLine();
}
private void ReadFileAsync(Action <byte[]> callback)
{
_fileStream.BeginRead(_fileBuffer, 0, _fileBuffer.Length,
c =>
{
if (this._isStopTask)
{
return;
}
int readlenght = _fileStream.EndRead(c);
if (readlenght != _fileBuffer.Length)
{
IsReadEnd();
byte[] buf = new byte[readlenght];
Array.Copy(_fileBuffer, 0, buf, 0, readlenght);
callback?.Invoke(buf);
}
else
{
IsReadEnd();
callback?.Invoke(_fileBuffer);
}
void IsReadEnd()
{
if (_fileStream.Length == _fileStream.Position)
{
this.CloseFileStream();
}
}
}, null);
}
protected void ReadCompleted(IAsyncResult iResult)
{
byte[] arrBuff = (byte[])iResult.AsyncState;
try
{
File.EndRead(iResult); // call end read : this throws any exceptions that happened during the read
try
{
InputReport oInRep = CreateInputReport(); // Create the input report for the device
oInRep.SetData(arrBuff); // and set the data portion - this processes the data received into a more easily understood format depending upon the report type
HandleDataReceived(oInRep); // pass the new input report on to the higher level handler
}
finally
{
BeginAsyncRead(); // when all that is done, kick off another read for the next report
}
}
catch (IOException ex)
{
HandleDeviceRemoved();
if (OnDeviceRemoved != null)
{
OnDeviceRemoved(this, new EventArgs());
}
Dispose();
}
}
static void Main(string[] args)
{
// open filestream for asynchronous read
FileStream fs = new FileStream("somedata.dat", FileMode.Open,
FileAccess.Read, FileShare.Read, 1024,
FileOptions.Asynchronous);
// byte array to hold 100 bytes of data
Byte[] data = new Byte[100];
// initiate asynchronous read operation, reading first 100 bytes
IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
// could do something in here which would run alongside file read...
// check for file read complete
while (!ar.IsCompleted)
{
Console.WriteLine("Operation not completed");
Thread.Sleep(10);
}
// get the result
int bytesRead = fs.EndRead(ar);
fs.Close();
Console.WriteLine("Number of bytes read={0}", bytesRead);
Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
}
public void EndReadThrowsForNullAsyncResult()
{
using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite))
{
Assert.Throws<ArgumentNullException>("asyncResult", () => fs.EndRead(null));
}
}
public void ReadAsync(Action <byte[]> callback)
{
if (!Exists)
{
throw new System.IO.IOException("file is not exists");
}
//todo:需要测试
System.IO.FileStream fs = new System.IO.FileStream(FullName,
System.IO.FileMode.Open,
System.IO.FileAccess.Read,
System.IO.FileShare.None,
bufferSize: 1024,
useAsync: true
);
byte[] data = new byte[fs.Length];
fs.BeginRead(data, 0, data.Length, (result) => {
fs.EndRead(result);
data = Decrypted(data);
fs.Close();
fs.Dispose();
callback.Invoke(data);
}, null);
}
/// <summary>
/// Demonstrates the use of the APM with files, through the FileStream class.
/// This method performs asynchronous reads and writes to copy data from an input
/// file to an output file. Reads and writes are interlaced, and proceed in chunks
/// of 8KB at a time (displaying progress to the console).
/// </summary>
static void APMWithFiles()
{
FileStream reader = new FileStream("sample.txt", FileMode.Open);
FileStream writer = new FileStream("sample2.txt", FileMode.Create);
byte[] buffer1 = new byte[8192], buffer2 = new byte[8192];
IAsyncResult ar1, ar2 = null;
while (true)
{
ar1 = reader.BeginRead(buffer1, 0, buffer1.Length, null, null);
while (!ar1.IsCompleted)
{
Console.Write("R");
}
if (ar2 != null)
{
while (!ar2.IsCompleted)
{
Console.Write("W");
}
}
int bytesRead;
if ((bytesRead = reader.EndRead(ar1)) == 0)
break; //No more data to read
if (ar2 != null)
{
writer.EndWrite(ar2);
}
Array.Copy(buffer1, buffer2, bytesRead);
ar2 = writer.BeginWrite(buffer2, 0, bytesRead, null, null);
}
Console.WriteLine();
Console.WriteLine();
}
public override int EndRead(IAsyncResult asyncResult)
{
if (_m_disposed)
{
throw ADP.ObjectDisposed(this);
}
return(_m_fs.EndRead(asyncResult));
}
public static void ApplyIPSPatch(string romname, string patchname)
{
// Noobish Noobsicle wrote this IPS patching code
// romname is the original ROM, patchname is the patch to apply
FileStream romstream = new FileStream(romname, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
FileStream ipsstream = new FileStream(patchname, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
int lint = (int)ipsstream.Length;
byte[] ipsbyte = new byte[ipsstream.Length];
byte[] rombyte = new byte[romstream.Length];
IAsyncResult romresult;
IAsyncResult ipsresult = ipsstream.BeginRead(ipsbyte, 0, lint, null, null);
ipsstream.EndRead(ipsresult);
int ipson = 5;
int totalrepeats = 0;
int offset = 0;
bool keepgoing = true;
while (keepgoing == true)
{
offset = ipsbyte[ipson] * 0x10000 + ipsbyte[ipson + 1] * 0x100 + ipsbyte[ipson + 2];
ipson++;
ipson++;
ipson++;
if (ipsbyte[ipson] * 256 + ipsbyte[ipson + 1] == 0)
{
ipson++;
ipson++;
totalrepeats = ipsbyte[ipson] * 256 + ipsbyte[ipson + 1];
ipson++;
ipson++;
byte[] repeatbyte = new byte[totalrepeats];
for (int ontime = 0; ontime < totalrepeats; ontime++)
repeatbyte[ontime] = ipsbyte[ipson];
romstream.Seek(offset, SeekOrigin.Begin);
romresult = romstream.BeginWrite(repeatbyte, 0, totalrepeats, null, null);
romstream.EndWrite(romresult);
ipson++;
}
else
{
totalrepeats = ipsbyte[ipson] * 256 + ipsbyte[ipson + 1];
ipson++;
ipson++;
romstream.Seek(offset, SeekOrigin.Begin);
romresult = romstream.BeginWrite(ipsbyte, ipson, totalrepeats, null, null);
romstream.EndWrite(romresult);
ipson = ipson + totalrepeats;
}
if (ipsbyte[ipson] == 69 && ipsbyte[ipson + 1] == 79 && ipsbyte[ipson + 2] == 70)
keepgoing = false;
}
romstream.Close();
ipsstream.Close();
}
static void Main(string[] args)
{
byte[] buf = new byte[128];
FileStream file = new FileStream(@"D:\hello.py", FileMode.Open);
IAsyncResult ar = file.BeginRead(buf, 0, 128, null, null);
Thread.Sleep(1000); // do other things
int n = file.EndRead(ar);
file.Close();
string s = Encoding.UTF8.GetString(buf, 0, n);
Console.WriteLine("Readed: {0}, {1}", n, s);
}
static void DemoAsync()
{
using (var fs = new FileStream(@"C:\temp\foo.txt", FileMode.Open))
{
byte[] content = new byte[fs.Length];
IAsyncResult ar = fs.BeginRead(content, 0, (int)fs.Length, ReadCompletionCallback, null);
Console.WriteLine("控制流程回到主執行緒，執行其他工作...");
Thread.Sleep(1500); // 模擬執行其他工作需要花費的時間。
// 等到需要取得結果時，呼叫 EndRead 方法（會 block 當前執行緒）
int bytesRead = fs.EndRead(ar);
Console.WriteLine("一共讀取了 {0} bytes。", bytesRead);
}
}
static public int EndRead(IntPtr l)
{
try {
System.IO.FileStream self = (System.IO.FileStream)checkSelf(l);
System.IAsyncResult a1;
checkType(l, 2, out a1);
var ret = self.EndRead(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
//Метод считывания из одного файла
private static void AsyncReadOneFile()
{
FileStream fs = new FileStream(@"../../Program.cs", FileMode.Open, FileAccess.Read,
FileShare.Read, 1024, FileOptions.Asynchronous);
Byte[] data = new Byte[100];
// Начало асинхронной операции чтения из файла FileStream.
IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
// Здесь выполняется другой код...
// Приостановка этого потока до завершения асинхронной операции
// и получения ее результата.
Int32 bytesRead = fs.EndRead(ar);
// Других операций нет. Закрытие файла.
fs.Close();
// Теперь можно обратиться к байтовому массиву и вывести результат операции.
Console.WriteLine("Количество прочитаных байт = {0}", bytesRead);
Console.WriteLine(Encoding.UTF8.GetString(data).Remove(0, 1));
}
void OnReadDone(IAsyncResult ar)
{
int result = stream.EndRead(ar);
if (result > 0)
{
loop.NonBlockInvoke(delegate {
RaiseData(new ByteBuffer(readBuffer, 0, result));
ReadNextBuffer();
});
}
else
{
loop.NonBlockInvoke(delegate {
PauseReading();
RaiseEndOfStream();
});
}
}
public static void CopyFile(String sourcePath, String destinationPath, Action<String, String, Exception> completed)
{
Stream source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read);
Stream destination = new FileStream(destinationPath, FileMode.Create, FileAccess.Write);
byte[] buffer = new byte[0x1000];
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(null);
Action<Exception> cbCompleted = e =>
{
if (completed != null) asyncOp.Post(delegate
{
source.Close();
destination.Close();
completed(sourcePath, destinationPath, e);
}, null);
};
AsyncCallback rc = null;
rc = readResult =>
{
try
{
int read = source.EndRead(readResult);
if (read > 0)
{
destination.BeginWrite(buffer, 0, read, writeResult =>
{
try
{
destination.EndWrite(writeResult);
source.BeginRead(
buffer, 0, buffer.Length, rc, null);
}
catch (Exception exc) { cbCompleted(exc); }
}, null);
}
else cbCompleted(null);
}
catch (Exception exc) { cbCompleted(exc); }
};
source.BeginRead(buffer, 0, buffer.Length, rc, null);
}
void OnReadDone(IAsyncResult ar)
{
Enqueue(delegate {
if (stream != null)
{
int result = stream.EndRead(ar);
if (result > 0)
{
RaiseData(new ByteBuffer(readBuffer, 0, result));
ReadNextBuffer();
}
else
{
PauseReading();
RaiseEndOfStream();
}
}
});
}
/// <summary>
/// 异步创建文件
/// </summary>
public void CreateAsync(byte[] data, Action callback)
{
if (Exists)
{
throw new System.IO.IOException("file is exists");
}
data = Encrypted(data);
System.IO.FileStream fs = System.IO.File.Create(FullName);
//todo:需要测试
fs.BeginWrite(data, 0, data.Length, (result) => {
fs.EndRead(result);
fs.Close();
fs.Dispose();
if (callback != null)
{
callback.Invoke();
}
}, null);
}
void OnReadDone(IAsyncResult ar)
{
Context.Enqueue(delegate {
if (stream != null)
{
ResetReadTimeout();
int result = stream.EndRead(ar);
if (result > 0)
{
byte [] newBuffer = new byte [result];
Buffer.BlockCopy(buffer, 0, newBuffer, 0, result);
RaiseData(new ByteBuffer(newBuffer));
DispatchRead();
}
else
{
PauseReading();
RaiseEndOfStream();
}
}
});
}
// len, buf, err
public static void read(FileStream fd, byte[] buffer, long offset, long length, Action<int, byte[], Exception> callback)
{
try
{
fd.BeginRead(buffer, (int)offset, (int)length, ar =>
{
try
{
int len = fd.EndRead(ar);
Boundary.Instance.ExecuteOnTargetLoop( () => callback( len, buffer, null ));
} catch (Exception e){
Boundary.Instance.ExecuteOnTargetLoop( () => callback( 0, buffer, null ));
}
}, null);
}
catch (Exception e)
{
callback(0, buffer, e);
}
}
private void DoSequentialRead(
BlobTransferContext transferContext,
FileStream stream,
byte[] streamBuffer = null,
KeyValuePair<long, int>? inputStartAndLength = null)
{
if (transferContext.CancellationToken.IsCancellationRequested)
{
return;
}
if (streamBuffer == null)
{
streamBuffer = transferContext.MemoryManager.RequireBuffer();
}
if (streamBuffer == null)
{
return;
}
KeyValuePair<long, int> startAndLength;
if (inputStartAndLength == null)
{
if (!transferContext.BlocksToTransfer.TryDequeue(out startAndLength))
{
transferContext.MemoryManager.ReleaseBuffer(streamBuffer);
return;
}
}
else
{
startAndLength = inputStartAndLength.Value;
}
// Catch any exceptions and cleanup the buffer. Otherwise uncleaned buffers will result in hang for future
// uploads as memorymanager is being shared.
// Also mark the transfer as complete and add exceptions to the transfercontext exception list.
try
{
if (!transferContext.PartialFileIOState.ContainsKey(startAndLength.Key))
{
transferContext.PartialFileIOState[startAndLength.Key] = 0;
}
transferContext.IsReadingOrWriting = true;
long beginFilePosition = startAndLength.Key;
long nextBeginFilePosition = startAndLength.Key + transferContext.BlockSize;
nextBeginFilePosition =
nextBeginFilePosition > transferContext.Length
? transferContext.Length
: nextBeginFilePosition;
beginFilePosition = beginFilePosition + transferContext.PartialFileIOState[startAndLength.Key];
int bytesToRead = (int)(nextBeginFilePosition - beginFilePosition);
stream.BeginRead(
streamBuffer,
transferContext.PartialFileIOState[startAndLength.Key],
bytesToRead,
result3 =>
{
int bytesRead;
SuccessfulOrRetryableResult wasReadSuccessful =
IsActionSuccessfulOrRetryable(transferContext, () => stream.EndRead(result3), out bytesRead);
if (!wasReadSuccessful.IsSuccessful)
{
transferContext.IsReadingOrWriting = false;
transferContext.MemoryManager.ReleaseBuffer(streamBuffer);
}
else if (bytesRead != bytesToRead)
{
transferContext.PartialFileIOState[startAndLength.Key] += bytesRead;
DoSequentialRead(transferContext, stream, streamBuffer, startAndLength);
}
else
{
transferContext.IsReadingOrWriting = false;
ApplyEncryptionTransform(
transferContext.FileEncryption,
Path.GetFileName(transferContext.LocalFilePath),
beginFilePosition,
streamBuffer,
bytesToRead);
transferContext.BlocksForFileIO[(int)(startAndLength.Key / transferContext.BlockSize)] = streamBuffer;
}
},
null);
}
catch (Exception ex)
{
transferContext.IsComplete = true;
transferContext.MemoryManager.ReleaseBuffer(streamBuffer);
transferContext.Exceptions.Add(ex);
}
}
public void ProcessItems(string src, string dst)
{
int size = 2048 * 1024 * 2; //buffer size
int current_read_buffer = 0; //pointer to current read buffer
int last_bytes_read = 0; //number of bytes last read
if (!Directory.Exists(System.IO.Path.GetDirectoryName(dst)))
{
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(dst));
}
byte[][] buffer = new byte[2][];
buffer[0] = new byte[size];
buffer[1] = new byte[size];
//Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Background,
// (Action)(() =>
// {
// lblFileName.Text = System.IO.Path.GetFileNameWithoutExtension(src);
// }));
using (var r = new System.IO.FileStream(src, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite, size * 2, System.IO.FileOptions.SequentialScan | System.IO.FileOptions.Asynchronous))
{
//Microsoft.Win32.SafeHandles.SafeFileHandle hDst = CreateFile(dst, (uint)System.IO.FileAccess.Write, (uint)System.IO.FileShare.None, IntPtr.Zero, (uint)System.IO.FileMode.Create, FILE_FLAG_NO_BUFFERING | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED, IntPtr.Zero);
var z = new FileStream(dst, FileMode.Create, FileAccess.Write, FileShare.None, size * 2,
FileOptions.WriteThrough | FileFlagNoBuffering | FileOptions.SequentialScan);
z.Close();
z.Dispose();
using (var w = new System.IO.FileStream(dst, FileMode.Open, System.IO.FileAccess.Write, FileShare.ReadWrite, size * 2, true))
{
current_read_buffer = 0;
last_bytes_read = r.Read(buffer[current_read_buffer], 0, size); //synchronously read the first buffer
long l = r.Length;
//w.SetLength(l);
long i = 0;
while (i < l)
{
_block.WaitOne();
if (Cancel)
{
Environment.Exit(5);
break;
}
IAsyncResult aw = w.BeginWrite(buffer[current_read_buffer], 0, last_bytes_read, new AsyncCallback(CopyFileCallback), 0);
current_read_buffer = current_read_buffer == 0 ? 1 : 0;
Thread.CurrentThread.Join(2);
IAsyncResult ar = r.BeginRead(buffer[current_read_buffer], 0, last_bytes_read, new AsyncCallback(CopyFileCallback), 0);
i += last_bytes_read;
if (i > 0)
{
long oldvalbefore = 0;
oldbyteVlaues.TryGetValue(src, out oldvalbefore);
long oldval = 0;
if (oldbyteVlaues.TryGetValue(src, out oldval))
{
oldbyteVlaues[src] = i;
}
else
{
oldbyteVlaues.Add(src, i);
}
if (i - oldvalbefore > 0)
{
totaltransfered += (i - oldvalbefore);
}
byte[] data = System.Text.Encoding.Unicode.GetBytes(String.Format("{0}|{1}|{2}|{3}", i, l, totaltransfered, src));
WindowsAPI.SendStringMessage(MessageReceiverHandle, data, 0, data.Length);
if (i == l)
{
//procCompleted++;
if (this.OPType == OperationType.Move)
{
r.Close();
r.Dispose();
FileInfo fi = new FileInfo(src);
if (fi.IsReadOnly)
{
fi.IsReadOnly = false;
}
fi.Delete();
}
}
//if (totaltransfered == total)
//{
// if (this.OPType == OperationType.Move)
// {
// foreach (var dir in this.SourceItemsCollection.Select(c => ShellObject.FromParsingName(c.Item1)).ToArray().Where(c => c.IsFolder))
// {
// DeleteAllFilesFromDir(new DirectoryInfo(dir.ParsingName), false);
// DeleteFolderRecursive(new DirectoryInfo(dir.ParsingName), false);
// }
// GC.WaitForPendingFinalizers();
// GC.Collect();
// }
// Environment.Exit(5);
//}
}
else
{
//oldbyteVlaue = 0;
oldbyteVlaues[src] = 0;
if (l == 0)
{
Environment.Exit(5);
}
}
last_bytes_read = r.EndRead(ar);
Thread.Sleep(1);
w.EndWrite(aw);
}
}
}
}
public void ThreadMethod()
{
threadId = Thread.CurrentThread.ManagedThreadId;
try
{
// Signal the openning thread that we're up and running.
if (ThreadStarted != null)
ThreadStarted.Set();
using (FileStream fs = new FileStream(HidHandle, FileAccess.Read, InputReportByteLength, true))
{
byte[] buffer = new byte[InputReportByteLength];
while (true)
{
IAsyncResult res = fs.BeginRead(buffer, 0, InputReportByteLength, AsyncCallback, null);
// We need to wait for either IO to complete or the read to be signaled
WaitHandle[] IOCompleteOrThreadTerminating = { res.AsyncWaitHandle, ThreadTerminating };
// Wait for data or thread termination
if (1 == WaitHandle.WaitAny(IOCompleteOrThreadTerminating))
break;
// Call endRead to get the # of bytes actually read. This will throw an exception
// if the read was not successfull (i.e. the device was removed, etc).
int bytesRead = fs.EndRead(res);
Logger.Info(devicename, "read " + bytesRead.ToString(CultureInfo.InvariantCulture) + " bytes from device.");
// Make sure we got the correct # of bytes
if (bytesRead == InputReportByteLength)
{
// Get strong ref to callback delegate
DataReadCallback callback = wdcallback.Target as DataReadCallback;
if (callback == null)
break;
// report data to caller
callback(buffer);
callback = null;
}
else
{
// Unexpected data size - we'll thrown an exception for now.
// This may need to change for devices that report variable length data.
throw new PosControlException(rm.GetString("IDS_UNEXPECTED_NUMBER_BYTES"), ErrorCode.Failure);
}
}
}
}
catch (Exception e)
{
// We must eat this exception and marshal it back to the calling thread or else the
// CLR will terminate the process
Logger.Error(devicename, "Exception occurred in HID read thread.", e);
//if (e.Message.CompareTo("The device is not connected.\r\n") == 0)
if (e is IOException)
{
lock (syncRoot)
{
if (null != HidHandle)
{
if (!HidHandle.IsClosed)
HidHandle.Close();
HidHandle.Dispose();
HidHandle = null;
}
}
}
ThreadExceptionCallback excallback = wdexcallback.Target as ThreadExceptionCallback;
if (excallback != null)
excallback(e); // report exception to caller
excallback=null;
}
}
public override IEnumerator<CoroutineState> GetEnumerator()
{
FileStream fileReader = new FileStream(
_fileName,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
BUFFER_SIZE,
true);
FileStream fileWriter = new FileStream(
Path.Combine(_destinationFolder, Path.GetFileName(_fileName)),
FileMode.Create,
FileAccess.ReadWrite,
FileShare.Write,
BUFFER_SIZE,
true);
int bytesRead = 0;
do
{
//Read asynchronously
bool finishedRead = false;
IAsyncResult readResult = fileReader.BeginRead(_buffer, 0, BUFFER_SIZE,
(asyncResult) =>
{
bytesRead = fileReader.EndRead(asyncResult);
finishedRead = true;
},
null);
//Wait until the reading is complete
while (!finishedRead)
{
//Allow other coroutines to run
yield return CoroutineState.Running;
}
Console.WriteLine("Finished reading chunk for: " + _fileName);
//Write asynchronously
bool finishedWriting = false;
IAsyncResult writeResult = fileWriter.BeginWrite(_buffer, 0, bytesRead,
(asyncResult) =>
{
fileWriter.EndWrite(asyncResult);
finishedWriting = true;
},
null);
//Wait until write is finished
while (!finishedWriting)
{
//Let other coroutines run
yield return CoroutineState.Running;
}
Console.WriteLine("Finished writing chunk for: " + _fileName);
} while (bytesRead > 0);
fileReader.Close();
fileWriter.Close();
}
private void DoSequentialRead(
BlobTransferContext transferContext,
FileStream stream,
byte[] streamBuffer = null,
KeyValuePair<long, int>? inputStartAndLength = null)
{
if (transferContext.CancellationToken.IsCancellationRequested)
{
return;
}
if (streamBuffer == null)
{
streamBuffer = transferContext.MemoryManager.RequireBuffer();
}
if (streamBuffer == null)
{
return;
}
KeyValuePair<long, int> startAndLength;
if (inputStartAndLength == null)
{
if (!transferContext.BlocksToTransfer.TryDequeue(out startAndLength))
{
transferContext.MemoryManager.ReleaseBuffer(streamBuffer);
return;
}
}
else
{
startAndLength = inputStartAndLength.Value;
}
if (!transferContext.PartialFileIOState.ContainsKey(startAndLength.Key))
{
transferContext.PartialFileIOState[startAndLength.Key] = 0;
}
transferContext.IsReadingOrWriting = true;
long beginFilePosition = startAndLength.Key;
long nextBeginFilePosition = startAndLength.Key + transferContext.BlockSize;
nextBeginFilePosition =
nextBeginFilePosition > transferContext.Length
? transferContext.Length
: nextBeginFilePosition;
beginFilePosition = beginFilePosition + transferContext.PartialFileIOState[startAndLength.Key];
int bytesToRead = (int)(nextBeginFilePosition - beginFilePosition);
stream.BeginRead(
streamBuffer,
transferContext.PartialFileIOState[startAndLength.Key],
bytesToRead,
result3 =>
{
int bytesRead;
SuccessfulOrRetryableResult wasReadSuccessful =
IsActionSuccessfulOrRetryable(transferContext, () => stream.EndRead(result3), out bytesRead);
if (!wasReadSuccessful.IsSuccessful)
{
transferContext.IsReadingOrWriting = false;
transferContext.MemoryManager.ReleaseBuffer(streamBuffer);
}
else if (bytesRead != bytesToRead)
{
transferContext.PartialFileIOState[startAndLength.Key] += bytesRead;
DoSequentialRead(transferContext, stream, streamBuffer, startAndLength);
}
else
{
transferContext.IsReadingOrWriting = false;
ApplyEncryptionTransform(
transferContext.FileEncryption,
Path.GetFileName(transferContext.LocalFilePath),
beginFilePosition,
streamBuffer,
bytesToRead);
transferContext.BlocksForFileIO[(int) (startAndLength.Key/transferContext.BlockSize)] = streamBuffer;
}
},
null);
}
// metoda, ktora de-facto implementuje maszyne stanowa pozwalajaca na asynchroniczny
// odczyt pliku w obrebie jednej metody z zachowaniem wszystkich udogodnien jezyka!
static IEnumerator<int> ReadFileOperation(AsyncController ctrl)
{
// otworz plik - dyrektywa USING!!
using (var fs = new FileStream("Content.txt",
FileMode.Open,
FileAccess.Read,
FileShare.Read,
512,
// otworz plik w trybie asynchronicznym!
FileOptions.Asynchronous))
{
byte[] buffer = new byte[fs.Length];
// rozpocznij odczyt
// UWAGA - parametr callback odnosi sie do metody w kontrolerze maszyny stanowej
IAsyncResult ar = fs.BeginRead(
buffer,
0,
buffer.Length,
ctrl.AsyncOperationCompleted,
null);
Console.WriteLine("Starting async operation on thread: "
+ Thread.CurrentThread.ManagedThreadId);
// zwroc kontrole do kontrollera maszyny stanowej - wykonanie kodu jest przerwane!
yield return 1;
// ta linia kodu jest wykonywana po zakonczeniu odczytu - kontroller
// maszyny stanowej wznawia iteracje!
int bytesRead = fs.EndRead(ar);
// odczyt danych
using (var ms = new MemoryStream(buffer))
using (var str = new StreamReader(ms))
{
string fileName = null;
// odczyt danych z pilku - linia po linii
while (!string.IsNullOrEmpty(fileName = str.ReadLine()))
{
// dla każdej linii - sprobuj otworzy nowy plik
using (var contentFs = new FileStream(
fileName,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
512,
// otworz plik w trybie asynchronicznym!
FileOptions.Asynchronous))
{
buffer = new byte[contentFs.Length];
// rozpocznij odczyt z pliku
IAsyncResult contentAr = contentFs.BeginRead(
buffer,
0,
buffer.Length,
ctrl.AsyncOperationCompleted,
null);
// poczekaj az dane zostana odczytane
yield return 1;
contentFs.EndRead(contentAr);
// i wyswietl je na konsole
using (var contentMs = new MemoryStream(buffer))
using (var contentStr = new StreamReader(contentMs))
{
Console.Write(contentStr.ReadToEnd());
}
}
}
Console.WriteLine("Read Completed on thread " +
Thread.CurrentThread.ManagedThreadId);
}
// zakonczenie przetwarzania - nie ma wiecej operacji do wykonania!
}
}
// cannot return String from this method
private void RestoreInput()
{
var stream = new FileStream(
"savedInput.txt",
FileMode.OpenOrCreate,
FileAccess.Read,
FileShare.Read,
bufferSize: 8192,
useAsync: true);
var buffer = new byte[stream.Length];
var context = SynchronizationContext.Current;
stream.BeginRead(buffer, 0, buffer.Length, asyncResult =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
context.Post(_ =>
{
try
{
stream.EndRead(asyncResult);
stream.Dispose();
Input = Encoding.ASCII.GetString(buffer);
}
catch
{
Input = "Error!!!";
}
finally
{
DisplayLoadCompletedNotification();
}
}, null);
},
null);
}
/// <summary>
/// Copies the specified source file to the specified destination file, overwriting if it exists.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
public static void Copy(string source, string destination)
{
var bufferLength = 4 * 1024 * 32;
var readBuffer = new Byte[bufferLength];
var writeBuffer = new Byte[bufferLength];
var readSize = -1;
IAsyncResult writeResult;
IAsyncResult readResult;
using (var sourceStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.None, 8, FileOptions.Asynchronous | FileOptions.SequentialScan))
using (var destinationStream = new FileStream(destination, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 8, FileOptions.Asynchronous | FileOptions.SequentialScan))
{
destinationStream.SetLength(sourceStream.Length);
readSize = sourceStream.Read(readBuffer, 0, readBuffer.Length);
readBuffer = Interlocked.Exchange(ref writeBuffer, readBuffer);
while (readSize > 0)
{
writeResult = destinationStream.BeginWrite(writeBuffer, 0, readSize, null, null);
readResult = sourceStream.BeginRead(readBuffer, 0, readBuffer.Length, null, null);
destinationStream.EndWrite(writeResult);
readSize = sourceStream.EndRead(readResult);
readBuffer = Interlocked.Exchange(ref writeBuffer, readBuffer);
}
sourceStream.Close();
destinationStream.Close();
}
}
public override int EndRead(IAsyncResult asyncResult)
{
return(tempStream.EndRead(asyncResult));
}
//使用FileStream对象的BeginRead()方法
void AsyncRead()
{
FileStream fs = new FileStream(Server.MapPath("/UTF8Text.txt"), FileMode.Open, FileAccess.Read, FileShare.None, 4096, FileOptions.Asynchronous);
fs.Seek(0, SeekOrigin.Begin);
byte[] buffer = new byte[100];
//开始异步读操作
IAsyncResult ar = fs.BeginRead(buffer, 0, buffer.Length, null, null);
while (!ar.AsyncWaitHandle.WaitOne(10, false))//直到异步读文件操作完成才退出轮询
{
}
int bytesRead = fs.EndRead(ar);//结束异步读操作
fs.Close();
string str = Encoding.Default.GetString(buffer, 0, buffer.Length);
Response.Write(str);
}
public void BeginRead_Disposed ()
{
string path = TempFolder + Path.DirectorySeparatorChar + "temp";
DeleteFile (path);
FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
stream.Close ();
stream.EndRead (stream.BeginRead (new byte[8], 0, 8, null, null));
}
internal UInt64 ExtendFile(UInt64 fp, string filename)
{
int size = 65536 * 4;
byte[] readBuf = new byte[size];
byte[] fpBuf = new byte[size];
ulong fileFP = fp;
using (Stream ifs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, size, FileOptions.Asynchronous | FileOptions.SequentialScan))
{
IAsyncResult readResult = ifs.BeginRead(readBuf, 0, readBuf.Length, null, null);
while (true)
{
int bytesRead = ifs.EndRead(readResult);
if (bytesRead == 0) break;
byte[] tmpBuf = fpBuf;
fpBuf = readBuf;
readBuf = tmpBuf;
readResult = ifs.BeginRead(readBuf, 0, readBuf.Length, null, null);
fileFP = this.Extend(fileFP, fpBuf, 0, bytesRead);
}
}
return fileFP;
}
private static void SampleAsyncMethods()
{
IAsyncResult asyncResult;
/***** SQL Connection *****/
// NOTE: "Async=true" setting required for asynchronous operations.
using (SqlConnection connection = new SqlConnection(@"Async=true;Server=SERVER;Database=DATABASE;Integrated Security=true"))
{
connection.Open();
using (SqlCommand cmd = new SqlCommand("SELECT UserId, Name, LastLogIn FROM Users WHERE Email = '*****@*****.**'", connection))
{
asyncResult = cmd.BeginExecuteReader();
// ... query executes asynchronously in background ...
using (IDataReader reader = cmd.EndExecuteReader(asyncResult))
{
// WARNING: The DbAsyncResult object returned by BeginExecuteReader always creates a ManualResetEvent, but
// never closes it; after calling EndExecuteReader, the AsyncWaitHandle property is still valid, so we close it explicitly.
asyncResult.AsyncWaitHandle.Close();
while (reader.Read())
{
// do stuff
}
}
}
using (SqlCommand cmd = new SqlCommand("UPDATE Users SET LastLogIn = GETUTCDATE() WHERE UserId = 1", connection))
{
asyncResult = cmd.BeginExecuteNonQuery();
// ... query executes asynchronously in background ...
int rowsAffected = cmd.EndExecuteNonQuery(asyncResult);
// WARNING: The DbAsyncResult object returned by BeginExecuteNonQuery always creates a ManualResetEvent, but
// never closes it; after calling EndExecuteReader, the AsyncWaitHandle property is still valid, so we close it explicitly.
asyncResult.AsyncWaitHandle.Close();
}
}
/***** File Operations *****/
// NOTE: FileOptions.Asynchronous flag required for asynchronous operations.
using (Stream stream = new FileStream(@"C:\Temp\test.dat", FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096,
FileOptions.Asynchronous))
{
byte[] buffer = new byte[65536];
asyncResult = stream.BeginRead(buffer, 0, buffer.Length, null, null);
// ... disk read executes asynchronously in background ...
int bytesRead = stream.EndRead(asyncResult);
}
/***** HTTP Operation *****/
// WARNING: DNS operations are synchronous, and will block!
WebRequest request = WebRequest.Create(new Uri(@"http://www.example.com/sample/page"));
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
asyncResult = request.BeginGetRequestStream(null, null);
// ... connection to server opened in background ...
using (Stream stream = request.EndGetRequestStream(asyncResult))
{
byte[] bytes = Encoding.UTF8.GetBytes("Sample request");
asyncResult = stream.BeginWrite(bytes, 0, bytes.Length, null, null);
stream.EndWrite(asyncResult);
}
// WARNING: WebRequest will swallow any exceptions thrown from the AsyncCallback passed to BeginGetResponse.
asyncResult = request.BeginGetResponse(null, null);
// ... web request executes in background ...
using (WebResponse response = request.EndGetResponse(asyncResult))
using (Stream stream = response.GetResponseStream())
{
// read response from server
// WARNING: This code should also use asynchronous operations (BeginRead, EndRead); "Using synchronous calls
// in asynchronous callback methods can result in severe performance penalties." (MSDN)
}
/***** DNS hostname resolution *****/
// WARNING: Doesn't truly use async I/O, but simply queues the request to a ThreadPool thread.
asyncResult = Dns.BeginGetHostEntry("www.example.com", null, null);
// ... DNS lookup executes in background
IPHostEntry entry = Dns.EndGetHostEntry(asyncResult);
/***** Other: Sockets, Serial Ports, SslStream *****/
}
public static void LoadFile(string path, Action<string, Stream> onSuccessfulLoad, TextWriter errorOut)
{
const string ioExceptionPreamble = "Could not read program file due to an IO Exception.";
FileStream fileStream = null;
try
{
fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, fileBufferSize, true);
}
catch (FileNotFoundException fileNotFoundException)
{
errorOut.WriteLine("Could not read program file." + fileNotFoundException.Message);
return;
}
catch (IOException ioException)
{
errorOut.Write(ioExceptionPreamble + ioException.Message);
return;
}
LoadState loadState = new LoadState(fileBufferSize);
int bytesRead = -1;
Func<bool> iterate = null;
AsyncCallback onEndRead = null;
Action onLoadComplete = null;
iterate = () =>
{
while (bytesRead != 0)
{
IAsyncResult result = fileStream.BeginRead(loadState.ReadBuffer, 0, fileBufferSize, onEndRead, null);
if (!result.CompletedSynchronously)
{
return false;
}
bytesRead = fileStream.EndRead(result);
loadState.FlushReadBuffer(bytesRead);
}
return true;
};
onEndRead = (ar) =>
{
if (!ar.CompletedSynchronously)
{
try
{
bytesRead = fileStream.EndRead(ar);
loadState.FlushReadBuffer(bytesRead);
if (iterate())
{
onLoadComplete();
}
}
catch (IOException ioException)
{
errorOut.Write(ioExceptionPreamble + ioException.Message);
fileStream.Close();
}
catch
{
fileStream.Close();
throw;
}
}
};
onLoadComplete = () =>
{
fileStream.Close();
loadState.BufferedFile.Seek(0, SeekOrigin.Begin);
onSuccessfulLoad(path, loadState.BufferedFile);
};
try
{
if (iterate())
{
onLoadComplete();
}
}
catch (IOException ioException)
{
errorOut.Write(ioExceptionPreamble + ioException.Message);
fileStream.Close();
}
catch
{
fileStream.Close();
throw;
}
}