我在尝试完成以下操作时使用Polly时遇到问题：

• 重新连接逻辑-我尝试创建一个Polly策略，当您尝试在没有Internet连接的情况下执行StartAsync时，该策略可以正常工作。但是，当它到达ReceiveLoop时，策略不再影响该方法，如果我们的连接在该点停止，它永远不会尝试重新连接。它只是抛出以下异常：Disconnected: The remote party closed the WebSocket connection without completing the close handshake.。也许我应该有两个策略：一个在StartAsync中，另一个在ReceiveLoop中，但出于某种原因，我感觉不对，所以这就是我问这个问题的原因。
• 超时-我想为每个ClientWebSocket方法调用添加超时。ConnectAsync、SendAsync等我对波莉不太熟悉，但我相信这项政策会自动为我们做到这一点。不过，我需要有人来证实。这里的timeout是指类似于_webSocket.ConnectAsync(_url, CancellationToken.None).TimeoutAfter(timeoutMilliseconds)的逻辑，TimeoutAfter的实现可以在这里找到。一个例子如何其他回购做到这一点可以在这里找到。

简单地说，我想让这个类具有弹性，这意味着无论原因是什么，它都应该快速失败-> 10秒后重试->快速失败->再次重试，以此类推，而不是尝试连接到一个死的Web Socket服务器30秒没有成功。这个 * 等待和重试逻辑 * 应该一直重复，直到我们调用StopAsync或释放示例。
您可以在GitHub上找到WebSocketDuplexPipe类。

public sealed class Client : IDisposable
{
    private const int RetrySeconds = 10;
    private readonly WebSocketDuplexPipe _webSocketPipe;
    private readonly string _url;

    public Client(string url)
    {
        _url = url;
        _webSocketPipe = new WebSocketDuplexPipe();
    }

    public Task StartAsync(CancellationToken cancellationToken = default)
    {
        var retryPolicy = Policy
            .Handle<Exception>(e => !cancellationToken.IsCancellationRequested)
            .WaitAndRetryForeverAsync(_ => TimeSpan.FromSeconds(RetrySeconds),
                (exception, calculatedWaitDuration) =>
                {
                    Console.WriteLine($"{exception.Message}. Retry in {calculatedWaitDuration.TotalSeconds} seconds.");
                });

        return retryPolicy.ExecuteAsync(async () =>
        {
            await _webSocketPipe.StartAsync(_url, cancellationToken).ConfigureAwait(false);
            _ = ReceiveLoop();
        });
    }

    public Task StopAsync()
    {
        return _webSocketPipe.StopAsync();
    }

    public async Task SendAsync(string data, CancellationToken cancellationToken = default)
    {
        var encoded = Encoding.UTF8.GetBytes(data);
        var bufferSend = new ArraySegment<byte>(encoded, 0, encoded.Length);
        await _webSocketPipe.Output.WriteAsync(bufferSend, cancellationToken).ConfigureAwait(false);
    }

    private async Task ReceiveLoop()
    {
        var input = _webSocketPipe.Input;

        try
        {
            while (true)
            {
                var result = await input.ReadAsync().ConfigureAwait(false);
                var buffer = result.Buffer;

                try
                {
                    if (result.IsCanceled)
                    {
                        break;
                    }

                    if (!buffer.IsEmpty)
                    {
                        while (MessageParser.TryParse(ref buffer, out var payload))
                        {
                            var message = Encoding.UTF8.GetString(payload);

                            _messageReceivedSubject.OnNext(message);
                        }
                    }

                    if (result.IsCompleted)
                    {
                        break;
                    }
                }
                finally
                {
                    input.AdvanceTo(buffer.Start, buffer.End);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Disconnected: {ex.Message}");
        }
    }
}