public Task WriteResponseMessageAsync([NotNull] IClientConnectionInfo connectionInfo, TcpMessage responseMessage)
{
if (connectionInfo == null)
{
throw new ArgumentNullException("connectionInfo");
}
if (responseMessage == null)
{
throw new ArgumentNullException("responseMessage");
}
TaskCompletionSource <int> completionSource = new TaskCompletionSource <int>();
Task headerTask = WriteHeaderAsync(connectionInfo, responseMessage.Header);
headerTask.ContinueWith(task =>
{
SendUserToken userToken = new SendUserToken(SendState.MessageSending, completionSource, this, false);
this._sender.SendAsync(connectionInfo.Socket, responseMessage.BodyBuffers, responseMessage.Header.Size,
userToken, SendCallbackHandler);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
headerTask.ContinueWith(task =>
{
if (task.IsFaulted)
{
completionSource.SetException(task.Exception);
}
else
{
completionSource.SetCanceled();
}
}, TaskContinuationOptions.NotOnRanToCompletion);
return(completionSource.Task);
}
private void startSend(SocketAsyncEventArgs sendArgs, string strData)
{
DataPacket dp = new DataPacket();
dp.Data = strData;
SendUserToken token = (SendUserToken)sendArgs.UserToken;
token.DataPacket = dp;
sendDataPacket(sendArgs);
}
private void SendCallbackHandler(SendUserToken outerToken, SocketError socketError,
IList <ArraySegment <byte> > buffer)
{
// releasing send buffers
if (outerToken.NeedToReleaseBuffer)
{
switch (outerToken.State)
{
case SendState.HeaderSending:
ReleaseBuffer(this._headerBufferManager, buffer);
break;
case SendState.MessageSending:
ReleaseBuffer(this._bodyBufferManager, buffer);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (socketError != SocketError.Success)
{
outerToken.SendTaskCompletionSource.SetException(new SocketException((int)socketError));
outerToken.Parent._listener.AcceptAsync(null);
return;
}
switch (outerToken.State)
{
case SendState.HeaderSending:
outerToken.State = SendState.HeaderSent;
outerToken.SendTaskCompletionSource.SetResult(0);
break;
case SendState.MessageSending:
outerToken.State = SendState.MessageSent;
outerToken.SendTaskCompletionSource.SetResult(0);
break;
default:
throw new ArgumentOutOfRangeException();
}
outerToken.Parent._listener.AcceptAsync(null);
}
private Task WriteHeaderAsync([NotNull] IClientConnectionInfo connectionInfo, [NotNull] TcpMessageHeader header)
{
if (connectionInfo == null)
{
throw new ArgumentNullException("connectionInfo");
}
if (header == null)
{
throw new ArgumentNullException("header");
}
TaskCompletionSource <int> completionSource = new TaskCompletionSource <int>();
IList <ArraySegment <byte> > headerBuffer = this._headerBufferManager.CheckOut(TcpMessageHeader.HeaderSize);
Debug.Assert(headerBuffer.Count == 1);
// TODO Write header to IList<ArraySegment<byte>>
header.Write(headerBuffer[0].Array, headerBuffer[0].Offset);
SendUserToken userToken = new SendUserToken(SendState.HeaderSending, completionSource, this, true);
this._sender.SendAsync(connectionInfo.Socket, headerBuffer, TcpMessageHeader.HeaderSize, userToken, SendCallbackHandler);
return(userToken.SendTaskCompletionSource.Task);
}
private void startSend(IDataPacket dpForSend)
{
Task.Factory.StartNew(() =>
{
lock (((ICollection)_clientCollection).SyncRoot)
{
List <Socket> aSocketsToDelete = new List <Socket>();
foreach (Socket client in _clientCollection)
{
if (client.Connected)
{
SocketAsyncEventArgs sendArgs;
if (!_sendArgsStack.TryPop(out sendArgs))
{
sendArgs = createSendAsyncEventArgs();
}
Debug.Assert(sendArgs.UserToken.GetType() == typeof(SendUserToken));
sendArgs.AcceptSocket = client;
SendUserToken token = (SendUserToken)sendArgs.UserToken;
token.DataPacket = dpForSend;
sendDataPacket(sendArgs);
}
else
{
aSocketsToDelete.Add(client);
}
}
for (int i = 0; i < aSocketsToDelete.Count; i++)
{
Socket socket = aSocketsToDelete[i];
_clientCollection.Remove(socket);
}
}
});
}
