由于Task.WhenAny，Polly不會處理任務中的例外

當我們的連接斷開時，ReceiveAsync正在拋出WebSocketException( ex.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely)。

問題是由于某種原因它沒有由 Polly 處理。Task我相信它不能處理它，因為它在一個單獨的Task.WhenAny.

如果WebSocketException拋出，預期的行為是觸發重新連接。

public sealed class ChannelWebSocketClient : IDisposable
{
    private readonly Uri _uri;
    private readonly ILogger<ChannelWebSocketClient> _logger;
    private readonly Channel<string> _output;
    private CancellationTokenSource? _cancellationTokenSource;

    public ChannelWebSocketClient(Uri uri, ILoggerFactory loggerFactory)
    {
        _uri = uri ?? throw new ArgumentNullException(nameof(uri));
        _logger = loggerFactory.CreateLogger<ChannelWebSocketClient>();

        _output = Channel.CreateUnbounded<string>(new UnboundedChannelOptions
        {
            SingleReader = true,
            SingleWriter = false
        });
    }

    public void Dispose()
    {
        _output.Writer.TryComplete();
    }

    public Task StartAsync()
    {
        return Policy.Handle<Exception>(ex => ex is not (TaskCanceledException or OperationCanceledException))
            .WaitAndRetryForeverAsync(
                (_, _) => TimeSpan.FromSeconds(5),
                (ex, retryCount, calculatedWaitDuration, _) => { _logger.LogError(ex, "Unable to connect to the web socket server. Retry count: {RetryCount} | Retry in {Seconds} seconds", retryCount, calculatedWaitDuration.TotalSeconds); })
            .ExecuteAsync(ConnectAsync);
    }

    public void Stop()
    {
        _cancellationTokenSource?.Cancel();
    }

    private async Task ConnectAsync()
    {
        _logger.LogDebug("Connecting");

        using var ws = new ClientWebSocket();

        // WebSocketException, TaskCanceledException
        await ws.ConnectAsync(_uri, CancellationToken.None).ConfigureAwait(false);

        _logger.LogDebug("Connected to {Host}", _uri.AbsoluteUri);

        _cancellationTokenSource = new CancellationTokenSource();

        var receiving = ReceiveLoopAsync(ws, _cancellationTokenSource.Token);
        var sending = SendLoopAsync(ws, _cancellationTokenSource.Token);

        var trigger = await Task.WhenAny(receiving, sending).ConfigureAwait(false);

        if (trigger == receiving)
        {
            _cancellationTokenSource?.Cancel();

            await sending.ConfigureAwait(false);
        }

        _logger.LogDebug("END");
    }

    public async Task SendAsync(string message)
    {
        await _output.Writer.WriteAsync(message, CancellationToken.None).ConfigureAwait(false);
    }

    private async Task SendLoopAsync(WebSocket webSocket, CancellationToken cancellationToken)
    {
        _logger.LogDebug("SendLoopAsync BEGIN");

        try
        {
            while (await _output.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
            {
                while (_output.Reader.TryRead(out var message))
                {
                    // WebSocketException, TaskCanceledException, ObjectDisposedException
                    await webSocket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(message)),
                        WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
                }
            }
        }
        catch (OperationCanceledException)
        {
        }
        finally
        {
            _logger.LogDebug("SendLoopAsync END");
        }
    }

    private async Task ReceiveLoopAsync(WebSocket webSocket, CancellationToken cancellationToken)
    {
        _logger.LogDebug("ReceiveLoopAsync BEGIN");

        try
        {
            while (true)
            {
                ValueWebSocketReceiveResult receiveResult;

                using var buffer = MemoryPool<byte>.Shared.Rent(4096);
                await using var ms = new MemoryStream(buffer.Memory.Length);
                do
                {
                    // WebSocketException, TaskCanceledException, ObjectDisposedException
                    receiveResult = await webSocket.ReceiveAsync(buffer.Memory, cancellationToken).ConfigureAwait(false);

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

                    await ms.WriteAsync(buffer.Memory[..receiveResult.Count], cancellationToken).ConfigureAwait(false);
                } while (!receiveResult.EndOfMessage);

                ms.Seek(0, SeekOrigin.Begin);

                if (receiveResult.MessageType == WebSocketMessageType.Text)
                {
                    using var reader = new StreamReader(ms, Encoding.UTF8);
                    var message = await reader.ReadToEndAsync().ConfigureAwait(false);

                    _logger.LogInformation("Message received: {Message}", message);
                }
                else if (receiveResult.MessageType == WebSocketMessageType.Close)
                {
                    break;
                }
            }
        }
        catch (WebSocketException ex) when (ex.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely)
        {
            _logger.LogError(ex, "");
            throw;
        }
        finally
        {
            _logger.LogDebug("ReceiveLoopAsync END");
        }
    }
}

uj5u.com熱心網友回復：

Task.WhenAll 作品不同于Task.WhenAny. _

• 前拋出例外是任何因例外而失敗的任務
• 即使所有任務都失敗，后者也不會拋出例外

所以要么你使用 call two 兩次，.GetAwaiter().GetResult()因為WhenAny回傳 aTask<Task>

Task.WhenAny(receiving, sending).ConfigureAwait(false)
   .GetAwaiter().GetResult()
   .GetAwaiter().GetResult();

或者你可以重新拋出例外

var trigger = await Task.WhenAny(receiving, sending).ConfigureAwait(false);
if (trigger.Exception != null)
{
    throw trigger.Exception;
}

這些解決方案都不是完美的，但它們會觸發您的策略。

更新#1

正如默索先生指出的那樣，您可以打電話兩次await

await await Task.WhenAny(receiving, sending).ConfigureAwait(false);

這比上述兩種方法要好得多。

更新#2

如果你想

• 如果更快的任務失敗則觸發策略
• 或者想知道哪一個成功完成得更快

那么你可以“避免”雙重await

var trigger = await Task.WhenAny(receiving, sending).ConfigureAwait(false); 

await trigger; //Throws exception if the faster Task has failed

if (trigger == receiving) //Determines which Task finished sooner
{

}

標籤：C＃ 。网 波莉

上一篇：RegEx：找到所有評論但不在引號內

下一篇：如何將多個串列框selectedItems獲取到網格