ASP.NET Core SignalR .NET-Client

Automatisches Wiederverbinden

HubConnection kann so konfiguriert werden, dass die Verbindung mithilfe der WithAutomaticReconnect-Methode für HubConnectionBuilder automatisch wiederhergestellt wird. Standardmäßig wird die Verbindung nicht automatisch wiederhergestellt.

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

Ohne Parameter wird der Client durch WithAutomaticReconnect() so konfiguriert, dass er 0, 2, 10 bzw. 30 Sekunden wartet, ehe er einen Widerverbindungsversuch unternimmt, und nach vier fehlgeschlagenen Versuchen beendet wird.

Ehe ein Wiederverbindungsversuch gestartet wird, geht HubConnection in den Zustand HubConnectionState.Reconnecting über und löst das Ereignis Reconnecting aus. Dies bietet die Möglichkeit, Benutzer zu warnen, dass die Verbindung unterbrochen wurde, und Benutzeroberflächenelemente zu deaktivieren. Nicht interaktive Apps können Nachrichten in die Warteschlange stellen oder löschen.

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;
};

Wenn der Client die Verbindung bei den ersten vier Versuchen erfolgreich wiederherstellt, geht HubConnection wieder in den Zustand Connected über und löst das Ereignis Reconnected aus. Dies bietet die Möglichkeit, Benutzern mitzuteilen, dass die Verbindung wiederhergestellt wurde, und alle Nachrichten aus der Warteschlange zu entfernen.

Da die Verbindung für den Server völlig neu aussieht, wird für die Reconnected-Ereignishandler ein neues ConnectionId-Ereignis bereitgestellt.

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;
};

Durch WithAutomaticReconnect() wird HubConnection nicht für eine Wiederholung nach anfänglichen Startfehlern konfiguriert, weshalb Startfehler manuell behandelt werden müssen:

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);
        }
    }
}

Wenn der Client die Verbindung bei den ersten vier Versuchen nicht erfolgreich wiederherstellt, geht HubConnection in den Zustand Disconnected über und löst das Ereignis Closed aus. Dadurch haben Sie die Möglichkeit, zu versuchen, die Verbindung manuell neu zu starten oder Benutzer zu informieren, dass die Verbindung dauerhaft unterbrochen wurde.

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;
};

Um eine benutzerdefinierte Anzahl von Wiederverbindungsversuchen zu konfigurieren, bevor die Verbindung getrennt wird, oder um den Zeitpunkt der Wiederverbindung zu ändern, akzeptiert WithAutomaticReconnect ein Array von Zahlen, die die Verzögerung in Millisekunden angeben, die gewartet werden soll, ehe die einzelnen Wiederverbindungsversuche gestartet werden.

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.

Im vorhergehenden Beispiel wird HubConnection so konfiguriert, dass sofort nach Unterbrechung der Verbindung ein neuer Verbindungsversuch unternommen wird. Dies gilt auch für die Standardkonfiguration.

Wenn der erste Wiederverbindungsversuch fehlschlägt, wird der zweite Wiederverbindungsversuch ebenfalls sofort gestartet, anstatt wie in der Standardkonfiguration zwei Sekunden zu warten.

Wenn der zweite Wiederverbindungsversuch fehlschlägt, wird der dritte Wiederverbindungsversuch nach 10 Sekunden gestartet, was wiederum der Standardkonfiguration entspricht.

Das benutzerdefinierte Verhalten weicht dann erneut vom Standardverhalten ab, da nach dem dritten fehlgeschlagenen Wiederverbindungsversuch der Vorgang abgebrochen wird. Die Standardkonfiguration sieht einen weiteren Wiederverbindungsversuch nach weiteren 30 Sekunden vor.

Wenn Sie noch mehr Kontrolle über Zeitpunkt und Anzahl der automatischen Wiederverbindungsversuche wünschen, akzeptiert WithAutomaticReconnect ein Objekt, das die IRetryPolicy-Schnittstelle implementiert, die eine einzige Methode namens NextRetryDelay hat.

NextRetryDelay akzeptiert ein einzelnes Argument mit dem Typ RetryContext. RetryContext hat drei Eigenschaften: PreviousRetryCount, ElapsedTime und RetryReason, die jeweils long, TimeSpan und Exception bedeuten. Vor dem ersten Wiederverbindungsversuch sind sowohl PreviousRetryCount als auch ElapsedTime 0, und RetryReason ist die Ausnahme, die den Verbindungsabbruch verursacht hat. Nach jedem fehlgeschlagenen Wiederverbindungsversuch wird PreviousRetryCount um 1 erhöht. ElapsedTime wird aktualisiert, um die bisher für den Wiederverbindungsversuch aufgewendete Zeit wiederzugeben, und RetryReason ist die Ausnahme, die den letzten Wiederverbindungsversuch fehlschlagen ließ.

NextRetryDelay muss entweder einen TimeSpan-Wert mit der Zeit zurückgeben, die bis zum nächsten Wiederverbindungsversuch gewartet werden muss, oder null, wenn HubConnection den Wiederverbindungsversuch abbrechen soll.

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();

Alternativ können Sie Code schreiben, der die Verbindung mit Ihrem Client manuell wiederherstellt, wie unter Manuelles Wiederverbinden gezeigt.