public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Task task = this.WriteAsync(buffer, offset, count);
if (task.IsSuccess())
{
// write+flush completed synchronously (and successfully)
var result = new SynchronousAsyncResult <int>
{
AsyncState = state
};
callback?.Invoke(result);
return(result);
}
else
{
if (callback is object || state != task.AsyncState)
{
Debug.Assert(_writeCompletion is null);
_writeCallback = callback;
var tcs = _owner.CapturedContext.NewPromise(state);
_writeCompletion = tcs;
_ = task.ContinueWith(s_writeCompleteCallback, this, TaskContinuationOptions.ExecuteSynchronously);
return(tcs.Task);
}
else
{
return(task);
}
}
}
//| <include file='doc\Stream.uex' path='docs/doc[@for="Stream.EndWrite"]/*' />
public virtual void EndWrite(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
SynchronousAsyncResult ar = asyncResult as SynchronousAsyncResult;
if (ar == null || !ar.IsWrite)
{
__Error.WrongAsyncResult();
assume false; // never gets here
}
if (ar._EndXxxCalled)
{
__Error.EndWriteCalledTwice();
assume false; // never gets here
}
ar._EndXxxCalled = true;
if (ar._exception != null)
{
throw ar._exception;
}
}
//| <include file='doc\Stream.uex' path='docs/doc[@for="Stream.BeginRead"]/*' />
public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object _state)
{
if (!CanRead)
{
__Error.ReadNotSupported();
}
// To avoid a race with a stream's position pointer & generating race
// conditions with internal buffer indexes in our own streams that
// don't natively support async IO operations when there are multiple
// async requests outstanding, we will block the application's main
// thread and do the IO synchronously.
SynchronousAsyncResult asyncResult = new SynchronousAsyncResult(_state, false);
try {
int numRead = Read(buffer, offset, count);
asyncResult._numRead = numRead;
asyncResult._isCompleted = true;
asyncResult._waitHandle.Set();
}
catch (IOException e) {
asyncResult._exception = e;
}
if (callback != null)
{
callback(asyncResult);
}
return(asyncResult);
}
public override int EndRead(IAsyncResult asyncResult)
{
SynchronousAsyncResult <int> syncResult = this.syncReadResult;
if (ReferenceEquals(asyncResult, syncResult))
{
return(syncResult.Result);
}
Contract.Assert(!((Task <int>)asyncResult).IsCanceled);
try
{
return(((Task <int>)asyncResult).Result);
}
catch (AggregateException ex)
{
ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
throw; // unreachable
}
finally
{
this.readCompletionSource = null;
this.readCallback = null;
this.sslOwnedBuffer = default(ArraySegment <byte>);
}
}
internal IAsyncResult BlockingBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Contract.Ensures(Contract.Result <IAsyncResult>() != null);
// To avoid a race with a stream's position pointer & generating ----
// conditions with internal buffer indexes in our own streams that
// don't natively support async IO operations when there are multiple
// async requests outstanding, we will block the application's main
// thread and do the IO synchronously.
// This can't perform well - use a different approach.
SynchronousAsyncResult asyncResult;
try
{
Write(buffer, offset, count);
asyncResult = new SynchronousAsyncResult(state);
}
catch (IOException ex)
{
asyncResult = new SynchronousAsyncResult(ex, state, isWrite: true);
}
if (callback != null)
{
callback(asyncResult);
}
return(asyncResult);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Task task = this.WriteAsync(buffer, offset, count);
switch (task.Status)
{
case TaskStatus.RanToCompletion:
// write+flush completed synchronously (and successfully)
var result = new SynchronousAsyncResult <int>();
result.AsyncState = state;
callback?.Invoke(result);
return(result);
default:
if (callback != null || state != task.AsyncState)
{
Contract.Assert(this.writeCompletion == null);
this.writeCallback = callback;
var tcs = new TaskCompletionSource(state);
this.writeCompletion = tcs;
task.ContinueWith(WriteCompleteCallback, this, TaskContinuationOptions.ExecuteSynchronously);
return(tcs.Task);
}
else
{
return(task);
}
}
}
IAsyncResult PrepareSyncReadResult(int readBytes, object state)
{
// it is safe to reuse sync result object as it can't lead to leak (no way to attach to it via handle)
SynchronousAsyncResult <int> result = this.syncReadResult ?? (this.syncReadResult = new SynchronousAsyncResult <int>());
result.Result = readBytes;
result.AsyncState = state;
return(result);
}
IAsyncResult PrepareSyncReadResult(int readBytes, object state)
{
//Program.Trace.WriteLine($"[MediationStream] PrepareSyncReadResult - readBytes {readBytes}");
// it is safe to reuse sync result object as it can't lead to leak (no way to attach to it via handle)
SynchronousAsyncResult <int> result = this.syncReadResult;
result.Result = readBytes;
result.AsyncState = state;
return(result);
}
internal static void BlockingEndWrite(IAsyncResult asyncResult)
{
SynchronousAsyncResult result = asyncResult as SynchronousAsyncResult;
if ((result == null) || !result.IsWrite)
{
__Error.WrongAsyncResult();
}
if (result._EndXxxCalled)
{
__Error.EndWriteCalledTwice();
}
result._EndXxxCalled = true;
if (result._exception != null)
{
throw result._exception;
}
}
internal static void EndWrite(IAsyncResult asyncResult)
{
SynchronousAsyncResult ar = asyncResult as SynchronousAsyncResult;
if (ar == null || !ar._isWrite)
{
throw new ArgumentException("WrongAsyncResult");
}
if (ar._endXxxCalled)
{
throw new InvalidOperationException();
}
ar._endXxxCalled = true;
ar.ThrowIfError();
}
internal static void EndWrite(IAsyncResult asyncResult)
{
SynchronousAsyncResult ar = asyncResult as SynchronousAsyncResult;
if (ar == null || !ar._isWrite)
{
__Error.WrongAsyncResult();
}
if (ar._endXxxCalled)
{
__Error.EndWriteCalledTwice();
}
ar._endXxxCalled = true;
ar.ThrowIfError();
}
internal static Int32 EndRead(IAsyncResult asyncResult)
{
SynchronousAsyncResult ar = asyncResult as SynchronousAsyncResult;
if (ar == null || ar._isWrite)
{
throw new InvalidOperationException();
}
if (ar._endXxxCalled)
{
throw new InvalidOperationException();
}
ar._endXxxCalled = true;
ar.ThrowIfError();
return(ar._bytesRead);
}
internal static int BlockingEndRead(IAsyncResult asyncResult)
{
SynchronousAsyncResult result = asyncResult as SynchronousAsyncResult;
if ((result == null) || result.IsWrite)
{
__Error.WrongAsyncResult();
}
if (result._EndXxxCalled)
{
__Error.EndReadCalledTwice();
}
result._EndXxxCalled = true;
if (result._exception != null)
{
throw result._exception;
}
return(result._numRead);
}
internal static int EndRead(IAsyncResult asyncResult)
{
SynchronousAsyncResult ar = asyncResult as SynchronousAsyncResult;
if (ar == null || ar._isWrite)
{
__Error.WrongAsyncResult();
}
if (ar._endXxxCalled)
{
__Error.EndReadCalledTwice();
}
ar._endXxxCalled = true;
ar.ThrowIfError();
return(ar._bytesRead);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Task task = this.owner.capturedContext.WriteAndFlushAsync(Unpooled.WrappedBuffer(buffer, offset, count));
switch (task.Status)
{
case TaskStatus.RanToCompletion:
// write+flush completed synchronously (and successfully)
var result = new SynchronousAsyncResult <int>();
result.AsyncState = state;
callback(result);
return(result);
default:
this.writeCallback = callback;
var tcs = new TaskCompletionSource(state);
this.writeCompletion = tcs;
task.ContinueWith(WriteCompleteCallback, this, TaskContinuationOptions.ExecuteSynchronously);
return(tcs.Task);
}
}
public override int EndRead(IAsyncResult asyncResult)
{
SynchronousAsyncResult <int> syncResult = this.syncReadResult;
if (ReferenceEquals(asyncResult, syncResult))
{
return(syncResult.Result);
}
Debug.Assert(this.readCompletionSource == null || this.readCompletionSource.Task == asyncResult);
Contract.Assert(!((Task <int>)asyncResult).IsCanceled);
try
{
return(((Task <int>)asyncResult).Result);
}
catch (AggregateException ex)
{
ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
throw; // unreachable
}
}
internal IAsyncResult BlockingBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
SynchronousAsyncResult ar = new SynchronousAsyncResult(state, true);
try
{
this.Write(buffer, offset, count);
}
catch (IOException exception)
{
ar._exception = exception;
}
finally
{
ar._isCompleted = true;
ar._waitHandle.Set();
}
if (callback != null)
{
callback(ar);
}
return(ar);
}
/// <include file='doc\Stream.uex' path='docs/doc[@for="Stream.BeginRead"]/*' />
public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
{
if (!CanRead) __Error.ReadNotSupported();
// To avoid a race with a stream's position pointer & generating race
// conditions with internal buffer indexes in our own streams that
// don't natively support async IO operations when there are multiple
// async requests outstanding, we will block the application's main
// thread and do the IO synchronously.
SynchronousAsyncResult asyncResult = new SynchronousAsyncResult(state, false);
try {
int numRead = Read(buffer, offset, count);
asyncResult._numRead = numRead;
asyncResult._isCompleted = true;
asyncResult._waitHandle.Set();
}
catch (IOException e) {
asyncResult._exception = e;
}
if (callback != null)
callback(asyncResult);
return asyncResult;
}
internal static void BlockingEndWrite(IAsyncResult asyncResult)
{
SynchronousAsyncResult.EndWrite(asyncResult);
}
internal static int BlockingEndRead(IAsyncResult asyncResult)
{
return(SynchronousAsyncResult.EndRead(asyncResult));
}
internal IAsyncResult BlockingBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
{
// To avoid a race with a stream's position pointer & generating ----
// conditions with internal buffer indexes in our own streams that
// don't natively support async IO operations when there are multiple
// async requests outstanding, we will block the application's main
// thread and do the IO synchronously.
// This can't perform well - use a different approach.
SynchronousAsyncResult asyncResult;
try
{
Write(buffer, offset, count);
asyncResult = new SynchronousAsyncResult(state);
}
catch (IOException ex)
{
asyncResult = new SynchronousAsyncResult(ex, state, isWrite: true);
}
if (callback != null)
{
callback(asyncResult);
}
return asyncResult;
}
public MediationStream(TlsHandler owner)
{
this.syncReadResult = new SynchronousAsyncResult <int>();
this.owner = owner;
}
public MediationStream(CustomTlsHandler owner)
{
//Program.Trace.WriteLine($"[MediationStream] Ctor");
this.syncReadResult = new SynchronousAsyncResult <int>();
this.owner = owner;
}
internal static int BlockingEndRead(IAsyncResult asyncResult)
{
Contract.Ensures(Contract.Result <int>() >= 0);
return(SynchronousAsyncResult.EndRead(asyncResult));
}
internal IAsyncResult BlockingBeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
SynchronousAsyncResult ar = new SynchronousAsyncResult(state, false);
try
{
int num = this.Read(buffer, offset, count);
ar._numRead = num;
}
catch (IOException exception)
{
ar._exception = exception;
}
finally
{
ar._isCompleted = true;
ar._waitHandle.Set();
}
if (callback != null)
{
callback(ar);
}
return ar;
}
