/// <summary>
/// The MessageSentCallback.
/// </summary>
/// <param name="result">The result<see cref="IAsyncResult"/>.</param>
private void MessageSentCallback(IAsyncResult result)
{
ITransferContext context = (ITransferContext)result.AsyncState;
try
{
int sendcount = context.Listener.EndSend(result);
}
catch (SocketException) { }
catch (ObjectDisposedException) { }
if (context.SerialBlockId >= 0)
{
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Message, DirectionType.Send);
request.Resolve();
context.Listener.BeginSend(context.SerialBlock, 0, context.SerialBlock.Length, SocketFlags.None, MessageSentCallback, context);
}
else
{
if (!context.ReceiveMessage)
{
context.Close = true;
}
context.MessageSentNotice.Set();
MessageSent.Execute(this);
}
}
/// <summary>
/// The HeaderReceivedCallBack.
/// </summary>
/// <param name="result">The result<see cref="IAsyncResult"/>.</param>
private void HeaderReceivedCallBack(IAsyncResult result)
{
ITransferContext context = (ITransferContext)result.AsyncState;
int receive = context.Listener.EndReceive(result);
if (receive > 0)
{
context.IncomingHeader(receive);
}
if (context.BlockSize > 0)
{
int buffersize = (context.BlockSize < context.BufferSize) ? (int)context.BlockSize : context.BufferSize;
context.Listener.BeginReceive(context.HeaderBuffer, 0, buffersize, SocketFlags.None, HeaderReceivedCallBack, context);
}
else
{
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Header, DirectionType.Receive);
request.Resolve(context);
if (!context.ReceiveMessage &&
!context.SendMessage)
{
context.Close = true;
}
context.HeaderReceivedNotice.Set();
HeaderReceived.Execute(this);
}
}
/// <summary>
/// The Send.
/// </summary>
/// <param name="messagePart">The messagePart<see cref="MessagePart"/>.</param>
public void Send(MessagePart messagePart)
{
if (!IsConnected())
{
throw new Exception("Destination socket is not connected.");
}
AsyncCallback callback = HeaderSentCallback;
if (messagePart == MessagePart.Header)
{
callback = HeaderSentCallback;
TransferOperation request = new TransferOperation(Context.Transfer, MessagePart.Header, DirectionType.Send);
request.Resolve();
}
else if (Context.SendMessage)
{
callback = MessageSentCallback;
context.SerialBlockId = 0;
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Message, DirectionType.Send);
request.Resolve();
}
else
{
return;
}
context.Listener.BeginSend(context.SerialBlock, 0, context.SerialBlock.Length, SocketFlags.None, callback, context);
}
/// <summary>
/// The DealHeaderReceived.
/// </summary>
/// <param name="context">The context<see cref="ITransferContext"/>.</param>
public void DealHeaderReceived(ITransferContext context)
{
if (context.BlockSize > 0)
{
int buffersize = (context.BlockSize < context.BufferSize) ? (int)context.BlockSize : context.BufferSize;
context.Listener.BeginReceive(context.HeaderBuffer, 0, buffersize, SocketFlags.None, HeaderReceivedCallback, context);
}
else
{
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Header, DirectionType.Receive);
request.Resolve(context);
context.HeaderReceivedNotice.Set();
try
{
HeaderReceived.Execute(context);
}
catch (Exception ex)
{
Echo(ex.Message);
CloseClient(context.Id);
}
}
}
/// <summary>
/// The MessageReceivedCallback.
/// </summary>
/// <param name="result">The result<see cref="IAsyncResult"/>.</param>
public void MessageReceivedCallback(IAsyncResult result)
{
ITransferContext context = (ITransferContext)result.AsyncState;
MarkupType noiseKind = MarkupType.None;
int receive = context.Listener.EndReceive(result);
if (receive > 0)
{
noiseKind = context.IncomingMessage(receive);
}
if (context.BlockSize > 0)
{
int buffersize = (context.BlockSize < context.BufferSize) ? (int)context.BlockSize : context.BufferSize;
context.Listener.BeginReceive(context.MessageBuffer, 0, buffersize, SocketFlags.None, MessageReceivedCallback, context);
}
else
{
object readPosition = context.DeserialBlockId;
if (noiseKind == MarkupType.Block || (noiseKind == MarkupType.End && (int)readPosition < (context.Transfer.HeaderReceived.Context.ObjectsCount - 1)))
{
context.Listener.BeginReceive(context.MessageBuffer, 0, context.BufferSize, SocketFlags.None, MessageReceivedCallback, context);
}
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Message, DirectionType.Receive);
request.Resolve(context);
if (context.ObjectsLeft <= 0 && !context.BatchesReceivedNotice.SafeWaitHandle.IsClosed)
{
context.BatchesReceivedNotice.Set();
}
if (noiseKind == MarkupType.End && (int)readPosition >= (context.Transfer.HeaderReceived.Context.ObjectsCount - 1))
{
context.BatchesReceivedNotice.WaitOne();
context.MessageReceivedNotice.Set();
try
{
MessageReceived.Execute(context);
}
catch (Exception ex)
{
Echo(ex.Message);
CloseClient(context.Id);
}
}
}
}
/// <summary>
/// The MessageSentCallback.
/// </summary>
/// <param name="result">The result<see cref="IAsyncResult"/>.</param>
public void MessageSentCallback(IAsyncResult result)
{
ITransferContext context = (ITransferContext)result.AsyncState;
try
{
int sendcount = context.Listener.EndSend(result);
}
catch (SocketException) { }
catch (ObjectDisposedException) { }
if (context.SerialBlockId >= 0 || context.ObjectPosition < (context.Transfer.MyHeader.Context.ObjectsCount - 1))
{
TransferOperation request = new TransferOperation(context.Transfer, MessagePart.Message, DirectionType.Send);
request.Resolve();
context.Listener.BeginSend(context.SerialBlock, 0, context.SerialBlock.Length, SocketFlags.None, MessageSentCallback, context);
}
else
{
if (context.ReceiveMessage)
{
context.MessageReceivedNotice.WaitOne();
}
context.Close = true;
context.MessageSentNotice.Set();
try
{
MessageSent.Execute(context);
}
catch (Exception ex)
{
Echo(ex.Message);
CloseClient(context.Id);
}
}
}
