Client .NET SignalR ASP.NET Core

Se reconnecter automatiquement

La HubConnection peut être configurée pour se reconnecter automatiquement à l’aide de la méthode WithAutomaticReconnect sur le HubConnectionBuilder. Elle ne se reconnectera pas automatiquement par défaut.

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

Sans aucun paramètre, WithAutomaticReconnect() configure le client pour attendre 0, 2, 10 et 30 secondes respectivement avant chaque tentative de reconnexion. Il s'arrête après quatre tentatives échouées.

Avant de tenter quelconque reconnexion, la HubConnection passe à l’état HubConnectionState.Reconnecting et déclenche l’événement Reconnecting. Cela permet d'avertir les utilisateurs que la connexion a été perdue et de désactiver les éléments de l'IU. Les applications non interactives peuvent commencer à mettre des messages en file d’attente ou à les annuler.

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

Si le client se reconnecte avec succès lors de ses quatre premières tentatives, la HubConnection revient à l'état Connected et déclenche l’événement Reconnected. Cela permet d'informer les utilisateurs que la connexion a été rétablie et d’éliminer les messages dans la file d’attente.

Étant donné que la connexion paraît entièrement nouvelle pour le serveur, une nouvelle ConnectionId est fournie aux gestionnaires d'événements Reconnected.

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() ne configure pas la HubConnection pour retenter les échecs de démarrage initial. Les échecs de démarrage doivent donc être gérés manuellement :

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

Si le client ne parvient pas à se reconnecter lors de ses quatre premières tentatives, la HubConnection passe à l'état Disconnected et déclenche l’événement Closed. Cela permet de tenter le redémarrage manuel de la connexion ou d’informer les utilisateurs que la connexion est définitivement perdue.

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

Afin de configurer un nombre personnalisé de tentatives de reconnexion avant de se déconnecter ou de modifier le délai de reconnexion, WithAutomaticReconnect accepte un tableau de nombres représentant le délai d’attente en millisecondes avant de démarrer chaque tentative de reconnexion.

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.

L'exemple précédent configure le HubConnection pour qu'il commence à tenter des reconnexions immédiatement après la perte de la connexion. Ceci est également vrai pour la configuration par défaut.

Si la première tentative de reconnexion échoue, la deuxième tentative de reconnexion démarrera également immédiatement au lieu d'attendre 2 secondes comme dans la configuration par défaut.

Si la deuxième tentative de reconnexion échoue, la troisième tentative de reconnexion démarre après 10 secondes, encore comme dans la configuration par défaut.

Le comportement personnalisé s’écarte à nouveau du comportement par défaut en s’arrêtant après l’échec de la troisième tentative de reconnexion. La configuration par défaut lancerait une autre tentative de reconnexion après 30 secondes.

Si vous souhaitez encore plus de contrôle sur la synchronisation et le nombre de tentatives de reconnexion automatique, WithAutomaticReconnect accepte un objet qui implémente l'interface IRetryPolicy, laquelle a une seule méthode nommée NextRetryDelay.

NextRetryDelay prend un seul argument de type RetryContext. Le RetryContext a trois propriétés : PreviousRetryCount, ElapsedTime et RetryReason, qui sont respectivement un long, un TimeSpan et une Exception. Avant la première tentative de reconnexion, PreviousRetryCount et ElapsedTime sont à zéro, et la RetryReason est l’exception ayant entraîné la perte de la connexion. Après chaque tentative échouée, PreviousRetryCount est augmenté d’une unité, ElapsedTime est mis à jour pour illustrer le temps de reconnexion jusqu'à présent et RetryReason est l'exception ayant entraîné l'échec de la dernière tentative de reconnexion.

NextRetryDelay doit renvoyer soit un TimeSpan correspondant au temps d’attente avant la prochaine tentative de reconnexion, ou null si la HubConnection doit cesser de se reconnecter.

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

Vous pouvez également écrire du code qui reconnecte manuellement votre client, comme illustré dans Reconnexion manuelle.