SignalR C# Client StartAsync() CancellationToken not respected

[Kolky]

Is there an existing issue for this?

• I have searched the existing issues

Describe the bug

Similar to #10059. I have a Client application (WPF .NET6) that uses the DI-framework which hosts a service on the background that connects to a SignalR hub. The cancellationtoken seems to not be respected and never finishes my task and thus blocks my application from exiting.

Expected Behavior

I would expect that I receive a TaskCanceledException.

Steps To Reproduce

To reproduce this you should have your SignalR server turned off (I don't think you even need a server!). In the below example the "await" start-task never finishes.

Example client code:

    internal class ServerProxy : IHostedService
    {
        private readonly HubConnection _connection;
        private readonly CancellationTokenSource _cts = new();
        private Task _startTask;

        public ServerProxy(IConfiguration configuration)
        {
            _connection = new HubConnectionBuilder()
                .WithUrl($"{configuration.GetValue<string>("ServerBaseAddress")}/messages")
                .WithAutomaticReconnect()
                .Build();
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _startTask = _connection.StartAsync(_cts.Token);
            return Task.CompletedTask;
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (_startTask != null && !_startTask.IsCompleted)
            {
                _cts.Cancel();
                try
                {
                    await _startTask;
                }
                catch (TaskCanceledException)
                {
                    // Do nothing
                }
            }

            if (_connection.State == HubConnectionState.Connected)
            {
                await _connection.StopAsync();
                await _connection.DisposeAsync();
            }
        }
    }

Exceptions (if any)

n/a

.NET Version

6.0.100

Anything else?

Using the Package "Microsoft.AspNetCore.SignalR.Client" Version="6.0.1".

[Kolky]

Here is a minimal example that reproduces it;
ConsoleApp2.zip

It has something to do with it being hosted & stopped from within a WPF application that runs on a STAThread.

[BrennanConroy]

I tried a super simple 6.0 WPF app and cannot reproduce the issue, I get a TaskCanceledException when clicking the Stop button.

public partial class MainWindow : Window
{
    private HubConnection _hubConnection;
    private CancellationTokenSource cts = new CancellationTokenSource();
    private Task _startTask;

    public MainWindow()
    {
        InitializeComponent();
    }

    private void Button_Click_Start(object sender, RoutedEventArgs e)
    {
        _hubConnection = new HubConnectionBuilder()
            .WithUrl("https://localhost:5000/default")
            .WithAutomaticReconnect()
            .Build();

        _startTask = _hubConnection.StartAsync(cts.Token);
    }

    private async void Button_Click_Stop(object sender, RoutedEventArgs e)
    {
        cts.Cancel();
        try
        {
            await _startTask;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

Please provide a simple repro app in the form of a GitHub repo (not a zip).

Hi @Kolky. We have added the "Needs: Author Feedback" label to this issue, which indicates that we have an open question for you before we can take further action. This issue will be closed automatically in 7 days if we do not hear back from you by then - please feel free to re-open it if you come back to this issue after that time.

[Kolky]

@BrennanConroy I made a repo out of my zip: https://github.com/Kolky/signalr-bug

[BrennanConroy]

Ok, so you're running the server and the client in the same process and since you're using WPF you are running in a "single-threaded" environment. What this means is that when you stop the server via exiting the app, you run on the UI thread and block any asynchronous work also running on the UI thread from completing. In this case you run Example.StopAsync() inline and hang your app.

I don't know the proper way to handle async work in WPF, but a quick fix is to replace _host.WaitForShutdown() with Task.Run(() => _host.WaitForShutdownAsync().ConfigureAwait(false)).ConfigureAwait(false).GetAwaiter().GetResult();

[adityamandaleeka]

Sounds like this isn't a SignalR issue, so I'll mark this as resolved.