ASP.NET Core SignalR .NET-klient

Återanslut automatiskt

HubConnection kan konfigureras för att automatiskt återansluta med hjälp av metoden WithAutomaticReconnect på HubConnectionBuilder. Den återansluts inte automatiskt som standard.

HubConnection connection= new HubConnectionBuilder()
    .WithUrl(new Uri("http://127.0.0.1:5000/chathub"))
    .WithAutomaticReconnect()
    .Build();

Utan några parametrar WithAutomaticReconnect() konfigurerar klienten att vänta 0, 2, 10 respektive 30 sekunder innan varje återanslutningsförsök provas och stoppas efter fyra misslyckade försök.

Innan du startar några återanslutningsförsök kommer HubConnection övergå till tillståndet HubConnectionState.Reconnecting och utlösa händelsen Reconnecting. Detta ger en möjlighet att varna användarna om att anslutningen har gått förlorad och att inaktivera gränssnittselement. Icke-interaktiva appar kan börja köa eller släppa meddelanden.

connection.Reconnecting += error =>
{
    Debug.Assert(connection.State == HubConnectionState.Reconnecting);

    // Notify users the connection was lost and the client is reconnecting.
    // Start queuing or dropping messages.

    return Task.CompletedTask;
};

Om klienten återansluter inom de första fyra försöken HubConnection övergår den tillbaka till Connected tillståndet och utlöser Reconnected händelsen. Detta ger en möjlighet att informera användarna om att anslutningen har återupprättats och att eventuella köade meddelanden raderas.

Eftersom anslutningen framstår som helt ny för servern, kommer en ny ConnectionId att ges till Reconnected händelsehanterarna.

connection.Reconnected += connectionId =>
{
    Debug.Assert(connection.State == HubConnectionState.Connected);

    // Notify users the connection was reestablished.
    // Start dequeuing messages queued while reconnecting if any.

    return Task.CompletedTask;
};

WithAutomaticReconnect() kommer inte att konfigurera HubConnection för att försöka igen vid initiala startfel, så startfel måste hanteras manuellt:

public static async Task<bool> ConnectWithRetryAsync(HubConnection connection, CancellationToken token)
{
    // Keep trying to until we can start or the token is canceled.
    while (true)
    {
        try
        {
            await connection.StartAsync(token);
            Debug.Assert(connection.State == HubConnectionState.Connected);
            return true;
        }
        catch when (token.IsCancellationRequested)
        {
            return false;
        }
        catch
        {
            // Failed to connect, trying again in 5000 ms.
            Debug.Assert(connection.State == HubConnectionState.Disconnected);
            await Task.Delay(5000);
        }
    }
}

Om klienten inte återansluter inom de första fyra försöken HubConnection övergår den till Disconnected tillståndet och utlöser Closed händelsen. Detta ger möjlighet att försöka starta om anslutningen manuellt eller informera användarna om att anslutningen har förlorats permanent.

connection.Closed += error =>
{
    Debug.Assert(connection.State == HubConnectionState.Disconnected);

    // Notify users the connection has been closed or manually try to restart the connection.

    return Task.CompletedTask;
};

För att konfigurera ett anpassat antal återanslutningsförsök innan du kopplar från eller ändrar återanslutningstidpunkten accepterar WithAutomaticReconnect en matris med tal som representerar fördröjningen i millisekunder att vänta innan varje återanslutningsförsök startas.

HubConnection connection = new HubConnectionBuilder()
    .WithUrl(new Uri("http://127.0.0.1:5000/chathub"))
    .WithAutomaticReconnect(new[] { TimeSpan.Zero, TimeSpan.Zero, TimeSpan.FromSeconds(10) })
    .Build();

    // .WithAutomaticReconnect(new[] { TimeSpan.Zero, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }) yields the default behavior.

I föregående exempel konfigureras HubConnection för att börja försöka återansluta omedelbart efter att anslutningen har gått förlorad. Detta gäller även för standardkonfigurationen.

Om det första återanslutningsförsöket misslyckas startar även det andra återanslutningsförsöket omedelbart i stället för att vänta 2 sekunder som i standardkonfigurationen.

Om det andra återanslutningsförsöket misslyckas startar det tredje återanslutningsförsöket om 10 sekunder, vilket återigen liknar standardkonfigurationen.

Det anpassade beteendet avviker sedan igen från standardbeteendet genom att stoppa efter det tredje återanslutningsförsöksfelet. I standardkonfigurationen skulle det finnas ytterligare ett återanslutningsförsök på ytterligare 30 sekunder.

Om du vill ha ännu mer kontroll över tidpunkten och antalet automatiska återanslutningsförsök WithAutomaticReconnect godkänner du ett objekt som implementerar IRetryPolicy gränssnittet, som har en enda metod med namnet NextRetryDelay.

NextRetryDelay tar ett argument med typen RetryContext. RetryContext har tre egenskaper: PreviousRetryCount, ElapsedTime och RetryReason, som är en long, en TimeSpan och en Exception respektive. Före det första återanslutningsförsöket är båda PreviousRetryCount och ElapsedTime noll, och RetryReason kommer att vara undantaget som gjorde att anslutningen gick förlorad. Efter varje misslyckat återförsök PreviousRetryCount ökas med ett, ElapsedTime uppdateras för att återspegla den tid som lagts på att återansluta hittills, och RetryReason kommer att vara undantaget som orsakade att det senaste återanslutningsförsöket misslyckades.

NextRetryDelay måste returnera antingen ett TimeSpan som representerar tiden att vänta innan nästa återanslutningsförsök eller null om HubConnection ska sluta återansluta.

public class RandomRetryPolicy : IRetryPolicy
{
    private readonly Random _random = new Random();

    public TimeSpan? NextRetryDelay(RetryContext retryContext)
    {
        // If we've been reconnecting for less than 60 seconds so far,
        // wait between 0 and 10 seconds before the next reconnect attempt.
        if (retryContext.ElapsedTime < TimeSpan.FromSeconds(60))
        {
            return TimeSpan.FromSeconds(_random.NextDouble() * 10);
        }
        else
        {
            // If we've been reconnecting for more than 60 seconds so far, stop reconnecting.
            return null;
        }
    }
}

HubConnection connection = new HubConnectionBuilder()
    .WithUrl(new Uri("http://127.0.0.1:5000/chathub"))
    .WithAutomaticReconnect(new RandomRetryPolicy())
    .Build();

Du kan också skriva kod som återansluter klienten manuellt, vilket visas i Återanslut manuellt.