网络游戏开发-服务器（01）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(), //向客户端发送“ping”帧的频率，以确保代理保持连接处于打开状态
ReceiveBufferSize = * 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 = ;
}
}
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[ * ];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
await webSocket.SendAsync(new ArraySegment<byte>(buffer, , 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[ * ]; 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: , 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(),
ReceiveBufferSize = *
};
app.UseWebSockets(webSocketOptions);
app.MapWebSocketManager("/zhajinhua", serviceProvider.GetService<ZjhGame>());

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

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

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

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