internal Task <byte[]> SendAsync(ProtocolPacket packet, IPEndPoint remoteEndPoint = null,
int millisecondsTimeout = -1)
{
return(Task.Factory.StartNew(() =>
{
ResultWaiter awaiter = null;
byte[] buffer = packet.ToBuffer();
IPEndPoint remotePoint = remoteEndPoint ?? new IPEndPoint(new IPAddress(packet.Ip), packet.Port);
if (packet.ReportArrived || packet.HasResponse)
{
_syncHandles[packet.Counter] = awaiter = new ResultWaiter();
}
SendFunctionAsync(buffer, remotePoint).NoAwaiter();
if (packet.ReportArrived)
{
if (packet.PacketMode == PacketMode.Arrived)
{
return new byte[0];
}
int waitCount = 0;
while (!awaiter.WaitArrive(millisecondsTimeout))
{
if (waitCount++ >= 3)
{
throw new TimeoutException("Waiting for command delivery timeout");
}
SendFunctionAsync(buffer, remotePoint).NoAwaiter();
}
}
if (!packet.HasResponse)
{
_syncHandles.TryRemove(packet.Counter);
return new byte[0];
}
byte[] resultBuffer = awaiter?.WaitResponse(millisecondsTimeout);
_syncHandles.TryRemove(packet.Counter);
return resultBuffer;
}, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
}
/// <param name="protocol"></param>
private async Task InnerChannelReceived(ProtocolPacket protocol)
{
if (protocol.ReportArrived && protocol.PacketMode != PacketMode.Arrived)
{
ProtocolPacket p = protocol.CopyTo(new ProtocolPacket());
p.Data = new byte[0];
p.HasResponse = false;
p.PacketMode = PacketMode.Arrived;
p.UsingRemoteEndPoint = true;
SendAsync(p).NoAwaiter();
}
if (_syncHandles.TryGetValue(protocol.Counter, out ResultWaiter syncHandle))
{
syncHandle?.Set(protocol);
}
if (protocol.PacketMode != PacketMode.Request)
{
return;
}
Task CallBack(ProtocolPacket packet, int millisecondsTimeout = -1)
{
IPEndPoint remoteEndPoint = new IPEndPoint(new IPAddress(packet.Ip), packet.Port);
packet.Ip = ConnectOptions.LocalEndPoint.Address.GetAddressBytes();
packet.Port = ConnectOptions.LocalEndPoint.Port;
packet.UsingRemoteEndPoint = true;
packet.ReportArrived = _connectMode == ConnectMode.Udp;
SendAsync(packet, remoteEndPoint, millisecondsTimeout).NoAwaiter();
return(Task.Delay(0));
}
ProtocolPacket newPro = protocol.CopyTo(new ProtocolPacket());
newPro.HasResponse = false;
newPro.PacketMode = PacketMode.Response;
EasySession session = new EasySession(newPro, CallBack);
if (Received != null)
{
await Received(session, protocol.Data);
}
}
public bool Set(ProtocolPacket paBase)
{
switch (paBase.PacketMode)
{
case PacketMode.Arrived:
return(_arrivedReset = _arrivedResetEvent.Set());
case PacketMode.Response:
_buffer = paBase.Data;
return(_responseReset = _responseResetEvent.Set());
default:
return(false);
}
}
internal async void ReceivedHandler(byte[] receiveBytes, int offset, int length,
IPEndPoint endPoint = null)
{
ICollection <ProtocolPacket> buffers = ProtocolPacket.ParseBuffers(receiveBytes, offset, length);
foreach (ProtocolPacket buffer in buffers)
{
if (endPoint != null)
{
buffer.Ip = endPoint.Address.GetAddressBytes();
buffer.Port = endPoint.Port;
}
await InnerChannelReceived(buffer);
}
}
