.Net API webSocket 模板

.Net FrameWork 

private static List<WebSocket> _sockets = new List<WebSocket>();

        [Route("Connect")]
        [HttpGet]
        [AllowAnonymous]
        public HttpResponseMessage Connect()
        {
            HttpContext.Current.AcceptWebSocketRequest(ProcessRequest); //在服务器端接受Web Socket请求，传入的函数作为Web Socket的处理函数，待Web Socket建立后该函数会被调用，在该函数中可以对Web Socket进行消息收发

            return Request.CreateResponse(HttpStatusCode.SwitchingProtocols); //构造同意切换至Web Socket的Response.
        }

        public async Task ProcessRequest(AspNetWebSocketContext context)
        {
            var socket = context.WebSocket;//传入的context中有当前的web socket对象
            _sockets.Add(socket);//此处将web socket对象加入一个静态列表中

            //进入一个无限循环，当web socket close是循环结束
            while (true)
            {
                var buffer = new ArraySegment<byte>(new byte[1024]);
                var receivedResult = await socket.ReceiveAsync(buffer, CancellationToken.None);//对web socket进行异步接收数据
                if (receivedResult.MessageType == WebSocketMessageType.Close)
                {
                    await socket.CloseAsync(WebSocketCloseStatus.Empty, string.Empty, CancellationToken.None);//如果client发起close请求，对client进行ack
                    _sockets.Remove(socket);
                    break;
                }

                if (socket.State == System.Net.WebSockets.WebSocketState.Open)
                {
                    string recvMsg = Encoding.UTF8.GetString(buffer.Array, 0, receivedResult.Count);
                    var recvBytes = Encoding.UTF8.GetBytes(recvMsg);
                    var sendBuffer = new ArraySegment<byte>(buffer.Array);
                    foreach (var innerSocket in _sockets)//当接收到文本消息时，对当前服务器上所有web socket连接进行广播
                    {
                        if (innerSocket != socket)
                        {
                            await innerSocket.SendAsync(sendBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
                        }
                    }
                }
            }
        }

.Net Core

Startup.cs

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
   //添加WebSocket支持，SignalR优先使用WebSocket传输
    app.UseWebSockets(webSocketOptions);
  
   app.Use(async (context, next) =>
          {
              if (context.Request.Path == "/ws1")
              {
                  if (context.WebSockets.IsWebSocketRequest)
                  {
                      //非压缩
                      using (WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync())
                      {
                          await Echo(context, webSocket);
                      }

                      //压缩信息
                      //using (WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(
                      //new WebSocketAcceptContext() { DangerousEnableCompression = true }))
                      // {
                      //   await Echo(context, webSocket);
                      // }
                      //}
                  }
                  else
                  {
                      context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
                  }
              }
              else
              {
                  await next();
              }

          });
}

public void ConfigureServices(IServiceCollection services)
{



    //注入SignalR实时通讯，默认用json传输
    services.AddSignalR(options =>
    {
        //客户端发保持连接请求到服务端最长间隔，默认30秒，改成4分钟，网页需跟着设置connection.keepAliveIntervalInMilliseconds = 12e4;即2分钟
        options.ClientTimeoutInterval = TimeSpan.FromMinutes(4);
        //服务端发保持连接请求到客户端间隔，默认15秒，改成2分钟，网页需跟着设置connection.serverTimeoutInMilliseconds = 24e4;即4分钟
        options.KeepAliveInterval = TimeSpan.FromMinutes(2);
    });



}

消息处理中间方法

    private async Task Echo(HttpContext context, WebSocket webSocket)
    {
        var buffer = new byte[1024 * 4];
        WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        while (!result.CloseStatus.HasValue)
        {
            if (result.MessageType == WebSocketMessageType.Text)
            {
                //获取文本
                string str = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Count);
                //传递文本
                byte[] byteArray = System.Text.Encoding.Default.GetBytes("我收到了消息："+str);
                await webSocket.SendAsync(new ArraySegment<byte>(byteArray, 0, byteArray.Length), result.MessageType, result.EndOfMessage, CancellationToken.None);

                result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }
          
        }
        await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
    }
}