/// <summary>
/// Reads the response from the socket asynchronously.
/// </summary>
/// <param name="socket">The socket to read from.</param>
/// <param name="next">The delegate which will continue processing the response. This is only called if the read completes asynchronoulsy.</param>
/// <param name="ioPending">Set to true if the read is still pending when ReadASync returns. In this case 'next' will be called when the read is finished.</param>
/// <returns>
/// If the socket is already dead, ReadAsync returns false, next is not called, ioPending = false
/// If the read completes synchronously (e.g. data is received from the buffer), it returns true/false depending on the StatusCode, and ioPending is set to true, 'next' will not be called.
/// It returns true if it has to read from the socket, so the operation will complate asynchronously at a later time. ioPending will be true, and 'next' will be called to handle the data
/// </returns>
public bool ReadAsync(PooledSocket socket, Action <bool> next, out bool ioPending)
{
this.StatusCode = -1;
this._socket = socket;
this._nextAction = next;
var asyncEvent = new AsyncIOArgs
{
Count = BinaryResponse.HeaderLength,
Next = this.DoDecodeHeaderAsync
};
this._shouldCallNext = true;
if (socket.ReceiveAsync(asyncEvent))
{
ioPending = true;
return(true);
}
ioPending = false;
this._shouldCallNext = false;
return(asyncEvent.Fail
? false
: this.DoDecodeHeader(asyncEvent, out ioPending));
}
private void DoDecodeHeaderAsync(AsyncIOArgs asyncEvent)
{
this.shouldCallNext = true;
bool tmp;
this.DoDecodeHeader(asyncEvent, out tmp);
}
/// <summary>
/// Reads the response from the socket asynchronously.
/// </summary>
/// <param name="socket">The socket to read from.</param>
/// <param name="next">The delegate whihc will continue processing the response. This is only called if the read completes asynchronoulsy.</param>
/// <param name="ioPending">Set totrue if the read is still pending when ReadASync returns. In this case 'next' will be called when the read is finished.</param>
/// <returns>
/// If the socket is already dead, ReadAsync returns false, next is not called, ioPending = false
/// If the read completes synchronously (e.g. data is received from the buffer), it returns true/false depending on the StatusCode, and ioPending is set to true, 'next' will not be called.
/// It returns true if it has to read from the socket, so the operation will complate asynchronously at a later time. ioPending will be true, and 'next' will be called to handle the data
/// </returns>
public bool ReadAsync(PooledSocket socket, Action <bool> next, out bool ioPending)
{
this.StatusCode = -1;
this.currentSocket = socket;
this.next = next;
var asyncEvent = new AsyncIOArgs();
asyncEvent.Count = HeaderLength;
asyncEvent.Next = this.DoDecodeHeaderAsync;
this.shouldCallNext = true;
if (socket.ReceiveAsync(asyncEvent))
{
ioPending = true;
return(true);
}
ioPending = false;
this.shouldCallNext = false;
return(asyncEvent.Fail
? false
: this.DoDecodeHeader(asyncEvent, out ioPending));
}
public bool ReceiveAsync(AsyncIOArgs p)
{
CheckDisposed();
if (!IsAlive)
{
p.Fail = true;
p.Result = null;
return(false);
}
if (_helper2 == null)
{
_helper2 = new AsyncSocketHelper2(this);
}
return(_helper2.Read(p));
}
private bool DoDecodeHeader(AsyncIOArgs asyncEvent, out bool pendingIO)
{
pendingIO = false;
if (asyncEvent.Fail)
{
if (this.shouldCallNext)
{
this.next(false);
}
return(false);
}
this.DeserializeHeader(asyncEvent.Result, out this.dataLength, out this.extraLength);
var retval = this.StatusCode == 0;
if (this.dataLength == 0)
{
if (this.shouldCallNext)
{
this.next(retval);
}
}
else
{
asyncEvent.Count = this.dataLength;
asyncEvent.Next = this.DoDecodeBodyAsync;
if (this.currentSocket.ReceiveAsync(asyncEvent))
{
pendingIO = true;
}
else
{
if (asyncEvent.Fail)
{
return(false);
}
this.DoDecodeBody(asyncEvent);
}
}
return(retval);
}
void DoDecodeBody(AsyncIOArgs asyncEvent)
{
if (asyncEvent.Fail)
{
if (this._shouldCallNext)
{
this._nextAction(false);
}
return;
}
this.Extra = new ArraySegment <byte>(asyncEvent.Result, 0, this._extraLength);
this.Data = new ArraySegment <byte>(asyncEvent.Result, this._extraLength, this._dataLength - this._extraLength);
if (this._shouldCallNext)
{
this._nextAction(true);
}
}
/// <summary>
/// returns true if io is pending
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public bool Read(AsyncIOArgs p)
{
var count = p.Count;
if (count < 1)
{
throw new ArgumentOutOfRangeException("count", "count must be > 0");
}
#if DEBUG_IO
if (Interlocked.CompareExchange(ref this.doingIO, 1, 0) != 0)
{
throw new InvalidOperationException("Receive is already in progress");
}
#endif
this.expectedToRead = p.Count;
this.pendingArgs = p;
p.Fail = false;
p.Result = null;
if (this.asyncBuffer.Available >= count)
{
PublishResult(false);
return(false);
}
else
{
this.remainingRead = count - this.asyncBuffer.Available;
this.isAborted = 0;
this.BeginReceive();
return(true);
}
}
void DoDecodeBodyAsync(AsyncIOArgs asyncEvent)
{
this._shouldCallNext = true;
this.DoDecodeBody(asyncEvent);
}
void DoDecodeHeaderAsync(AsyncIOArgs asyncEvent)
{
this._shouldCallNext = true;
this.DoDecodeHeader(asyncEvent, out var tmp);
}
/// <summary>
/// Reads the response from the socket asynchronously.
/// </summary>
/// <param name="socket">The socket to read from.</param>
/// <param name="next">The delegate whihc will continue processing the response. This is only called if the read completes asynchronoulsy.</param>
/// <param name="ioPending">Set totrue if the read is still pending when ReadASync returns. In this case 'next' will be called when the read is finished.</param>
/// <returns>
/// If the socket is already dead, ReadAsync returns false, next is not called, ioPending = false
/// If the read completes synchronously (e.g. data is received from the buffer), it returns true/false depending on the StatusCode, and ioPending is set to true, 'next' will not be called.
/// It returns true if it has to read from the socket, so the operation will complate asynchronously at a later time. ioPending will be true, and 'next' will be called to handle the data
/// </returns>
public bool ReadAsync(PooledSocket socket, Action<bool> next, out bool ioPending)
{
this.StatusCode = -1;
this.currentSocket = socket;
this.next = next;
var asyncEvent = new AsyncIOArgs();
asyncEvent.Count = HeaderLength;
asyncEvent.Next = this.DoDecodeHeaderAsync;
this.shouldCallNext = true;
if (socket.ReceiveAsync(asyncEvent))
{
ioPending = true;
return true;
}
ioPending = false;
this.shouldCallNext = false;
return asyncEvent.Fail
? false
: this.DoDecodeHeader(asyncEvent, out ioPending);
}
private void DoDecodeHeaderAsync(AsyncIOArgs asyncEvent)
{
this.shouldCallNext = true;
bool tmp;
this.DoDecodeHeader(asyncEvent, out tmp);
}
private bool DoDecodeHeader(AsyncIOArgs asyncEvent, out bool pendingIO)
{
pendingIO = false;
if (asyncEvent.Fail)
{
if (this.shouldCallNext) this.next(false);
return false;
}
this.DeserializeHeader(asyncEvent.Result, out this.dataLength, out this.extraLength);
var retval = this.StatusCode == 0;
if (this.dataLength == 0)
{
if (this.shouldCallNext) this.next(retval);
}
else
{
asyncEvent.Count = this.dataLength;
asyncEvent.Next = this.DoDecodeBodyAsync;
if (this.currentSocket.ReceiveAsync(asyncEvent))
{
pendingIO = true;
}
else
{
if (asyncEvent.Fail) return false;
this.DoDecodeBody(asyncEvent);
}
}
return retval;
}
private void DoDecodeBodyAsync(AsyncIOArgs asyncEvent)
{
this.shouldCallNext = true;
DoDecodeBody(asyncEvent);
}
private void DoDecodeBody(AsyncIOArgs asyncEvent)
{
if (asyncEvent.Fail)
{
if (this.shouldCallNext) this.next(false);
return;
}
this.Extra = new ArraySegment<byte>(asyncEvent.Result, 0, this.extraLength);
this.Data = new ArraySegment<byte>(asyncEvent.Result, this.extraLength, this.dataLength - this.extraLength);
if (this.shouldCallNext) this.next(true);
}
private void DoDecodeBodyAsync(AsyncIOArgs asyncEvent)
{
this.shouldCallNext = true;
DoDecodeBody(asyncEvent);
}