private void HandleNewMessage(WebSocketReceiveResult msgInfo, byte[] buffer)
{
if (msgInfo == null)
{
return;
}
try
{
if (msgInfo.MessageType == WebSocketMessageType.Text)
{
var text = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
OnTextMessage?.Invoke(text);
}
else if (msgInfo.MessageType == WebSocketMessageType.Binary)
{
OnBinaryMessage?.Invoke(buffer);
}
}
catch (Exception ex)
{
OnError?.Invoke(ex);
}
}
private void HandleMessage(OpCode opCode, byte[] data)
{
if (opCode == OpCode.Text)
{
OnTextMessage?.Invoke(this, Encoding.UTF8.GetString(data));
}
else
{
OnBinaryMessage?.Invoke(this, data);
}
}
private async Task Receive(ClientWebSocket clientWebSocket, CancellationToken token, Action <string> handleMessage)
{
while (_clientWebSocket.State == WebSocketState.Open && !token.IsCancellationRequested)
{
ArraySegment <Byte> buffer = new ArraySegment <byte>(new Byte[1024 * 4]);
WebSocketReceiveResult result = null;
using (var ms = new MemoryStream())
{
do
{
result = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None).ConfigureAwait(false);
ms.Write(buffer.Array, buffer.Offset, result.Count);
if (result.MessageType == WebSocketMessageType.Close)
{
break;
}
}while (!result.EndOfMessage);
_lastReceivedMsg = DateTime.UtcNow;
ms.Seek(0, SeekOrigin.Begin);
if (result.MessageType == WebSocketMessageType.Text)
{
try
{
string serializedMessage = null;
using (var reader = new StreamReader(ms, Encoding.UTF8))
{
serializedMessage = await reader.ReadToEndAsync().ConfigureAwait(false);
}
OnTextMessage?.Invoke(this, new TextMessageEventArgs(serializedMessage));
//handleMessage(serializedMessage);
}
catch (Exception e)
{
}
}
else if (result.MessageType == WebSocketMessageType.Binary)
{
OnBinaryMessage?.Invoke(this, new BinaryMessageEventArgs());
}
else if (result.MessageType == WebSocketMessageType.Close)
{
await _clientWebSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
_clientWebSocket = null;
_cancelation.Cancel();
OnClose?.Invoke(this, new CloseEventArgs());
break;
}
}
}
}
public bool on(string eventName, OnBinaryMessage listener)
{
if (eventName.Contains(':') || eventName.Contains('$') || listener == null)
{
return(false);
}
try
{
this.binaryMessageListeners[eventName] = listener;
}
catch (Exception)
{
return(false);
}
return(true);
}
public bool handleBinaryEvent(BinaryMessage m)
{
if (this.state != NetEventIOClientState.Authenticated || m.packetType != PacketType.C_binaryEvent)
{
return(false);
}
OnBinaryMessage listener = null;
try
{
listener = this.binaryMessageListeners[m.eventName];
}
catch (Exception) { return(false); }
if (listener == null)
{
return(false);
}
// emit event
listener(this, m);
return(true);
}
/// <summary>
/// Emits the binary message.
/// </summary>
/// <returns>The binary message.</returns>
/// <param name="messageEvent">Message event.</param>
protected void EmitBinaryMessage(BinaryMessageEvent messageEvent)
{
OnBinaryMessage?.Invoke(messageEvent);
}
/// <summary>
/// Awaitable task that reads incoming messages from the WebSocket.
/// This is a blocking method
/// </summary>
/// <returns></returns>
public async Task <ConnectionResult> ReadLoopAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested && !_disconnecting)
{
if (_ws.State != WebSocketState.Open)
{
TraceEvent(
"(ReadLoopAsync) Invalid attempt to read a closed socket",
EventIdentifiers.WS_ERR_READ_SOCK_CLOSE_ASYNC,
TraceEventType.Error
);
throw new InvalidOperationException("Websocket is not open");
}
if (ct.IsCancellationRequested)
{
TraceEvent(
"(ReadLoopAsync) Operation cancelled",
EventIdentifiers.WS_WAR_CANC_READ,
TraceEventType.Warning
);
ct.ThrowIfCancellationRequested();
}
await _sem.WaitAsync(ct);
WebSocketReceiveResult res;
ArraySegment <byte> buf = new ArraySegment <byte>(new byte[1024]);
res = await _ws.ReceiveAsync(buf, ct);
_sem.Release();
//We don't know how long the receive task has waited, so check for cancellation again
if (ct.IsCancellationRequested)
{
TraceEvent(
"(ReadLoopAsync) Operation cancelled",
EventIdentifiers.WS_WAR_CANC_READ_ASYNC,
TraceEventType.Warning
);
ct.ThrowIfCancellationRequested();
}
if (res.MessageType == WebSocketMessageType.Close)
{
_disconnecting = true;
TraceEvent(
$"(ReadLoopAsync) Close request: [{res.CloseStatus}] {res.CloseStatusDescription}",
EventIdentifiers.WS_INF_CONN_CLOSE_REQ,
TraceEventType.Information
);
await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close request acknowledged", ct);
TraceEvent(
"(ReadLoopAsync) Socket disconnected",
EventIdentifiers.WS_INF_CONN_CLOSE,
TraceEventType.Information
);
return(ConnectionResult.Disconnecting);
}
if (!res.EndOfMessage)
{
_rQ.Enqueue(buf.Take(res.Count));
continue;
}
List <byte> msg = new List <byte>();
while (!_rQ.IsEmpty)
{
_rQ.TryDequeue(out IEnumerable <byte> result);
msg.AddRange(result);
}
msg.AddRange(buf.Take(res.Count));
TraceEvent(
$"(ReadLoopAsync) Received bytes [ len: {res.Count} ]",
EventIdentifiers.WS_VER_RBYTES_ASYNC,
TraceEventType.Verbose
);
if (res.MessageType == WebSocketMessageType.Binary)
{
OnBinaryMessage?.Invoke(this, new BinaryMessageEventArgs(msg.ToArray()));
}
else
{
string strMsg = Encoding.UTF8.GetString(msg.ToArray());
OnTextMessage?.Invoke(this, new StringMessageEventArgs(strMsg));
}
}
if (ct.IsCancellationRequested)
{
TraceEvent(
"(ReadLoopAsync) Operation cancelled",
EventIdentifiers.WS_WAR_CANC_READ_ASYNC,
TraceEventType.Warning
);
ct.ThrowIfCancellationRequested();
}
TraceEvent(
"(ReadLoopAsync) Socket disconnecting",
EventIdentifiers.WS_INF_CONN_CLOSE,
TraceEventType.Information
);
return(ConnectionResult.Disconnecting);
}
