服务器开发- Asp.Net Core中的websocket，并封装一个简单的中间件 -阿里云开发者社区

先拉开MSDN的文档，大致读一遍 (https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/websockets)

WebSocket 是一个协议，支持通过 TCP 连接建立持久的双向信道。它可用于聊天、股票报价和游戏等应用程序，以及 Web 应用程序中需要实时功能的任何情景。　

使用方法　　

安装 Microsoft.AspNetCore.WebSockets 包。
配置中间件。
接受 WebSocket 请求。
发送和接收消息。

如果是创建的asp.net core项目，默认会有一个all的包，里面默认带了websocket的包。所以，添加的时候，注意看一下

然后就是配置websocket的中间件

app.UseWebSockets();

　如果需要更细致的配置websocket，MSDN文档上也提供了一种配置缓冲区大小和ping的option

var webSocketOptions = new WebSocketOptions()
{
    KeepAliveInterval = TimeSpan.FromSeconds(120),  //向客户端发送“ping”帧的频率，以确保代理保持连接处于打开状态
    ReceiveBufferSize = 4 * 1024   //用于接收数据的缓冲区的大小。 只有高级用户才需要对其进行更改，以便根据数据大小调整性能。
};
app.UseWebSockets(webSocketOptions);

接受 WebSocket 请求

在请求生命周期后期（例如在 Configure 方法或 MVC 操作的后期），检查它是否是 WebSocket 请求并接受 WebSocket 请求。

该示例来自 Configure 方法的后期。

app.Use(async (context, next) =>
{
    if (context.Request.Path == "/ws")
    {
        if (context.WebSockets.IsWebSocketRequest)
        {
            WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
            await Echo(context, webSocket);
        }
        else
        {
            context.Response.StatusCode = 400;
        }
    }
    else
    {
        await next();
    }
});

WebSocket 请求可以来自任何 URL，但此示例代码只接受 /ws 的请求

(比如要测试websocket的连接，地址必须写上：ws://ip:端口/ws) 最后这个路径的ws是可以自己定义的，可以理解为MVC的路由，或者url地址，websocket第一次连接的时候，可以使用url传递参数

发送和接收消息

AcceptWebSocketAsync 方法将 TCP 连接升级到 WebSocket 连接，并提供 WebSocket 对象。使用 WebSocket 对象发送和接收消息。

之前显示的接受 WebSocket 请求的代码将 WebSocket 对象传递给 Echo 方法；此处为 Echo 方法。代码接收消息并立即发回相同的消息。一直在循环中执行此操作，直到客户端关闭连接

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)
    {
        await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), 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);
}

如果在开始此循环之前接受 WebSocket，中间件管道会结束。关闭套接字后，管道展开。也就是说，如果接受 WebSocket ，请求会在管道中停止前进，就像点击 MVC 操作一样。但是完成此循环并关闭套接字时，请求将在管道中后退。

如果要测试是否连上，那么可以自己写ws的客户端程序，当然也可以使用一些现成的工具辣

封装一个简单的中间件:

什么是中间件？MSDN对此的解释是：

中间件是一种装配到应用程序管道以处理请求和响应的软件。每个组件：

选择是否将请求传递到管道中的下一个组件。
可在调用管道中的下一个组件前后执行工作。

请求委托用于生成请求管道。请求委托处理每个 HTTP 请求。

使用 Run、Map 和 Use 扩展方法来配置请求委托。可将一个单独的请求委托并行指定为匿名方法（称为并行中间件），或在可重用的类中对其进行定义。这些可重用的类和并行匿名方法即为中间件或中间件组件。请求管道中的每个中间件组件负责调用管道中的下一个组件，或在适当情况下使链发生短路。

新建一个WebSocketExtensions.cs的类

public static class WebSocketExtensions
    {
        public static IApplicationBuilder MapWebSocketManager(this IApplicationBuilder app,PathString path,WebSocketHandler handler)
        {
            return app.Map(path, (_app) => _app.UseMiddleware<WebSocketManagerMiddleware>(handler));
        }
        public static IServiceCollection AddWebSocketManager(this IServiceCollection services)
        {
            services.AddTransient<WebSocketConnectionManager>();
            foreach (var type in Assembly.GetEntryAssembly().ExportedTypes)
            {
                if (type.GetTypeInfo().BaseType == typeof(WebSocketHandler))
                {
                    services.AddSingleton(type);
                }
            }
            return services;
        }
    }

AddWebSocketManager这个方法主要是处理依赖注入的问题。通过反射把实现WebSocketHandler的类，统统注入

管理websocket连接

public class WebSocketConnectionManager
    {
        private ConcurrentDictionary<string, WebSocket> _sockets = new ConcurrentDictionary<string, WebSocket>();
        public int GetCount()
        {
            return _sockets.Count;
        }
        public WebSocket GetSocketById(string id)
        {
            return _sockets.FirstOrDefault(p => p.Key == id).Value;
        }
        public ConcurrentDictionary<string, WebSocket> GetAll()
        {
            return _sockets;
        }
        public WebSocket GetWebSocket(string key)
        {
            WebSocket _socket;
            _sockets.TryGetValue(key, out _socket);
            return _socket;
        }
        public string GetId(WebSocket socket)
        {
            return _sockets.FirstOrDefault(p => p.Value == socket).Key;
        }
        public void AddSocket(WebSocket socket,string key)
        {
            if (GetWebSocket(key)!=null)
            {
                _sockets.TryRemove(key, out WebSocket destoryWebsocket);
            }
            _sockets.TryAdd(key, socket);
            //string sId = CreateConnectionId();
            //while (!_sockets.TryAdd(sId, socket))
            //{
            //    sId = CreateConnectionId();
            //}
        }
        public async Task RemoveSocket(string id)
        {
            try
            {
                WebSocket socket;
                _sockets.TryRemove(id, out socket);
                await socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
            }
            catch (Exception)
            {
            }
        }
        public async Task CloseSocket(WebSocket socket)
        {
            await socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
        }
        private string CreateConnectionId()
        {
            return Guid.NewGuid().ToString();
        }
    }

这里我把客户的连接的管理都封装到一个连接类里面，我的思路是

我使用webapi来验证身份，走http协议的接口
验证成功后，服务器给客户端返回一个token
客户端通过websocket连接服务器的时候，需要带上上次返回的token，这样我就可以在连接字典里面判断出重复的socket（因为我试过在.Net core里面如果多次连接，服务器不会走断开的事件，而是不断的出现多个socket对象）

WebSocketManagerMiddleware类的封装

public class WebSocketManagerMiddleware
    {
        private readonly RequestDelegate _next;
        private WebSocketHandler _webSocketHandler { get; set; }
        public WebSocketManagerMiddleware(RequestDelegate next,
                                          WebSocketHandler webSocketHandler)
        {
            _next = next;
            _webSocketHandler = webSocketHandler;
        }
        public async Task Invoke(HttpContext context)
        {
            if (!context.WebSockets.IsWebSocketRequest)
                return;
            var socket = await context.WebSockets.AcceptWebSocketAsync();
            string Key = context.Request.Query["Key"];
            Console.WriteLine("连接人："+Key);
            _webSocketHandler.OnConnected(socket,Key);
            await Receive(socket, async (result, buffer) =>
            {
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    await _webSocketHandler.ReceiveAsync(socket, result, buffer);
                    return;
                }
                else if (result.MessageType == WebSocketMessageType.Close)
                {
                    await _webSocketHandler.OnDisconnected(socket);
                    return;
                }
            });
            //TODO - investigate the Kestrel exception thrown when this is the last middleware
            //await _next.Invoke(context);
        }
        private async Task Receive(WebSocket socket, Action<WebSocketReceiveResult, byte[]> handleMessage)
        {
            try
            {
                var buffer = new byte[1024 * 4];
                while (socket.State == WebSocketState.Open)
                {
                    var result = await socket.ReceiveAsync(buffer: new ArraySegment<byte>(buffer),
                                                           cancellationToken: CancellationToken.None);
                    handleMessage(result, buffer);
                }
            }
            catch (Exception ex)
            {
                GsLog.E(ex.StackTrace);
            }
        }
    }

Invoke的时候，传递的key参数需要客户端验证身份后，传递进来:(ws://ip:端口/ws?key=xxx) 这样的格式来连接websocket

在这个类里面，我们主要处理三个事情

如果客户端连接进来，那么我们把这个连接放到连接管理字典里面
如果客户端断开连接，那么我们把这个连接冲连接管理字典里面移除
如果是发送数据过来，那么我们就调用ReceiveAsync方法，并把连接对象和数据传递进去

WebSocketHandler类的封装

这个类主要关联游戏逻辑模块和websocket的一个纽带，我们封装的中间件，通过websockethandler把数据传递给实现这个类的子类

public abstract class WebSocketHandler
    {
        public WebSocketConnectionManager WebSocketConnectionManager { get; set; }
        public WebSocketHandler(WebSocketConnectionManager webSocketConnectionManager)
        {
            WebSocketConnectionManager = webSocketConnectionManager;
        }
        public virtual void OnConnected(WebSocket socket, string key)
        {
            //var ServerSocket = WebSocketConnectionManager.GetWebSocket(key);
            //if (ServerSocket != null)
            //{
            //    WebSocketConnectionManager.AddSocket();
            //    Console.WriteLine("已经存在当前的连接，断开。。");
            //}
            WebSocketConnectionManager.AddSocket(socket, key);
        }
        public virtual async Task OnDisconnected(WebSocket socket)
        {
            Console.WriteLine("Socket 断开了");
            await WebSocketConnectionManager.RemoveSocket(WebSocketConnectionManager.GetId(socket));
        }
        public async Task SendMessageAsync(WebSocket socket, string message)
        {
            if (socket.State != WebSocketState.Open)
                return;
            var bytes = Encoding.UTF8.GetBytes(message);
            await socket.SendAsync(buffer: new ArraySegment<byte>(array: bytes, offset: 0, count: bytes.Length), messageType: WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None);
        }
        public async Task SendMessageAsync(string socketId, string message)
        {
            try
            {
                await SendMessageAsync(WebSocketConnectionManager.GetSocketById(socketId), message);
            }
            catch (Exception)
            {
            }
        }
        public async Task SendMessageToAllAsync(string message)
        {
            foreach (var pair in WebSocketConnectionManager.GetAll())
            {
                if (pair.Value.State == WebSocketState.Open)
                    await SendMessageAsync(pair.Value, message);
            }
        }
        /// <summary>
        /// 获取一些连接
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public IEnumerable<WebSocket> GetSomeWebsocket(string[] keys)
        {
            foreach (var key in keys)
            {
                yield return WebSocketConnectionManager.GetWebSocket(key);
            }
        }
        /// <summary>
        /// 给一堆人发消息
        /// </summary>
        /// <param name="webSockets"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public async Task SendMessageToSome(WebSocket[] webSockets, string message)
        {
            webSockets.ToList().ForEach(async a => { await SendMessageAsync(a, message); });
        }
        public abstract Task ReceiveAsync(WebSocket socket, WebSocketReceiveResult result, byte[] buffer);
    }

需要把一些必须要重写的方法定义为abstract 给子类重写

使用我们写好的websocket管理中间件

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddWebSocketManager();
        }

var webSocketOptions = new WebSocketOptions()
            {
                KeepAliveInterval = TimeSpan.FromSeconds(20),
                ReceiveBufferSize = 4 * 1024
            };
            app.UseWebSockets(webSocketOptions);
            app.MapWebSocketManager("/zhajinhua", serviceProvider.GetService<ZjhGame>());

ZjhGame这个类，必须实现 WebSocketHandler，这样我们就能在ZjhGame这个类，处理游戏逻辑

好了，大致就是这样的，毕竟我也没有开发游戏的经验，有错误的地方，希望大佬们能指出

还有上一篇博客有大佬说加注，但是我没有收到加注的钱啊，你们到底加不加啊？不加我可要反悔了啊

http://www.cnblogs.com/boxrice/p/8570730.html

服务器开发- Asp.Net Core中的websocket，并封装一个简单的中间件

使用方法

接受 WebSocket 请求

发送和接收消息

封装一个简单的中间件:

管理websocket连接

WebSocketManagerMiddleware类的封装

WebSocketHandler类的封装

使用我们写好的websocket管理中间件

中间件

热门文章

最新文章

相关课程

相关电子书

相关实验场景