public IAsyncResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, AsyncCallback callback, object state)
{
IAsyncResult result2;
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
try
{
lock (this.ThisLock)
{
this.SetImmediate(immediate);
this.SetWriteTimeout(timeout, false);
this.asyncWritePending = true;
}
result2 = this.socket.BeginSend(buffer, offset, size, SocketFlags.None, callback, state);
}
catch (SocketException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelper(this.ConvertSendException(exception, TimeSpan.MaxValue), this.ExceptionEventType);
}
catch (ObjectDisposedException exception2)
{
Exception objA = this.ConvertObjectDisposedException(exception2, TransferOperation.Write);
if (object.ReferenceEquals(objA, exception2))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelper(objA, this.ExceptionEventType);
}
return(result2);
}
public void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
TimeoutHelper helper = new TimeoutHelper(timeout);
try
{
this.SetImmediate(immediate);
int num = size;
while (num > 0)
{
this.SetWriteTimeout(helper.RemainingTime(), true);
size = Math.Min(num, 0x10000);
this.socket.Send(buffer, offset, size, SocketFlags.None);
num -= size;
offset += size;
timeout = helper.RemainingTime();
}
}
catch (SocketException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelper(this.ConvertSendException(exception, helper.RemainingTime()), this.ExceptionEventType);
}
catch (ObjectDisposedException exception2)
{
Exception objA = this.ConvertObjectDisposedException(exception2, TransferOperation.Write);
if (object.ReferenceEquals(objA, exception2))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelper(objA, this.ExceptionEventType);
}
}
public AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout, Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
_readCallback = callback;
try
{
SetReadTimeout(timeout);
Task <int> localTask = _stream.ReadAsync(AsyncReadBuffer, offset, size);
//IAsyncResult localResult = stream.BeginRead(AsyncReadBuffer, offset, size, onRead, state);
if (!localTask.IsCompleted)
{
localTask.ContinueWith(_onRead, state);
return(AsyncCompletionResult.Queued);
}
_bytesRead = localTask.GetAwaiter().GetResult();
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
return(AsyncCompletionResult.Completed);
}
public virtual AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout,
Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
this.ThrowIfNotOpen();
return(this.BeginReadCore(offset, size, timeout, callback, state));
}
protected override AsyncCompletionResult BeginWriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
bool abortWrite = true;
try
{
lock (ThisLock)
{
Contract.Assert(!_asyncWritePending, "Called BeginWrite twice.");
this.ThrowIfClosed();
this.EnsureWriteEventArgs();
SetImmediate(immediate);
SetWriteTimeout(timeout, false);
this.SetUserToken(_asyncWriteEventArgs, this);
_asyncWritePending = true;
_asyncWriteCallback = callback;
_asyncWriteState = state;
}
_asyncWriteEventArgs.SetBuffer(buffer, offset, size);
if (_socket.SendAsync(_asyncWriteEventArgs))
{
abortWrite = false;
return(AsyncCompletionResult.Queued);
}
this.HandleSendAsyncCompleted();
abortWrite = false;
return(AsyncCompletionResult.Completed);
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, TimeSpan.MaxValue));
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (object.ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
finally
{
if (abortWrite)
{
this.AbortWrite();
}
}
}
protected override void WriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout)
{
// as per http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b201213
// we shouldn't write more than 64K synchronously to a socket
const int maxSocketWrite = 64 * 1024;
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
try
{
int bytesToWrite = size;
using (timeoutHelper.GetCancellationToken().Register(OnSendTimeout, this))
{
while (bytesToWrite > 0)
{
size = Math.Min(bytesToWrite, maxSocketWrite);
_outputStream.Write(buffer, offset, size);
if (immediate)
{
_outputStream.Flush();
}
bytesToWrite -= size;
offset += size;
}
}
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (object.ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
catch (Exception exception)
{
if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown)
{
SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, timeoutHelper.RemainingTime()));
}
throw;
}
}
public override int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
if (this.preReadCount > 0)
{
int count = Math.Min(size, this.preReadCount);
Buffer.BlockCopy(this.preReadData, this.preReadOffset, buffer, offset, count);
this.preReadOffset += count;
this.preReadCount -= count;
return(count);
}
return(base.Read(buffer, offset, size, timeout));
}
public int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
ThrowIfNotOpen();
int bytesRead = ReadCore(buffer, offset, size, timeout, false);
if (WcfEventSource.Instance.SocketReadStopIsEnabled())
{
TraceSocketReadStop(bytesRead, false);
}
return(bytesRead);
}
public virtual AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout,
Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
this.ThrowIfNotOpen();
var completionResult = this.BeginReadCore(offset, size, timeout, callback, state);
if (completionResult == AsyncCompletionResult.Completed && WcfEventSource.Instance.SocketReadStopIsEnabled())
{
TraceSocketReadStop(_asyncReadSize, true);
}
return(completionResult);
}
public override AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(this.AsyncReadBufferSize, offset, size);
if (this.preReadCount > 0)
{
int count = Math.Min(size, this.preReadCount);
Buffer.BlockCopy(this.preReadData, this.preReadOffset, this.AsyncReadBuffer, offset, count);
this.preReadOffset += count;
this.preReadCount -= count;
this.asyncBytesRead = count;
return(AsyncReadResult.Completed);
}
return(base.BeginRead(offset, size, timeout, callback, state));
}
public override int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
if (_preReadCount > 0)
{
int bytesToCopy = Math.Min(size, _preReadCount);
Buffer.BlockCopy(_preReadData, _preReadOffset, buffer, offset, bytesToCopy);
_preReadOffset += bytesToCopy;
_preReadCount -= bytesToCopy;
return(bytesToCopy);
}
return(base.Read(buffer, offset, size, timeout));
}
public override AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout, Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
if (_preReadCount > 0)
{
int bytesToCopy = Math.Min(size, _preReadCount);
Buffer.BlockCopy(_preReadData, _preReadOffset, AsyncReadBuffer, offset, bytesToCopy);
_preReadOffset += bytesToCopy;
_preReadCount -= bytesToCopy;
_asyncBytesRead = bytesToCopy;
return(AsyncCompletionResult.Completed);
}
return(base.BeginRead(offset, size, timeout, callback, state));
}
protected override void WriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout)
{
// as per http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b201213
// we shouldn't write more than 64K synchronously to a socket
const int maxSocketWrite = 64 * 1024;
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
try
{
SetImmediate(immediate);
int bytesToWrite = size;
while (bytesToWrite > 0)
{
SetWriteTimeout(timeoutHelper.RemainingTime(), true);
size = Math.Min(bytesToWrite, maxSocketWrite);
_socket.Send(buffer, offset, size, SocketFlags.None);
bytesToWrite -= size;
offset += size;
timeout = timeoutHelper.RemainingTime();
}
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, timeoutHelper.RemainingTime()));
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (object.ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
}
public AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(this.AsyncReadBufferSize, offset, size);
this.readCallback = callback;
try
{
this.SetReadTimeout(timeout);
IAsyncResult asyncResult = this.stream.BeginRead(this.AsyncReadBuffer, offset, size, this.onRead, state);
if (!asyncResult.CompletedSynchronously)
{
return(AsyncReadResult.Queued);
}
this.bytesRead = this.stream.EndRead(asyncResult);
}
catch (IOException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.ConvertIOException(exception));
}
return(AsyncReadResult.Completed);
}
public AsyncCompletionResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
readCallback = callback;
try
{
SetReadTimeout(timeout);
IAsyncResult localResult = stream.BeginRead(AsyncReadBuffer, offset, size, onRead, state);
if (!localResult.CompletedSynchronously)
{
return(AsyncCompletionResult.Queued);
}
bytesRead = stream.EndRead(localResult);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
return(AsyncCompletionResult.Completed);
}
protected override AsyncCompletionResult BeginWriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
Action <object> callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
bool abortWrite = true;
try
{
lock (ThisLock)
{
Contract.Assert(!_asyncWritePending, "Called BeginWrite twice.");
this.ThrowIfClosed();
SetWriteTimeout(timeout, false);
_asyncWritePending = true;
_asyncWriteCallback = callback;
_asyncWriteState = state;
}
Task writeTask = _outputStream.WriteAsync(buffer, offset, size, _sendCts.Token);
if (immediate)
{
writeTask = writeTask.ContinueWith(s_flushWriteImmedaite, this, CancellationToken.None).Unwrap();
}
if (!writeTask.IsCompleted)
{
writeTask.ContinueWith(s_onSendAsyncCompleted, this, CancellationToken.None);
abortWrite = false;
return(AsyncCompletionResult.Queued);
}
writeTask.GetAwaiter().GetResult();
abortWrite = false;
return(AsyncCompletionResult.Completed);
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (object.ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
catch (Exception exception)
{
if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown)
{
SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, TimeSpan.MaxValue));
}
throw;
}
finally
{
if (abortWrite)
{
this.AbortWrite();
}
}
}
public int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
this.ThrowIfNotOpen();
return(this.ReadCore(buffer, offset, size, timeout, false));
}