.net core 调用 websocket开发聊天功能

使用 .NET Core 可以很方便地实现 WebSocket 通信，以下是一个简单的示例：

1. 创建 WebSocket 控制器

在 .NET Core 中，可以通过继承 `Microsoft.AspNetCore.Mvc.ControllerBase` 来创建控制器。我们可以创建一个 `WebSocketController`，代码如下：

using Microsoft.AspNetCore.Mvc;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;

namespace YourNamespace.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WebSocketController : ControllerBase
    {
        private readonly WebSocketManager _webSocketManager;

        public WebSocketController(WebSocketManager webSocketManager)
        {
            _webSocketManager = webSocketManager;
        }

        [HttpGet("{id}")]
        public async Task Get(string id)
        {
            if (HttpContext.WebSockets.IsWebSocketRequest)
            {
                var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
                _webSocketManager.AddSocket(id, webSocket);
                await Receive(webSocket, async (result, buffer) =>
                {
                    if (result.MessageType == WebSocketMessageType.Text)
                    {
                        var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                        await _webSocketManager.SendMessageAsync(id, message);
                    }
                    else if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await _webSocketManager.RemoveSocketAsync(id);
                    }
                });
            }
            else
            {
                HttpContext.Response.StatusCode = 400;
            }
        }

        private async Task Receive(WebSocket webSocket, Action<WebSocketReceiveResult, byte[]> handleMessage)
        {
            var buffer = new byte[1024 * 4];
            while (webSocket.State == WebSocketState.Open)
            {
                var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
                handleMessage(result, buffer);
            }
        }
    }
}

在上面的代码中，我们首先判断 HTTP 请求是否是 WebSocket 请求，如果是，则接受 WebSocket 连接，并将 WebSocket 加入到 `WebSocketManager` 中。然后，我们使用 `Receive` 方法处理接收到的消息，并使用 `SendMessageAsync` 方法发送消息给客户端。如果收到关闭消息，我们将 WebSocket 从 `WebSocketManager` 中移除。

2. 创建 WebSocket 管理器

我们需要一个 WebSocket 管理器来管理所有的 WebSocket 连接。我们可以创建一个 `WebSocketManager` 类，代码如下：

using System.Collections.Concurrent;
using System.Net.WebSockets;
using System.Text;
using System.Threading.Tasks;

namespace YourNamespace
{
    public class WebSocketManager
    {
        private readonly ConcurrentDictionary<string, WebSocket> _sockets = new ConcurrentDictionary<string, WebSocket>();

        public void AddSocket(string id, WebSocket socket)
        {
            _sockets.TryAdd(id, socket);
        }

        public async Task SendMessageAsync(string id, string message)
        {
            if (_sockets.TryGetValue(id, out WebSocket socket))
            {
                var bytes = Encoding.UTF8.GetBytes(message);
                await socket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }

        public async Task RemoveSocketAsync(string id)
        {
            _sockets.TryRemove(id, out WebSocket socket);
            await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closed by the WebSocketManager", CancellationToken.None);
        }
    }
}

在上面的代码中，我们使用 `ConcurrentDictionary` 来存储所有的 WebSocket 连接。我们提供了 `AddSocket` 方法来添加 WebSocket 连接，`SendMessageAsync` 方法来发送消息给指定的 WebSocket 连接，`RemoveSocketAsync` 方法来移除指定的 WebSocket 连接。

3. 注册 WebSocket 控制器和 WebSocket 管理器

最后，我们需要在 `Startup.cs` 中注册 WebSocket 控制器和 WebSocket 管理器，代码如下：

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;

namespace YourNamespace
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton<WebSocketManager>();
            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseRouting();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

在上面的代码中，我们首先注册 `WebSocketManager` 类型的单例依赖，然后使用 `AddControllers` 方法来注册控制器。最后，我们使用 `MapControllers` 方法将控制器映射到路由。

现在，我们可以使用浏览器或其他 WebSocket 客户端连接到 `/WebSocket/{id}` 路径，并发送和接收消息了。