.net core websocket

.NET Core WebSocket是一种基于WebSocket协议的实时通信技术，它可以在客户端和服务器之间建立持久性连接，实现双向通信。它是.NET Core框架的一部分，可以在跨平台的环境下运行，支持多种操作系统和开发语言。使用.NET Core WebSocket可以轻松地构建实时应用程序，如聊天室、游戏、在线协作等。

相关问题

来一段.net 6 Websocket 聊天功能代码，并且附带.net core客户端代码

好的，下面是一个简单的使用 .NET 6 的 WebSocket 实现聊天室功能的代码示例：

服务端代码：

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.Collections.Concurrent;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class ChatRoom
{
    private readonly ConcurrentDictionary<string, WebSocket> _sockets = new ConcurrentDictionary<string, WebSocket>();
    private readonly ILogger<ChatRoom> _logger;

    public ChatRoom(ILogger<ChatRoom> logger)
    {
        _logger = logger;
    }

    public async Task HandleWebSocketAsync(HttpContext context)
    {
        if (!context.WebSockets.IsWebSocketRequest)
        {
            context.Response.StatusCode = 400;
            return;
        }

        WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();

        string socketId = Guid.NewGuid().ToString();
        _sockets.TryAdd(socketId, webSocket);

        _logger.LogInformation($"WebSocket {socketId} connected");

        try
        {
            await HandleIncomingMessageAsync(webSocket, socketId);
        }
        finally
        {
            _sockets.TryRemove(socketId, out _);
            await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "WebSocket closed", CancellationToken.None);

            _logger.LogInformation($"WebSocket {socketId} disconnected");
        }
    }

    private async Task HandleIncomingMessageAsync(WebSocket webSocket, string socketId)
    {
        byte[] buffer = new byte[1024 * 4];

        while (webSocket.State == WebSocketState.Open)
        {
            WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

            if (result.MessageType == WebSocketMessageType.Close)
            {
                break;
            }

            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);

            _logger.LogInformation($"WebSocket {socketId} received message: {message}");

            await BroadcastMessageAsync(message, socketId);
        }
    }

    private async Task BroadcastMessageAsync(string message, string excludeSocketId)
    {
        foreach (KeyValuePair<string, WebSocket> pair in _sockets)
        {
            if (pair.Key != excludeSocketId && pair.Value.State == WebSocketState.Open)
            {
                await pair.Value.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }
    }
}

public static class ChatRoomExtensions
{
    public static IApplicationBuilder UseChatRoom(this IApplicationBuilder app)
    {
        return app.Use(async (context, next) =>
        {
            if (context.Request.Path == "/chat")
            {
                ChatRoom chatRoom = context.RequestServices.GetService(typeof(ChatRoom)) as ChatRoom;
                await chatRoom.HandleWebSocketAsync(context);
            }
            else
            {
                await next();
            }
        });
    }
}

客户端代码：

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

public class ChatClient : IDisposable
{
    private readonly ClientWebSocket _webSocket = new ClientWebSocket();

    public async Task ConnectAsync(Uri uri)
    {
        await _webSocket.ConnectAsync(uri, CancellationToken.None);
        Console.WriteLine("Connected to WebSocket server");

        Task receiveTask = ReceiveAsync();

        while (_webSocket.State == WebSocketState.Open)
        {
            string message = Console.ReadLine();

            byte[] buffer = Encoding.UTF8.GetBytes(message);
            await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
        }

        await receiveTask;
    }

    private async Task ReceiveAsync()
    {
        byte[] buffer = new byte[1024 * 4];

        while (_webSocket.State == WebSocketState.Open)
        {
            WebSocketReceiveResult result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

            if (result.MessageType == WebSocketMessageType.Close)
            {
                break;
            }

            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            Console.WriteLine(message);
        }
    }

    public async Task DisconnectAsync()
    {
        await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "WebSocket closed", CancellationToken.None);
        Console.WriteLine("Disconnected from WebSocket server");
    }

    public void Dispose()
    {
        _webSocket.Dispose();
    }
}

使用方法：

在 ASP.NET Core 应用程序的 `Startup.cs` 文件中调用 `UseChatRoom()` 扩展方法，将 `/chat` 路径映射到 `ChatRoom` 类：

app.UseChatRoom();

在客户端代码中创建 `ChatClient` 实例，然后调用 `ConnectAsync()` 方法连接到 WebSocket 服务器：

ChatClient client = new ChatClient();
await client.ConnectAsync(new Uri("ws://localhost:5000/chat"));

当用户在控制台中输入文本时，调用 `SendAsync()` 方法将文本发送到服务器：

string message = Console.ReadLine();
await client.SendAsync(message);

当用户想要断开连接时，调用 `DisconnectAsync()` 方法断开连接：

await client.DisconnectAsync();

.net 新建WebSocket程序

.NET 中创建WebSocket程序主要是在.NET Core或.NET 5/6等较新版本中进行的，因为WebSocket API 在这些版本中得到了更好的支持。以下是使用.NET Core创建WebSocket服务器端的一个基本示例：

1. 创建一个新的ASP.NET Core项目，可以使用Visual Studio或命令行工具。
2. 在项目中添加必要的NuGet包，如`Microsoft.AspNetCore.WebSockets`。
3. 配置WebSocket中间件，在`Startup.cs`中的`Configure`方法中添加WebSocket服务。
4. 实现WebSocket处理器，处理WebSocket连接、接收消息和发送消息。

以下是一个简单的示例代码：

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.UseWebSockets(); // 启用WebSocket功能

        app.Use(async (context, next) =>
        {
            if (context.WebSockets.IsWebSocketRequest)
            {
                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
                await Echo(context, webSocket);
            }
            else
            {
                await next();
            }
        });

        app.Run(async (context) =>
        {
            await context.Response.WriteAsync("Hello World!");
        });
    }
}

private async Task Echo(HttpContext context, WebSocket webSocket)
{
    byte[] 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 ?? string.Empty, CancellationToken.None);
}

在上面的代码中，`Echo`方法是一个简单的回声服务器，它接收客户端通过WebSocket发送的消息，并将相同的消息发送回客户端。它会一直运行，直到连接被关闭。

要测试WebSocket服务，你需要一个能够连接并交换消息的WebSocket客户端。可以使用浏览器中的JavaScript来测试，或者使用任何支持WebSocket的第三方客户端工具。