public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
SerialAsyncResult ar = new SerialAsyncResult(this);
ar.Init(state, callback, false);
Overlapped ov = new Overlapped(0, 0, ar.AsyncWaitHandle.Handle.ToInt32(), ar);
unsafe
{
fixed(byte *data = &buffer[0])
{
int write = 0;
NativeOverlapped *nov = ov.Pack(m_IOCompletionCallback);
WriteFile(m_hFile, data, count, &write, nov);
}
}
if (GetLastError() == ERROR_IO_PENDING)
{
return(ar);
}
else
{
throw new Exception("Unable to initialize write. Errorcode: " + GetLastError().ToString());
}
}
private unsafe void AsyncFSCallback(uint errorCode, uint numBytes, NativeOverlapped *pOverlapped)
{
SerialAsyncResult sar = (SerialAsyncResult)Overlapped.Unpack(pOverlapped).AsyncResult;
if (sar.m_bIsRead)
{
m_iReadCount = (int)numBytes;
}
else
{
m_iWriteCount = (int)numBytes;
}
((ManualResetEvent)sar.AsyncWaitHandle).Set();
if (errorCode == ERROR_OPERATION_ABORTED)
{
sar.m_bCompleted = false;
}
else
{
sar.m_bCompleted = true;
}
if (sar.Callback != null)
{
sar.Callback.Invoke(sar);
}
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
GCHandle gchBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
SerialAsyncResult sar = new SerialAsyncResult(this, state, callback, false, gchBuffer);
Overlapped ov = new Overlapped(0, 0, sar.AsyncWaitHandle.Handle.ToInt32(), sar);
unsafe
{
NativeOverlapped *nov = ov.Pack(m_IOCompletionCallback);
byte * data = (byte *)((int)gchBuffer.AddrOfPinnedObject() + offset);
uint written = 0;
if (WriteFile(m_hFile, data, (uint)count, out written, nov))
{
sar.m_bCompletedSynchronously = true;
return(sar);
}
else if (GetLastError() == ERROR_IO_PENDING)
{
return(sar);
}
else
{
throw new Exception("Não foi possível inicializar escrita. Código de erro: " + GetLastError().ToString());
}
}
}
private unsafe void AsyncFSCallback(uint errorCode, uint numBytes, NativeOverlapped *pOverlapped)
{
SerialAsyncResult sar = (SerialAsyncResult)Overlapped.Unpack(pOverlapped).AsyncResult;
sar.m_nErrorCode = errorCode;
sar.m_nReadWritten = (int)numBytes;
sar.m_bCompleted = true;
if (sar.Callback != null)
{
sar.Callback.Invoke(sar);
}
Overlapped.Free(pOverlapped);
}
public override void EndWrite(IAsyncResult asyncResult)
{
SerialAsyncResult sar = (SerialAsyncResult)asyncResult;
if (sar.m_bIsRead)
{
throw new Exception("Invalid parameter: IAsyncResult is from a read");
}
sar.AsyncWaitHandle.WaitOne();
if (!sar.m_bCompleted)
{
((ManualResetEvent)sar.AsyncWaitHandle).Reset();
sar.AsyncWaitHandle.WaitOne();
}
sar.Reset();
}
private int EndOperation(IAsyncResult asyncResult, bool isRead)
{
SerialAsyncResult sar = (SerialAsyncResult)asyncResult;
if (sar.m_bIsRead != isRead)
{
throw new IOException("Parâmetro inválido: IAsyncResult não é para " + (isRead ? "leitura" : "escrita"));
}
if (sar.EndOperationCalled)
{
throw new IOException("Fim" + (isRead ? "Leitura" : "Escrita") + " invocado duas vezes para a mesma operação.");
}
else
{
sar.m_bEndOperationCalled = true;
WaitHandle waitTemp = sar.AsyncWaitHandle;
if (eCallSetaWaitHandle != null)
{
eCallSetaWaitHandle(ref waitTemp);
}
}
while (!sar.m_bCompleted)
{
System.Console.WriteLine("Entrou no while que espera o Handle"); //Testando
try
{
sar.AsyncWaitHandle.WaitOne();
}
catch
{
break;
}
}
System.Console.WriteLine("Saiu do while que espera o Handle"); //Testando
sar.Dispose();
if (sar.m_nErrorCode != ERROR_SUCCESS && sar.m_nErrorCode != ERROR_OPERATION_ABORTED)
{
throw new IOException("Operação terminado com código de erro: " + sar.m_nErrorCode);
}
return(sar.m_nReadWritten);
}
public override int EndRead(IAsyncResult asyncResult)
{
SerialAsyncResult sar = (SerialAsyncResult)asyncResult;
if (!sar.m_bIsRead)
{
throw new Exception("Invalid parameter: IAsyncResult is not from a read");
}
sar.AsyncWaitHandle.WaitOne();
if (!sar.m_bCompleted)
{
((ManualResetEvent)sar.AsyncWaitHandle).Reset();
sar.AsyncWaitHandle.WaitOne();
}
sar.Reset();
return(m_iReadCount);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
SerialAsyncResult ar = new SerialAsyncResult(this);
ar.Init(state, callback, false);
Overlapped ov = new Overlapped(0, 0, ar.AsyncWaitHandle.Handle.ToInt32(), ar);
unsafe { fixed (byte* data = &buffer[0]) {
int write = 0;
NativeOverlapped* nov = ov.Pack(m_IOCompletionCallback);
WriteFile(m_hFile, data, count, &write, nov);
} }
if (GetLastError() == ERROR_IO_PENDING)
return ar;
else
throw new Exception("Unable to initialize write. Errorcode: " + GetLastError().ToString());
}
