ASP.NET Core SignalR .NET client

Automatisch opnieuw verbinding maken

De HubConnection kan worden geconfigureerd om automatisch opnieuw verbinding te maken met behulp van de WithAutomaticReconnect methode op de HubConnectionBuilder. Standaard wordt er niet automatisch opnieuw verbinding gemaakt.

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

Zonder parameters configureert WithAutomaticReconnect() de client om respectievelijk 0, 2, 10 en 30 seconden te wachten voordat elke poging om opnieuw verbinding te maken, stopt na vier mislukte pogingen.

Voordat u opnieuw verbinding probeert te maken, wijzigt de HubConnection naar de HubConnectionState.Reconnecting-status en wordt de Reconnecting-gebeurtenis geactiveerd. Dit biedt de mogelijkheid om gebruikers te waarschuwen dat de verbinding is verbroken en om UI-elementen uit te schakelen. Niet-interactieve apps kunnen beginnen met het in wachtrij plaatsen of verwijderen van berichten.

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

Als de client opnieuw verbinding maakt binnen de eerste vier pogingen, gaat de HubConnection client terug naar de Connected status en wordt de Reconnected gebeurtenis geactiveerd. Dit biedt de mogelijkheid om gebruikers te informeren dat de verbinding opnieuw tot stand is gebracht en om berichten uit de wachtrij te halen.

Omdat de verbinding er op de server volledig nieuw uitziet, wordt er een nieuwe ConnectionId verstrekt aan de Reconnected gebeurtenis-handlers.

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() configureert de HubConnection niet om initiële startfouten opnieuw uit te voeren. Startfouten moeten dus handmatig worden afgehandeld:

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

Als de client niet succesvol opnieuw verbinding maakt binnen de eerste vier pogingen, verandert de HubConnection naar de Disconnected-toestand en wordt de Closed gebeurtenis afgevuurd. Dit biedt de mogelijkheid om de verbinding handmatig opnieuw op te starten of gebruikers te informeren dat de verbinding permanent verloren is gegaan.

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

Als u een aangepast aantal nieuwe verbindingspogingen wilt configureren voordat u de tijdsinstellingen voor opnieuw verbinden verbreekt of wijzigt, accepteert WithAutomaticReconnect een matrix met getallen die de vertraging in milliseconden vertegenwoordigen om te wachten voordat elke poging voor opnieuw verbinden wordt gestart.

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.

In het voorgaande voorbeeld wordt de HubConnection geconfigureerd om opnieuw verbinding te maken direct nadat de verbinding is verbroken. Dit geldt ook voor de standaardconfiguratie.

Als de eerste poging om opnieuw verbinding te maken mislukt, wordt de tweede poging om opnieuw verbinding te maken ook onmiddellijk gestart in plaats van 2 seconden te wachten, net zoals in de standaardconfiguratie.

Als de tweede poging om opnieuw verbinding te maken mislukt, wordt de derde poging om opnieuw verbinding te maken binnen 10 seconden gestart, wat weer lijkt op de standaardconfiguratie.

Het aangepaste gedrag wijkt vervolgens opnieuw af van het standaardgedrag door te stoppen na de derde mislukte poging om opnieuw verbinding te maken. In de standaardconfiguratie is er nog een poging om opnieuw verbinding te maken in een andere 30 seconden.

Als u nog meer controle wilt over de timing en het aantal pogingen om automatisch opnieuw verbinding te maken, accepteert WithAutomaticReconnect een object dat de IRetryPolicy-interface implementeert, met één methode met de naam NextRetryDelay.

NextRetryDelay gebruikt één argument met het type RetryContext. De RetryContext heeft drie eigenschappen: PreviousRetryCount, ElapsedTime en RetryReason, die respectievelijk een long, een TimeSpan en een Exception zijn. Voordat de eerste poging wordt ondernomen om opnieuw verbinding te maken, zullen zowel PreviousRetryCount als ElapsedTime nul zijn, en RetryReason zal de uitzondering zijn die ervoor zorgde dat de verbinding verloren is gegaan. Na elke mislukte poging wordt PreviousRetryCount met één verhoogd, ElapsedTime wordt bijgewerkt met de hoeveelheid tijd die tot nu toe aan het opnieuw verbinden is besteed en RetryReason zal de uitzondering zijn die de vorige poging tot opnieuw verbinden heeft doen falen.

NextRetryDelay moet een TimeSpan-object retourneren dat de tijd aangeeft die moet worden gewacht voor de volgende poging om opnieuw verbinding te maken, of null als de HubConnection object moet stoppen met opnieuw proberen verbinding te maken.

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

U kunt ook code schrijven waarmee uw client handmatig opnieuw wordt verbonden, zoals wordt weergegeven in Handmatig opnieuw verbinding maken.