private async Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var pairs = Request.GetQueryNameValuePairs().ToList();
if (pairs.Any())
{
var player = pairs.First();
var webSocket = context.WebSocket;
GameLogicHandler.AddPlayer(player.Value, webSocket);
await GameLogicHandler.NewGame();
byte[] receiveBuffer = new byte[1024];
while (webSocket.State == WebSocketState.Open)
{
try
{
var receiveResult = await webSocket.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), CancellationToken.None);
if (receiveResult.Count > 0)
{
string s = Encoding.UTF8.GetString(receiveBuffer, 0, receiveBuffer.Length).Replace("\0", string.Empty).ToString();
var answer = JsonConvert.DeserializeObject <Answer>(s);
await GameLogicHandler.EvaluateAnswer(answer);
}
}
catch (Exception e)
{
// To do
}
}
}
}
private Task ProcessWebsocketSession(AspNetWebSocketContext context)
{
var handler = new Hubs.WebSocketEventHandler();
var processTask = handler.ProcessWebSocketRequestAsync(context);
return(processTask);
}
/// <summary>
/// 部分Handler过程参考：http://www.cnblogs.com/lookbs/p/MVC-IMG.html
/// </summary>
/// <param name="webSocketContext"></param>
/// <returns></returns>
public static async Task WebSocketRequestHandler(AspNetWebSocketContext webSocketContext)
{
//Gets the current WebSocket object.
System.Net.WebSockets.WebSocket webSocket = webSocketContext.WebSocket;
/*We define a certain constant which will represent
* size of received data. It is established by us and
* we can set any value. We know that in this case the size of the sent
* data is very small.
*/
const int maxMessageSize = 1024;
//Buffer for received bits.
var receivedDataBuffer = new ArraySegment <Byte>(new Byte[maxMessageSize]);
var cancellationToken = new CancellationToken();
WebSocketHelper webSocketHandler = new WebSocketHelper(webSocket, cancellationToken);
var messageHandler = WebSocketConfig.WebSocketMessageHandlerFunc.Invoke();
if (webSocket.State == WebSocketState.Connecting)
{
if (WebSocketConfig.WebSocketMessageHandlerFunc != null)
{
await messageHandler.OnConnecting(webSocketHandler);//调用MessageHandler
}
}
//Checks WebSocket state.
await HandleMessage(webSocket);
}
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 arg)
{
WebSocket socket = arg.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 message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
//string returnMessage = "You send :" + message + ". at" + DateTime.Now.ToLongTimeString();
//buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(returnMessage));
//await socket.SendAsync(buffer, WebSocketMessageType.Text, true,CancellationToken.None);
if (!string.IsNullOrWhiteSpace(Config.Indicator))
{
Thread.Sleep(5000);
string sendMsg = $"两秒后主动推送消息，测试websocket,Indicator值为{Config.Indicator}。";
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(sendMsg));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
else
{
break;
}
}
}
Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var connection = new LiveClientConnection(socket);
return(connection.Start());
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
// Получаем сокет клиента из контекста запроса
var clientSocket = context.WebSocket;
// Слушаем его
var buffer = new ArraySegment <byte>(new byte[1024]);
// Ожидаем данные от него
var result = await clientSocket.ReceiveAsync(buffer, CancellationToken.None);
byte[] cleanBuffer = buffer.Array.Where(b => b != 0).ToArray();
int id = 0;
if (cleanBuffer.Length > 0)
{
id = Convert.ToInt32(Encoding.UTF8.GetString(buffer.Array));
}
if (clientSocket.State == WebSocketState.Open)
{
Thread closing = new Thread(async() => await GetUsers.isClosedConnection(clientSocket));
closing.Start();
}
while (clientSocket.State == WebSocketState.Open)
{
//var res = clientSocket.ReceiveAsync(buffer, CancellationToken.None);//Единственный ответ, который мы можем получить- инф о закрытии сокета и => мы завершим его обработку
await GetDialogs(context, id);
Thread.Sleep(30000);
}
}
/// <summary>
/// 无论是SuperSocket还是WebSocket都需要心跳包，需要健康检查，每隔多长时间去发送一条消息，浏览器定时发送消息给服务器，
/// 服务器接收到某一条特定的消息之后，马上回复给浏览器，那就表示连接是正常的；否则就需要去重新连接，其实就是短信重连；
/// </summary>
/// <param name="aspNetWebSocketContext"></param>
/// <returns></returns>
public async Task handSocket(AspNetWebSocketContext aspNetWebSocketContext)
{
WebSocket socket = aspNetWebSocketContext.WebSocket;
//保存起来
SocketManger.AddSocket(_name, Guid.NewGuid().ToString(), socket);
CancellationToken token = new CancellationToken();
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[8192]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, token);
string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
if (!string.IsNullOrEmpty(userMessage))
{
//前端调用关闭事件
if (result.MessageType == WebSocketMessageType.Close)
{
//如果是群聊的话，则要把该用户从Socket的list中移除
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, token);
}
else
{
SocketManger.SendOne(userMessage, token);
}
}
}
}
private static async Task SendAsync(AspNetWebSocketContext socketContext, string message, int retryCount)
{
var data = Encoding.UTF8.GetBytes(message + " => " + WebSocketCollection.Instance.Count.ToString());
var arraySegment = new ArraySegment <byte>(data);
try
{
var context = socketContext;
var socket = context.WebSocket;
await socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
}
catch (InvalidOperationException ex)
{
await Task.Delay(1000);
if (retryCount > 0)
{
await SendAsync(socketContext, message, --retryCount);
}
}
catch (Exception ex)
{
return;
}
}
private async Task ProcessInLabSocket(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (true)
{
if (socket.State == WebSocketState.Open)
{
InLabArea[] areas = GetInLab();
int count = areas.SelectMany(x => x.Clients).Count();
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[2048]);
var response = new { Timestamp = DateTime.Now, Count = count, Areas = areas };
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(Provider.Utility.Serialization.Json.SerializeObject(response)));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
await Task.Delay(10000);
}
else
{
break;
}
}
}
public async Task ProcessSocket(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
while (true)
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[1024]);
Console.WriteLine("Buffer Amount: " + buffer);
//Asynchrounously 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;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private async Task ProcessChat(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
CancellationToken cancellationToken = new CancellationToken();
//ChatManager.AddUser(_UserName, socket);
//某人登陆后，给群里其他人发 登陆消息
//await ChatManager.SendMessage(cancellationToken, $"{DateTime.Now.ToString("yyyyMMdd-HHmmss:fff")} {this._UserName} 进入聊天室");
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[2048]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, cancellationToken);
if (result.MessageType == WebSocketMessageType.Close) //如果输入帧为取消帧，发送close命令
{
//放在前面移除和发消息， 因为直接关浏览器会导致CloseAsync异常
//ChatManager.RemoveUser(_UserName);
//await ChatManager.SendMessage(cancellationToken, $"{DateTime.Now.ToString("yyyyMMdd-HHmmss:fff")} {this._UserName} 离开聊天室");
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken);
}
else//获取字符串
{
string userMsg = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
string content = $"{DateTime.Now.ToString("yyyyMMdd-HHmmss:fff")} {this._UserName} 发送了：{userMsg}";
//await ChatManager.SendMessage(cancellationToken, content);
}
}
}
private async Task ProcessRequestInternal(AspNetWebSocketContext ctx)
{
System.Diagnostics.Debug.WriteLine("In socket");
WebSocket socket = ctx.WebSocket;
await socket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes("Hello")), WebSocketMessageType.Text, true, CancellationToken.None);
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[1024]);
while (true)
{
var retVal = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (retVal.CloseStatus != null)
{
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Bye", CancellationToken.None);
return;
}
await socket.SendAsync(new ArraySegment <byte>(buffer.Array, 0, retVal.Count), retVal.MessageType, retVal.EndOfMessage, CancellationToken.None);
}
}
public async Task WebSocketRequestHandler(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
Debug.AddSocket(socket);
const int maxMessageSize = 1024;
if (socket.State == System.Net.WebSockets.WebSocketState.Open)
{
var receiveBuffer = new ArraySegment <Byte>(new Byte[maxMessageSize]);
var cancellationToken = new CancellationToken();
while (true)
{
var content = await socket.ReceiveAsync(receiveBuffer, cancellationToken);
if (content.MessageType == System.Net.WebSockets.WebSocketMessageType.Close)
{
Debug.RemoveSocket(socket);
break;
}
else
{
var text = Encoding.UTF8.GetString(receiveBuffer.Array, 0, content.Count);
Debug.HandleMessage(text);
}
}
}
}
private Task ProcessWebsocketSession(AspNetWebSocketContext context)
{
ChatWebSocketHandler handler = new ChatWebSocketHandler("a");
var processTask = handler.ProcessWebSocketRequestAsync(context);
return(processTask);
}
private async Task ProcessWSChat(AspNetWebSocketContext arg)
{
WebSocket socket = arg.WebSocket;
if (socketFirst == null)
{
socketFirst = socket;
}
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 message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
string returnMessage = "You send :" + message + ". at" + DateTime.Now.ToLongTimeString();
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(returnMessage));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
var response = TryRevokeBiz(message);
await SendToFirst(socket, returnMessage + " to first");
}
else
{
break;
}
}
}
private async Task ProcessRequestInternal(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var userId = Guid.NewGuid();
var tableIdInput = GetTableInput(context);
var tableId = _tables.AddUserToTable(tableIdInput, userId, socket);
var clientConnected = true;
while (true)
{
if (socket.State == WebSocketState.Open)
{
if (clientConnected)
{
await ProcessConnectedClientAsync(socket, tableId, userId);
clientConnected = false;
}
var message = await _messageExchanger.ReceiveMessageAsync(socket);
await _messageProcessor.ProcessMessageAsync(message, userId, tableId);
}
else
{
await ProcessDisconnectedClientAsync(tableId, userId);
break;
}
}
}
/// <summary>
/// 接收前端发送的数据
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task ProcessChat(AspNetWebSocketContext arg)
{
WebSocket socket = arg.WebSocket;
string key = arg.SecWebSocketKey;
if (!dicSockets.ContainsKey(key))
{
dicSockets.Add(key, socket);
}
while (true)
{
ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024 * 10]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
//前端发送的命令
string message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
}
else
{
dicSockets.Remove(key);
break;
}
}
}
Task ProcessWebSocketRequest(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var connection = new DemoWebSocketHandler(socket);
return(connection.Start());
}
public async Task PushExampleData(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)
{
}
else
{
break;
}
/*
*
* ArraySegment buffer = new ArraySegment(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(Encoding.UTF8.GetBytes(userMessage));
* await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
* }
* else
* {
* break;
* }*/
}
}
public async Task WebSocketRequestHandler(AspNetWebSocketContext webSocketContext)
{
var webSocket = webSocketContext.WebSocket;
const int maxMessageSize = 4096;
var receivedDataBuffer = new ArraySegment <byte>(new byte[maxMessageSize]);
var cancellationToken = new CancellationToken();
while (webSocket.State == WebSocketState.Open)
{
var webSocketReceiveResult = await webSocket.ReceiveAsync(receivedDataBuffer, cancellationToken);
if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
String.Empty, cancellationToken);
}
else
{
var payloadData = (receivedDataBuffer.Array ?? throw new InvalidOperationException()).Where(b => b != 0).ToArray();
var receivedString = System.Text.Encoding.UTF8.GetString(payloadData, 0, payloadData.Length);
if (String.IsNullOrEmpty(receivedString))
{
return;
}
//Write to db
var data = JsonConvert.DeserializeObject <WifiConnection>(receivedString);
var context = WifiFactory.GetContext();
context.WifiConnections.Add(data);
context.SaveChanges();
}
}
}
public async Task SendMsg(string msg, AspNetWebSocketContext C)
{
var cancellationToken = new CancellationToken();
Byte[] bytes = System.Text.Encoding.UTF8.GetBytes(msg);
await C.WebSocket.SendAsync(new ArraySegment <byte>(bytes), WebSocketMessageType.Text, true, cancellationToken);
}
/// <summary>
/// 群发
/// </summary>
/// <param name="socketContext"></param>
/// <returns></returns>
public async Task ProcessChat(AspNetWebSocketContext socketContext)
{
// SuperSocket:Session
// 表示客户端发起请求的一个链接
System.Net.WebSockets.WebSocket socket = socketContext.WebSocket;
CancellationToken token = new CancellationToken();
string socketGuid = Guid.NewGuid().ToString();
OldChatManager.AddUser(socketGuid, UserName, socket, token);
await OldChatManager.SengdMessage(token, UserName, "进入聊天室");
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[2048]);
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, token);
string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); // 来自于客户端发送过来的消息内容
if (result.MessageType == WebSocketMessageType.Close)
{
OldChatManager.RemoveUser(socketGuid);
await OldChatManager.SengdMessage(token, UserName, "离开聊天室");
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, token);
}
else
{
await OldChatManager.SengdMessage(token, UserName, userMessage);
}
}
}
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;
}
}
private async Task UserFunc(AspNetWebSocketContext aspNetWebSocketContext)
{
var model = new WebSocketModel()
{
SecWebSocketKey = aspNetWebSocketContext.SecWebSocketKey,
SecWebSocketProtocols = aspNetWebSocketContext.SecWebSocketProtocols?.ToList(),
SecWebSocketVersion = aspNetWebSocketContext.SecWebSocketVersion,
WebSocket = aspNetWebSocketContext.WebSocket,
UserName = aspNetWebSocketContext.User.Identity.Name
};
webSockets.Add(model);
while (true)
{
var buffer = new ArraySegment <byte>(new byte[64]);
var webSocketReceiveResult = await model.WebSocket.ReceiveAsync(buffer, CancellationToken.None);
if (model.WebSocket.State == WebSocketState.Open)
{
var receiveMessage = Encoding.UTF8.GetString(buffer.Array, 0, webSocketReceiveResult.Count);
var sendMessage = "You send :" + receiveMessage + ". at" + DateTime.Now.ToLongTimeString();
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(sendMessage));
await model.WebSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
break;
}
}
}
public async Task ProcessAsync(AspNetWebSocketContext context)
{
var socket = context.WebSocket;
var recvBuffer = new byte[1024];
while (socket.State == WebSocketState.Open)
{
using (var ms = new MemoryStream())
{
WebSocketReceiveResult result;
do
{
result = await socket.ReceiveAsync(
new ArraySegment <byte>(recvBuffer),
CancellationToken.None
);
ms.Write(recvBuffer, 0, result.Count);
} while (!result.EndOfMessage);
await socket.SendAsync(
new ArraySegment <byte>(ms.ToArray()),
WebSocketMessageType.Text,
true,
CancellationToken.None
);
}
}
}
public void Send(string message, AspNetWebSocketContext context)
{
foreach (var item in WebSocketCollection.Instance.Values)
{
Broker.Send(item.Context, message);
}
}
private async Task UserThread(AspNetWebSocketContext context)
{
WebSocket socket = context.WebSocket;
//获取Socket所要绑定的用户实体
UserEntity ue = ReconnectUserManager.Instance.GetContainUser(context.QueryString["userName"]);
ue.ConnectedSocket = socket;
//把用户从重连实体池转移到在线实体池
ReconnectUserManager.Instance.RemoveUserEntity(ue);
UserManager.Instance.RegUser(ue);
ue.InitUserConnect();//当用户连接时的初始化操作，把用户引入属于各自状态的空间
//循环等待并获取客户端信息
while (true)
{
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);//发送过来的消息
//--------------------测试------------------------
LobbyManager.Instance.AddRoom(new LobbyRoomEntity());
}
}
}
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;
}
}
}
public async Task WebSocketRequest(AspNetWebSocketContext context)
{
// Получаем сокет клиента из контекста запроса
var socket = context.WebSocket;
WsConnectionManager.AddWebSocket(socket);
// Слушаем его
while (socket.State == WebSocketState.Open)
{
var receiveBuffer = new ArraySegment <byte>(new byte[MsgBufferSize]);
// Ожидаем данные от него
var receiveResult = await socket.ReceiveAsync(receiveBuffer, CancellationToken.None);
var stringResult = BufferMsgToString(receiveBuffer, receiveResult.Count);
AddReceivedMsgToChatRoom(stringResult);
//Передаём сообщение всем клиентам
await WsConnectionManager.SendChatMessageToAll(stringResult);
}
// Если программа дошла сюда, значит, соединение закрылось
// Удаляем сокет
WsConnectionManager.DeleteWebSocket(socket);
}
