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

本文涉及的产品
服务治理 MSE Sentinel/OpenSergo,Agent数量 不受限
简介: 服务器开发- 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 请求。

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

新建一个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

目录
相关文章
|
5天前
|
JSON 数据格式
【虚幻引擎】DTWebSocketServer 蓝图创建WebSocket服务器插件使用说明
该插件用于创建和管理WebSocket服务器,支持通过蓝图创建服务器、监听端口并接收响应。主要功能包括:创建服务器、绑定各种回调函数(用户连接、断开、发送消息时触发)、关闭服务器、获取所有用户、获取用户数据、向用户发送消息及主动关闭用户连接。示例和下载链接在原文中提供。
39 2
|
5天前
|
开发框架 前端开发 JavaScript
盘点72个ASP.NET Core源码Net爱好者不容错过
盘点72个ASP.NET Core源码Net爱好者不容错过
80 0
|
5天前
|
开发框架 .NET
ASP.NET Core NET7 增加session的方法
ASP.NET Core NET7 增加session的方法
43 0
|
4天前
|
网络协议 JavaScript 前端开发
WebSocket:实现客户端与服务器实时通信的技术
WebSocket:实现客户端与服务器实时通信的技术
|
4天前
|
网络协议 JavaScript 前端开发
将websocket封装成一个class,断线可重连
将websocket封装成一个class,断线可重连
|
5天前
|
网络协议 网络安全 数据安全/隐私保护
KOI websocket服务器转发请求给 orchestra - 什么是 Client Address
KOI websocket服务器转发请求给 orchestra - 什么是 Client Address
6 0
|
5天前
|
Web App开发 JavaScript 前端开发
KOI Orchestra 从微服务提供商获得结果,再发送回 WebSocket 服务器
KOI Orchestra 从微服务提供商获得结果,再发送回 WebSocket 服务器
6 0
|
5天前
|
开发框架 前端开发 JavaScript
JavaScript云LIS系统源码ASP.NET CORE 3.1 MVC + SQLserver + Redis医院实验室信息系统源码 医院云LIS系统源码
实验室信息系统(Laboratory Information System,缩写LIS)是一类用来处理实验室过程信息的软件,云LIS系统围绕临床,云LIS系统将与云HIS系统建立起高度的业务整合,以体现“以病人为中心”的设计理念,优化就诊流程,方便患者就医。
23 0
|
5天前
|
JSON JavaScript 前端开发
服务器通信:使用WebSocket与后端实时交互
【4月更文挑战第24天】WebSocket为解决服务器与客户端实时双向通信问题而生,常用于聊天、游戏和实时通知等场景。本文通过4步教你实现WebSocket通信:1) 客户端使用JavaScript创建WebSocket连接;2) 监听`open`、`message`和`close`事件;3) 使用`send`方法发送数据;4) 使用`close`方法关闭连接。服务器端则需处理连接和数据发送,具体实现依后端技术而定。WebSocket为现代Web应用的实时交互提供了强大支持。
|
5天前
|
开发框架 中间件 .NET
C# .NET面试系列七:ASP.NET Core
## 第一部分:ASP.NET Core #### 1. 如何在 controller 中注入 service? 在.NET中,在ASP.NET Core应用程序中的Controller中注入服务通常使用<u>依赖注入(Dependency Injection)</u>来实现。以下是一些步骤,说明如何在Controller中注入服务: 1、创建服务 首先,确保你已经在应用程序中注册了服务。这通常在Startup.cs文件的ConfigureServices方法中完成。例如: ```c# services.AddScoped<IMyService, MyService>(); //
100 0