主页 / 问题 / 1589002
Accepted
Alexander
Asked:2024-07-31 17:44:28 +0000 UTC2024-07-31 17:44:28 +0000 UTC

C# 中的 WebSocketClient

  • 772

我正在学习 Blazor。我遇到了一个问题 - 你需要有一个不断运行的 websocket 客户端，当收到消息时，它将将它们广播到网页，并根据页面中的命令将某些内容发送到服务器。

找到的所有示例都归结为这样一个事实：他们创建了一个客户端，连接到回显服务器，发送消息，读取响应并完成工作。

我做了什么：我用这个任务创建了一个连接到服务器并循环等待消息的任务。读取后，只是将其输出到日志中。我做了一个发送消息的函数。看起来还不错。

我将其发布在 Program.cs 中，它连接、监听，一切似乎都很好，但我无法从 *.razor 调用发送函数 - CS8801

我将所有内容转移到 .razoz，基于页面中的事件，调用 runWS（之后要调用 sendWS） - websocket 客户端连接，但随后，从逻辑上讲，它等待来自服务器的消息，但有没有消息——我们挂着，我们等待。

@code{
    private static ClientWebSocket ws;

    private static async Task DoClientWebSocket()
    {
        using ( ws = new ClientWebSocket())
        {
            Uri serverUri = new Uri("wss://echo.websocket.org/");

            await ws.ConnectAsync(serverUri, CancellationToken.None);

            while (ws.State == WebSocketState.Open )
            {
                //Receive buffer
                var receiveBuffer = new byte[2048];
                //Multipacket response
                var offset = 0;
                var dataPerPacket = 1024; //Just for example

                while (true)
                {
                    ArraySegment<byte> bytesReceived =
                                    new ArraySegment<byte>(receiveBuffer, offset, dataPerPacket);
                    WebSocketReceiveResult result = await ws.ReceiveAsync(bytesReceived,
                                                                        source.Token);
                    offset += result.Count;
                    if (result.EndOfMessage)
                        break;
                }
                Console.WriteLine("\nWS message: {0}",
                                    Encoding.UTF8.GetString(receiveBuffer, 0,
                                                                offset));
            }
        }
    }


    public async Task runWS()
    {
        var taskWebConnect = Task.Run(() => DoClientWebSocket());

        taskWebConnect.Wait();
    }



    public async Task sendWS(string text)
    {
        ArraySegment<byte> arraySegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes( text ));
        await ws.SendAsync(arraySegment, System.Net.WebSockets.WebSocketMessageType.Text, true, CancellationToken.None);
    }

    
}

告诉我如何并行运行任务？通过网页中的事件，或者在应用程序启动时立即执行。

c#

1 个回答

  1. Best Answer

    使用静态 ClientWebSocket 和静态方法可能会导致可为 null 不一致，因为静态成员无权访问 Blazor 组件实例状态，可能会引发错误 CS8801

    客户端必须异步处理消息而不阻塞主 UI 线程

    使用异步方法连续连接和接收消息，这样 UI 就不会冻结等待数据

    我稍微调整了你的解决方案并进行了各种测试，将流程显示在页面上

    using System.Net.WebSockets;
using System.Text;

namespace SomeProjectTestSocket.Services
{
    public class WebSocketClientService
    {
        private ClientWebSocket _webSocket;

        public event Action<string> OnMessageReceived;
        public event Action<string> OnStatusChanged;

        public async Task ConnectAsync(Uri serverUri, CancellationToken cancellationToken)
        {
            _webSocket = new ClientWebSocket();
            try
            {
                await _webSocket.ConnectAsync(serverUri, cancellationToken);
                OnStatusChanged?.Invoke("Connected");
                await ReceiveMessagesAsync(cancellationToken);
            }
            catch (Exception ex)
            {
                OnStatusChanged?.Invoke($"Error: {ex.Message}");
            }
        }

        private async Task ReceiveMessagesAsync(CancellationToken cancellationToken)
        {
            var buffer = new byte[2048];
            while (_webSocket.State == WebSocketState.Open)
            {
                try
                {
                    var result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancellationToken);
                    if (result.MessageType == WebSocketMessageType.Text)
                    {
                        var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                        OnMessageReceived?.Invoke(message);
                        OnStatusChanged?.Invoke($"Received message: {message}");
                    }
                    else if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken);
                        OnStatusChanged?.Invoke("Closed");
                    }
                }
                catch (Exception ex)
                {
                    OnStatusChanged?.Invoke($"Error: {ex.Message}");
                    break;
                }
            }
        }

        public async Task SendMessageAsync(string message, CancellationToken cancellationToken)
        {
            if (_webSocket.State == WebSocketState.Open)
            {
                var buffer = Encoding.UTF8.GetBytes(message);
                await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, cancellationToken);
                OnStatusChanged?.Invoke($"Sent message: {message}");
            }
            else
            {
                OnStatusChanged?.Invoke("WebSocket is not open");
            }
        }
    }
}

    @page "/websocket"
@inject WebSocketClientService WebSocketService

<h3>WebSocket Example</h3>

<button @onclick="ConnectWebSocket">Connect</button>
<button @onclick="SendMessage">Send Message</button>

<p>Received message: @_receivedMessage</p>
<p>Status: @_statusMessage</p>

@code {
    private string _receivedMessage;
    private string _statusMessage;

    protected override void OnInitialized()
    {
        WebSocketService.OnMessageReceived += (message) =>
        {
            InvokeAsync(() =>
            {
                _receivedMessage = message;
                StateHasChanged();
            });
        };

        WebSocketService.OnStatusChanged += (status) =>
        {
            InvokeAsync(() =>
            {
                _statusMessage = status;
                StateHasChanged();
            });
        };
    }

    private async Task ConnectWebSocket()
    {
        _statusMessage = "Connecting...";
        await WebSocketService.ConnectAsync(new Uri("wss://ws.ifelse.io"), CancellationToken.None);
    }

    private async Task SendMessage()
    {
        _statusMessage = "Sending message...";
        await WebSocketService.SendMessageAsync("Hello, WebSocket!", CancellationToken.None);
    }
}

    builder.Services.AddSingleton<WebSocketClientService>();

    在此输入图像描述

    还有有用的信息：

    1. wss://ws.ifelse.io - 流行的回显服务器。
    2. wss://echo.websocket.org - 最常用的回显服务器之一，但最近可能不可用。
    3. wss://demos.kaazing.com/echo - Kaazing 的 Echo 服务器，也广泛用于演示和测试。
    4. wss://echo.websocket.events — 由 websocket.events 服务提供的 Echo 服务器。
    5. wss://ws.postman-echo.com/raw - Postman 服务还提供了一个 echo 服务器，非常适合测试 WebSocket 连接。

    使用回显服务器时，请务必记住，其中一些服务器可能暂时不可用，或者由于安全策略或服务器负载而受到限制。因此，如果其中一台服务器没有响应，建议尝试另一台服务器。 （例如昨天其中一个在测试时没有反应）

    • 0

相关问题