public async Task ProcessSocket(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
// Asynchronously wait for a message to arrive from a client
WebSocketReceiveResult result =
await socket.ReceiveAsync(buffer, CancellationToken.None);
// If the socket is still open, echo the message back to the client
if (socket.State == WebSocketState.Open)
{
string userMessage = Encoding.UTF8.GetString(buffer.Array, 0,
result.Count);
userMessage = "You sent: " + userMessage + " at " +
DateTime.Now.ToLongTimeString();
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage));
// Asynchronously send a message to the client
await socket.SendAsync(buffer, WebSocketMessageType.Text,
true, CancellationToken.None);
}
else { break; }
}
}
private async Task ProcessWSChat(AspNetWebSocketContext arg)
{
System.Net.WebSockets.WebSocket websct = arg.WebSocket;
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = await websct.ReceiveAsync(buffer, CancellationToken.None);
if (websct.State == WebSocketState.Open)
{
if (result.Count > 0)
{
string message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
JavaScriptSerializer js = new JavaScriptSerializer();
SocketMsgTypeModel data = js.Deserialize<SocketMsgTypeModel>(message);
string requetype = data.Msgtype;
string send = await SocketService.MessageTypes(requetype);
var returnMessage = "收到 :" + data + "_时间:" + DateTime.Now.ToLongTimeString();
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(returnMessage));
await websct.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
websct.Abort();
}
}
else
{
break;
}
}
await websct.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
}
private async Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
while (true)
{
/*
if (!HelicopterWorker.ProcessCommands)
{
Task.Run(() => new HelicopterWorker().Run());
}
* */
var buffer = new ArraySegment<byte>(new byte[1024]);
var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State != WebSocketState.Open) break;
var userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
var state = JObject.Parse(userMessage);
if (state != null)
{
//var response = string.Format("Throttle:{0}\tPitch:{1}\tYaw:{2}", state["Throttle"], state["Pitch"], state["Yaw"]);
Debug.WriteLine("Throttle:{0}\tPitch:{1}\tYaw:{2}", state["Throttle"], state["Pitch"], state["Yaw"]);
HelicopterState.SetValues(false, Convert.ToInt32(state["Throttle"].ToString()), Convert.ToInt32(state["Pitch"].ToString()), Convert.ToInt32(state["Yaw"].ToString()), 0);
}
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
private async Task ProcessWSChat(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = await socket.ReceiveAsync(
buffer, CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
string userMessage = Encoding.UTF8.GetString(
buffer.Array, 0, result.Count);
userMessage = "You sent: " + userMessage + " at " +
DateTime.Now.ToLongTimeString();
buffer = new ArraySegment<byte>(
Encoding.UTF8.GetBytes(userMessage));
await socket.SendAsync(
buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
break;
}
}
}
private async Task ProcessSocket(AspNetWebSocketContext context)
{
//generate a new ID for this socket connection
var socketId = Guid.NewGuid().ToString();
//get socket off context and send the socketId back to client
WebSocket socket = context.WebSocket;
await socket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(socketId)), WebSocketMessageType.Text, true, CancellationToken.None);
//add the socket to the dictionary
Clients.Add(socketId, socket);
//keep the connection open which checking for notifications to go out
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
string userMessage = Encoding.UTF8.GetString(
buffer.Array, 0, result.Count);
userMessage = "You sent: " + userMessage + " at " +
DateTime.Now.ToLongTimeString();
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
break;
}
}
}
private async Task ProcessWebsocketSession(AspNetWebSocketContext context)
{
var ws = context.WebSocket;
new Task(async () =>
{
var inputSegment = new ArraySegment<byte>(new byte[1024]);
while (true)
{
// MUST read if we want the state to get updated...
var result = await ws.ReceiveAsync(inputSegment, CancellationToken.None);
if (ws.State != WebSocketState.Open)
{
break;
}
}
}).Start();
while (true)
{
if (ws.State != WebSocketState.Open)
{
break;
}
else
{
byte[] binaryData = { 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe };
var segment = new ArraySegment<byte>(binaryData);
await ws.SendAsync(segment, WebSocketMessageType.Binary,
true, CancellationToken.None);
}
}
}
private async Task ProcessWSChat(AspNetWebSocketContext context, string homeHubId, string userEmail)
{
WebSocket socket = context.WebSocket;
using (var userAppSocket = new UserAppSocket(context.WebSocket, Services, homeHubId, userEmail))
{
await userAppSocket.Process();
}
}
private async Task ProcessWSChat(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
using (var cameraSocket = new CameraSocket(context.WebSocket, Services))
{
await cameraSocket.Process();
}
}
private async Task WebSocketLoop(AspNetWebSocketContext context)
{
WebSocket socket = null;
try
{
socket = context.WebSocket;
try
{
while (socket.State == WebSocketState.Open)
{
string serializedMessage = await ReadSerializedMessage(socket);
LogHelper.LogInfo("serializedMessage e: " + serializedMessage);
if (String.IsNullOrWhiteSpace(serializedMessage))
{
LogHelper.LogInfo(SerializationHelper.Serialize("serializedMessage is empty!"));
return;
}
Message message = JsonConvert.DeserializeObject<Message>(serializedMessage);
if (message == null || String.IsNullOrWhiteSpace(message.FromId) == true)
{
LogHelper.LogInfo("invalid messsage!");
return;
}
AddOrUpdateEntry(message.FromId, socket);
switch (message.MessageType)
{
case Enums.MessageType.Initialization:
break;
case Enums.MessageType.Chat:
await SendChatMessage(message);
break;
case Enums.MessageType.Broadcast:
break;
}
}
}
catch (Exception ex)
{
LogHelper.LogInfo(SerializationHelper.Serialize(ex.Message));
}
}
catch (Exception ex)
{
LogHelper.LogInfo(SerializationHelper.Serialize(ex.Message));
}
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
// Получаем сокет клиента из контекста запроса
WebSocket socket = context.WebSocket;
// Добавляем его в список клиентов
Locker.EnterWriteLock();
try
{
Clients.Add(socket);
}
finally
{
Locker.ExitWriteLock();
}
// Слушаем его
while (true)
{
var buffer = new ArraySegment<byte>(new byte[1024]);
// Ожидаем данные от него
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
//Передаём сообщение всем клиентам
for (int i = 0; i < Clients.Count; i++)
{
WebSocket client = Clients[i];
try
{
if (client.State == WebSocketState.Open)
{
await client.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
catch (ObjectDisposedException)
{
Locker.EnterWriteLock();
try
{
Clients.Remove(client);
i--;
}
finally
{
Locker.ExitWriteLock();
}
}
}
}
}
private static async Task WebSocketProcessRequest(AspNetWebSocketContext context)
{
byte[] bytes = new byte[4096];
while (true)
{
var result = context.WebSocket.ReceiveAsync(new ArraySegment<byte>(bytes), CancellationToken.None).Result;
if (result.MessageType == WebSocketMessageType.Close)
{
return;
}
context.WebSocket.SendAsync(new ArraySegment<byte>(bytes, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None).Wait();
}
}
private async Task ProcessChat(AspNetWebSocketContext context)
{
using (WebSocket socket = context.WebSocket)
{
var key = Guid.NewGuid().ToString();
socketList.Add(key, socket);
while (true)
{
ClearExpiredSocket();
if (socket.State == WebSocketState.Open)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[2048]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
string userMsg = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
var responseResult = string.Empty;
if (userMsg == "progress1")
{
responseResult = GetPlayer();
}
if (userMsg == "progress2")
{
responseResult = GetAllPosition();
}
if (responseResult != string.Empty)
{
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(responseResult));
foreach (var s in socketList)
{
try
{
if (s.Value.State == WebSocketState.Open)
{
await s.Value.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
catch
{
}
}
}
}
else
{
break;
}
}
}
}
public async Task SocketReceiver(AspNetWebSocketContext context)
{
Context = context;
// We have just made a connecton, so tell the client about the current player
SendMessage(new PlayerConnectedMessage(this));
// If the game is on, we're the second player
if (this.Game.Status == GameInProgress.GameStatus.InProgress)
{
SendMessage(new GameOnMessage());
}
// Start listening on the socket
var socket = context.WebSocket as AspNetWebSocket;
var buffer = new ArraySegment<byte>(new byte[2048]);
try
{
while (true)
{
var message = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State != WebSocketState.Open)
{
Disconnects(this);
}
var json = Encoding.UTF8.GetString(buffer.Array, 0, message.Count);
var test = new { type = "" };
test = JsonConvert.DeserializeAnonymousType(json, test);
if (test.type == "move")
{
var move = JsonConvert.DeserializeObject<PlayerMovesMessage>(json, settings: null);
Moves(this, move);
}
else if (test.type == "wins")
{
var wins = JsonConvert.DeserializeObject<PlayerWinsMessage>(json, settings: null);
Game.Winner(wins.player);
}
}
}
catch( Exception ex )
{
Disconnects(this);
}
}
private async Task ProcessWSRequest(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
var screenGuid = Guid.NewGuid();
//tell the client about their new identifier
await socket.sendObject(new
{
identifier = screenGuid
});
dynamic confirmation = await socket.receiveObject();
bool isokay = false;
try
{
isokay = confirmation.ok;
}
catch (RuntimeBinderException)
{
//om nom nom
}
if (!isokay)
{
await socket.CloseAsync(WebSocketCloseStatus.ProtocolError, "Expecting confirmation to be true", CancellationToken.None);
return;
}
TypeResolver.IScreenManager.AddScreen(screenGuid, socket);
/*
while (true)
{
dynamic msg = await socket.receiveObject();
if (socket.State != WebSocketState.Open)
{
TypeResolver.IScreenManager.RemoveScreen(screenGuid);
return;
}
}*/
}
private async Task ProcessProtoBufDecodeRecode(AspNetWebSocketContext context)
{
System.Net.WebSockets.WebSocket socket = context.WebSocket;
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
var inputStream = new System.IO.MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
TestObject msg = Serializer.Deserialize<TestObject>(inputStream);
if (socket.State == WebSocketState.Open)
{
msg.Name = "now I change you";
msg.TestId = 12;
msg.IsWorking = true;
msg.Priority = Priority.HIGH;
msg.Balance = 876.54321;
msg.Contacts.Add(new Contact
{
Name = "Jo",
ContactDetails = "*****@*****.**"
});
msg.Contacts.Add(new Contact
{
Name = "Fred",
ContactDetails = "01234121412"
});
ArraySegment<byte> outputBuffer;
using (var serializationBuffer = new System.IO.MemoryStream())
{
Serializer.Serialize(serializationBuffer, msg);
outputBuffer = new ArraySegment<byte>(serializationBuffer.GetBuffer(), 0, (int)serializationBuffer.Length);
}
await socket.SendAsync(outputBuffer, WebSocketMessageType.Binary, true, CancellationToken.None);
}
else
{
break;
}
}
}
private async Task ProcessWS(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
sockets.Add(socket);
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
//WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
try
{
while (socket.State == WebSocketState.Open)
{
WebSocketReceiveResult receiveResult = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (receiveResult.MessageType == WebSocketMessageType.Close)
{
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
}
else if (receiveResult.MessageType == WebSocketMessageType.Text)
{
string receivedMessage = Encoding.UTF8.GetString(buffer.Array, 0, receiveResult.Count);
string userMessage = string.Format("{0}", receivedMessage);
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage));
sockets.ForEach(sck =>
{
sck.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
});
}
else
{
}
}
}
catch
{
}
finally
{
sockets.Remove(socket);
socket.Dispose();
}
}
private async Task ProcessWSChat(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = await socket.ReceiveAsync(
buffer, CancellationToken.None);
if (socket.State != WebSocketState.Open)
break;
//string userMessage = Encoding.UTF8.GetString(
// buffer.Array, 0, result.Count);
//buffer = new ArraySegment<byte>(
// Encoding.UTF8.GetBytes(userMessage));
await socket.SendAsync(
buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
/// <summary>
/// Принимает соединения сокета
/// </summary>
public async Task Receiver(AspNetWebSocketContext context)
{
_context = context;
var socket = _context.WebSocket as AspNetWebSocket;
// подготовить буфер для чтения сообщений
var inputBuffer = new ArraySegment<byte>(new byte[1024]);
// отправить номер игрока другому игроку
SendMessage(new PlayerNumberMessage { PlayerNumber = _game.GetPlayerIndex(this) });
try
{
while (true)
{
// чтение из сокета
var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None);
if (socket.State != WebSocketState.Open)
{
if (PlayerDisconnected != null)
PlayerDisconnected(this);
break;
}
// конвертация bytes в string
var messageString = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count);
// десериализует толькоPlayerPositionMessage
var positionMessage = JsonConvert.DeserializeObject<PlayerPositionMessage>(messageString);
//сохранить новую позицию и отправить в игру
YPos = positionMessage.YPos;
if (PlayerMoved != null)
PlayerMoved(this, positionMessage);
}
}
catch (Exception ex)
{
if (PlayerDisconnected != null)
PlayerDisconnected(this);
}
}
/// <summary>
/// This method is used as delegate to accept WebSocket connection
/// </summary>
public async Task Receiver(AspNetWebSocketContext context)
{
_context = context;
var socket = _context.WebSocket as AspNetWebSocket;
// prepare buffer for reading messages
var inputBuffer = new ArraySegment<byte>(new byte[1024]);
// send player number to player
SendMessage(new PlayerNumberMessage { PlayerNumber = _game.GetPlayerIndex(this) });
try
{
while (true)
{
// read from socket
var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None);
if (socket.State != WebSocketState.Open)
{
if (PlayerDisconnected != null)
PlayerDisconnected(this);
break;
}
// convert bytes to text
var messageString = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count);
// only PlayerPositionMessage is expected, deserialize
var positionMessage = JsonConvert.DeserializeObject<PlayerPositionMessage>(messageString);
// save new position and notify game
YPos = positionMessage.YPos;
if (PlayerMoved != null)
PlayerMoved(this, positionMessage);
}
}
catch (Exception ex)
{
if (PlayerDisconnected != null)
PlayerDisconnected(this);
}
}
private async Task AcceptCallback(AspNetWebSocketContext webSocketContext)
{
OwinWebSocketWrapper wrapper = null;
try
{
wrapper = new OwinWebSocketWrapper(webSocketContext);
await _webSocketFunc(wrapper.Environment);
// Making sure to close the web socket is not necessary, Asp.Net will do this for us.
wrapper.Dispose();
}
catch (Exception ex)
{
if (wrapper != null)
{
wrapper.Cancel();
wrapper.Dispose();
}
// traced as warning here because it is re-thrown
_trace.WriteWarning(Resources.Trace_WebSocketException, ex);
throw;
}
}
public async Task Receiver(AspNetWebSocketContext context)
{
this.context = context;
var socket = this.context.WebSocket as AspNetWebSocket;
var inputBuffer = new ArraySegment<byte>(new byte[1024]);
try
{
while (true)
{
var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None);
if (socket.State != WebSocketState.Open)
{
if (this.Disconnected != null)
{
this.Disconnected(this);
}
break;
}
var message = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count);
if (this.MessageReceived != null)
{
this.MessageReceived(this, message);
}
}
}
catch (Exception)
{
if (this.Disconnected != null)
{
this.Disconnected(this);
}
throw;
}
}
/*
* IMPLEMENTATION
*/
public Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext)
{
if (webSocketContext == null)
{
throw new ArgumentNullException("webSocketContext");
}
byte[] buffer = new byte[_receiveLoopBufferSize];
WebSocket webSocket = webSocketContext.WebSocket;
return ProcessWebSocketRequestAsync(webSocketContext, () => WebSocketMessageReader.ReadMessageAsync(webSocket, buffer, MaxIncomingMessageSize));
}
Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var connection = new DemoWebSocketHandler(socket);
return connection.Start();
}
Task PostAcceptWebSocket(AspNetWebSocketContext context)
{
this.webSocketWaitingTask = new TaskCompletionSource<object>();
this.WebSocketChannel.Closed += new EventHandler(this.FinishWebSocketWaitingTask);
this.webSocketContextTaskSource.SetResult(context);
return webSocketWaitingTask.Task;
}
private Task ProcessWebsocketSession(AspNetWebSocketContext context)
{
var handler = new NyanWebSocketHandler();
var processTask = handler.ProcessWebSocketRequestAsync(context);
return processTask;
}
Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var connection = new LiveClientConnection(socket);
return connection.Start();
}
/// <summary>
/// Initiates an ASP.Net websocket and starts accepting messages.
/// </summary>
public virtual Task Init(AspNetWebSocketContext socketContext)
{
_socketContext = socketContext;
return ReceiveMessage();
}
private async Task WebSocketRequestHandler(AspNetWebSocketContext context) {
Log("Accepted web socket request from {0}.", context.UserHostAddress);
TaskCompletionSource<bool> tcs = null;
if (!AllowConcurrentConnections) {
tcs = new TaskCompletionSource<bool>();
while (true) {
var currentSession = Interlocked.CompareExchange(ref _currentSession, tcs.Task, null);
if (currentSession == null) {
break;
}
Log("Another session is active, waiting for completion.");
await currentSession;
Log("The other session completed, proceeding.");
}
}
try {
var webSocket = context.WebSocket;
using (var tcpClient = new TcpClient("localhost", DebuggerPort)) {
try {
var stream = tcpClient.GetStream();
var cts = new CancellationTokenSource();
// Start the workers that copy data from one socket to the other in both directions, and wait until either
// completes. The workers are fully async, and so their loops are transparently interleaved when running.
// Usually end of session is caused by VS dropping its connection on detach, and so it will be
// CopyFromWebSocketToStream that returns first; but it can be the other one if debuggee process crashes.
Log("Starting copy workers.");
var copyFromStreamToWebSocketTask = CopyFromStreamToWebSocketWorker(stream, webSocket, cts.Token);
var copyFromWebSocketToStreamTask = CopyFromWebSocketToStreamWorker(webSocket, stream, cts.Token);
Task completedTask = null;
try {
completedTask = await Task.WhenAny(copyFromStreamToWebSocketTask, copyFromWebSocketToStreamTask);
} catch (IOException ex) {
Log(ex);
} catch (WebSocketException ex) {
Log(ex);
}
// Now that one worker is done, try to gracefully terminate the other one by issuing a cancellation request.
// it is normally blocked on a read, and this will cancel it if possible, and throw OperationCanceledException.
Log("One of the workers completed, shutting down the remaining one.");
cts.Cancel();
try {
await Task.WhenAny(Task.WhenAll(copyFromStreamToWebSocketTask, copyFromWebSocketToStreamTask), Task.Delay(1000));
} catch (OperationCanceledException ex) {
Log(ex);
}
// Try to gracefully close the websocket if it's still open - this is not necessary, but nice to have.
Log("Both workers shut down, trying to close websocket.");
try {
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
} catch (WebSocketException ex) {
Log(ex);
}
} finally {
// Gracefully close the TCP socket. This is crucial to avoid "Remote debugger already attached" problems.
Log("Shutting down TCP socket.");
try {
tcpClient.Client.Shutdown(SocketShutdown.Both);
tcpClient.Client.Disconnect(false);
} catch (SocketException ex) {
Log(ex);
}
Log("All done!");
}
}
} finally {
if (tcs != null) {
Volatile.Write(ref _currentSession, null);
tcs.SetResult(true);
}
}
}
internal async Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext, Func<Task<WebSocketMessage>> messageRetriever)
{
try
{
// first, set primitives and initialize the object
WebSocketContext = webSocketContext;
OnOpen();
// dispatch incoming messages
while (true)
{
WebSocketMessage incomingMessage = await messageRetriever();
switch (incomingMessage.MessageType)
{
case WebSocketMessageType.Binary:
OnMessage((byte[])incomingMessage.Data);
break;
case WebSocketMessageType.Text:
OnMessage((string)incomingMessage.Data);
break;
default:
// If we received an incoming CLOSE message, we'll queue a CLOSE frame to be sent.
// We'll give the queued frame some amount of time to go out on the wire, and if a
// timeout occurs we'll give up and abort the connection.
await Task.WhenAny(CloseAsync(), Task.Delay(_closeTimeout))
.ContinueWith(_ => { }, TaskContinuationOptions.ExecuteSynchronously); // swallow exceptions occurring from sending the CLOSE
return;
}
}
}
catch (Exception ex)
{
if (IsFatalException(ex))
{
Error = ex;
OnError();
}
}
finally
{
try
{
// we're finished
OnClose();
}
finally
{
// call Dispose if it exists
IDisposable disposable = this as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
}
public async Task WebSocketHandler(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (socket.State == WebSocketState.Open)
{
var buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result =
await socket.ReceiveAsync(buffer, CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string userMessage = Encoding.UTF8.GetString(buffer.Array, 0,
result.Count);
Task.Run(async () =>
{
OnMessageArrived(socket, userMessage);
});
}
else if (result.MessageType == WebSocketMessageType.Binary)
{
var lists = new List<ArraySegment<byte>>();
if (result.EndOfMessage)
{
lists.Add(new ArraySegment<byte>(buffer.Array, 0, result.Count));
}
else
{
lists.Add(buffer);
while (!result.EndOfMessage)
{
buffer = new ArraySegment<byte>(new byte[1024]);
result =
await socket.ReceiveAsync(buffer, CancellationToken.None);
if (!result.EndOfMessage)
{
lists.Add(buffer);
}
else
{
lists.Add(new ArraySegment<byte>(buffer.Array, 0, result.Count));
}
}
}
Task.Run(async () =>
{
var buff = MergeAllBytes(lists);
OnDataArrived(socket, buff);
});
}
else if (result.MessageType == WebSocketMessageType.Close)
{
socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
}
}
}
