public ReusableTask <int> ReceiveAsync(byte[] buffer, int offset, int count)
{
// If this has been disposed, then bail out
if (Socket == null)
{
ReceiveTcs.SetResult(0);
return(ReceiveTcs.Task);
}
var args = GetSocketAsyncEventArgs(buffer);
args.SetBuffer(offset, count);
args.UserToken = ReceiveTcs;
AsyncFlowControl?control = null;
if (!ExecutionContext.IsFlowSuppressed())
{
control = ExecutionContext.SuppressFlow();
}
try {
if (!Socket.ReceiveAsync(args))
{
ReceiveTcs.SetResult(args.BytesTransferred);
}
} finally {
if (control.HasValue)
{
control.Value.Undo();
}
}
return(ReceiveTcs.Task);
}
public ReusableTask <int> ReceiveAsync(ByteBuffer buffer, int offset, int count)
{
SocketAsyncEventArgs args = GetSocketAsyncEventArgs(buffer);
args.SetBuffer(offset, count);
args.UserToken = ReceiveTcs;
#if ALLOW_EXECUTION_CONTEXT_SUPPRESSION
AsyncFlowControl?control = null;
if (!ExecutionContext.IsFlowSuppressed())
{
control = ExecutionContext.SuppressFlow();
}
#endif
try {
if (!Socket.ReceiveAsync(args))
{
ReceiveTcs.SetResult(args.BytesTransferred);
}
} catch (ObjectDisposedException) {
ReceiveTcs.SetResult(0);
} finally {
#if ALLOW_EXECUTION_CONTEXT_SUPPRESSION
control?.Undo();
#endif
}
return(ReceiveTcs.Task);
}
public ReusableTask <int> ReceiveAsync(byte[] buffer, int offset, int count)
{
// If this has been disposed, then bail out
if (Socket == null)
{
ReceiveTcs.SetResult(0);
return(ReceiveTcs.Task);
}
SocketAsyncEventArgs args = GetSocketAsyncEventArgs(buffer);
args.SetBuffer(offset, count);
args.UserToken = ReceiveTcs;
#if ALLOW_EXECUTION_CONTEXT_SUPPRESSION
AsyncFlowControl?control = null;
if (!ExecutionContext.IsFlowSuppressed())
{
control = ExecutionContext.SuppressFlow();
}
#endif
try {
if (!Socket.ReceiveAsync(args))
{
ReceiveTcs.SetResult(args.BytesTransferred);
}
} finally {
#if ALLOW_EXECUTION_CONTEXT_SUPPRESSION
control?.Undo();
#endif
}
return(ReceiveTcs.Task);
}
public ReusableTask <int> ReceiveAsync(SocketMemory buffer)
{
SocketAsyncEventArgs args = GetSocketAsyncEventArgs(buffer);
args.UserToken = ReceiveTcs;
AsyncFlowControl?control = null;
if (!ExecutionContext.IsFlowSuppressed())
{
control = ExecutionContext.SuppressFlow();
}
try {
if (!Socket.ReceiveAsync(args))
{
ReceiveTcs.SetResult(args.BytesTransferred);
}
} catch (ObjectDisposedException) {
ReceiveTcs.SetResult(0);
} finally {
control?.Undo();
}
return(ReceiveTcs.Task);
}
private void Receive(CancellationToken cancellationToken)
{
Task.Run(async() =>
{
try
{
var channels = Channels;
var messageTypes = ServiceProvider.GetService <IMessageTypes>();
while (!cancellationToken.IsCancellationRequested)
{
var buffer = await ReadAsync(4, cancellationToken);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(buffer);
}
var length = BitConverter.ToInt32(buffer, 0);
CastMessage castMessage;
using (var ms = new MemoryStream())
{
await ms.WriteAsync(await ReadAsync(length, cancellationToken), 0, length);
ms.Position = 0;
castMessage = Serializer.Deserialize <CastMessage>(ms);
}
var payload = (castMessage.PayloadType == PayloadType.Binary ?
Encoding.UTF8.GetString(castMessage.PayloadBinary) : castMessage.PayloadUtf8);
//Debug.WriteLine($"RECEIVED: {castMessage.Namespace} : {payload}");
//Debug.WriteLine(castMessage.Namespace);
var channel = channels.FirstOrDefault(c => c.Namespace == castMessage.Namespace);
if (channel != null)
{
var message = JsonSerializer.Deserialize <MessageWithId>(payload);
if (messageTypes.TryGetValue(message.Type, out Type type))
{
try
{
var response = (IMessage)JsonSerializer.Deserialize(type, payload);
await channel.OnMessageReceivedAsync(response);
TaskCompletionSourceInvoke(message, "SetResult", response);
}
catch (Exception ex)
{
TaskCompletionSourceInvoke(message, "SetException", ex, new Type[] { typeof(Exception) });
}
}
}
}
}
catch (Exception)
{
await Dispose(false);
ReceiveTcs.SetResult(true);
}
});
}
private void Receive()
{
Task.Run(async() =>
{
try
{
while (true)
{
//First 4 bytes contains the length of the message
var buffer = await _stream.ReadAsync(4);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(buffer);
}
var length = BitConverter.ToInt32(buffer, 0);
var castMessage = CastMessage.Parser.ParseFrom(await _stream.ReadAsync(length));
//Payload can either be Binary or UTF8 json
var payload = (castMessage.PayloadType == PayloadType.Binary ?
Encoding.UTF8.GetString(castMessage.PayloadBinary.ToByteArray()) : castMessage.PayloadUtf8);
Console.WriteLine($"RECEIVED: {castMessage.Namespace} : {payload}");
var channel = Channels.FirstOrDefault(c => c.Namespace == castMessage.Namespace);
if (channel != null)
{
var message = JsonConvert.DeserializeObject <MessageWithId>(payload);
if (MessageTypes.TryGetValue(message.Type, out Type type))
{
try
{
var response = (IMessage)JsonConvert.DeserializeObject(payload, type);
await channel.OnMessageReceivedAsync(response);
TaskCompletionSourceInvoke(message, "SetResult", response);
}
catch (Exception ex)
{
TaskCompletionSourceInvoke(message, "SetException", ex, new Type[] { typeof(Exception) });
}
}
else
{
Debugger.Break();
}
}
}
}
catch (Exception)
{
//await Dispose(false);
ReceiveTcs.SetResult(true);
}
});
}
public ReusableTask <int> ReceiveAsync(Memory <byte> buffer)
{
if (Socket is null)
{
throw new InvalidOperationException("The underlying socket is not connected");
}
if (ReceiveArgs == null)
{
ReceiveArgs = new SocketAsyncEventArgs();
ReceiveArgs.Completed += Handler;
ReceiveArgs.UserToken = ReceiveTcs;
}
SetBuffer(ReceiveArgs, buffer);
SocketAsyncEventArgs args = ReceiveArgs;
AsyncFlowControl?control = null;
if (!ExecutionContext.IsFlowSuppressed())
{
control = ExecutionContext.SuppressFlow();
}
try {
if (!Socket.ReceiveAsync(args))
{
ReceiveTcs.SetResult(args.BytesTransferred);
}
} catch (ObjectDisposedException) {
ReceiveTcs.SetResult(0);
} finally {
control?.Undo();
}
return(ReceiveTcs.Task);
}
