Client .NET di ASP.NET Core SignalR

Riconnettersi automaticamente

L'oggetto HubConnection può essere configurato per riconnettersi automaticamente usando il WithAutomaticReconnect metodo in HubConnectionBuilder. Per impostazione predefinita, la riconnessione non verrà riconnessa automaticamente.

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

Senza parametri, WithAutomaticReconnect() configura il client per attendere rispettivamente 0, 2, 10 e 30 secondi prima di provare ogni tentativo di riconnessione, interrompendo dopo quattro tentativi non riusciti.

Prima di avviare qualsiasi tentativo di riconnessione, passerà HubConnection allo HubConnectionState.Reconnecting stato e genererà l'evento Reconnecting . In questo modo è possibile avvisare gli utenti che la connessione è stata persa e di disabilitare gli elementi dell'interfaccia utente. Le app non interattive possono avviare l'accodamento o eliminare messaggi.

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

Se il client si riconnette correttamente entro i primi quattro tentativi, l'oggetto HubConnection eseguirà la transizione allo Connected stato e attiverà l'evento Reconnected . In questo modo è possibile informare gli utenti che la connessione è stata ristabilita e annullare la coda di eventuali messaggi in coda.

Poiché la connessione sembra completamente nuova per il server, verrà fornito Reconnected un nuovo ConnectionId gestore eventi.

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() non configurerà per HubConnection ripetere gli errori di avvio iniziale, quindi gli errori di avvio devono essere gestiti manualmente:

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

Se il client non si riconnette correttamente entro i primi quattro tentativi, HubConnection passerà allo Disconnected stato e attiverà l'evento Closed . In questo modo è possibile tentare di riavviare la connessione manualmente o informare gli utenti che la connessione è stata persa definitivamente.

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

Per configurare un numero personalizzato di tentativi di riconnessione prima di disconnettersi o modificare l'intervallo di riconnessione, WithAutomaticReconnect accetta una matrice di numeri che rappresenta il ritardo in millisecondi di attesa prima di avviare ogni tentativo di riconnessione.

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.

Nell'esempio precedente viene configurato l'oggetto HubConnection per avviare il tentativo di riconnessione immediatamente dopo la perdita della connessione. Questo vale anche per la configurazione predefinita.

Se il primo tentativo di riconnessione ha esito negativo, il secondo tentativo di riconnessione verrà avviato immediatamente anziché attendere 2 secondi come nella configurazione predefinita.

Se il secondo tentativo di riconnessione ha esito negativo, il terzo tentativo di riconnessione verrà avviato in 10 secondi, come la configurazione predefinita.

Il comportamento personalizzato si differenzia quindi di nuovo dal comportamento predefinito arrestando dopo il terzo tentativo di riconnessione. Nella configurazione predefinita ci sarebbe un altro tentativo di riconnessione in altri 30 secondi.

Se si vuole un maggiore controllo sulla tempistica e sul numero di tentativi di riconnessione automatica, WithAutomaticReconnect accetta un oggetto che implementa l'interfaccia IRetryPolicy , che ha un singolo metodo denominato NextRetryDelay.

NextRetryDelay accetta un singolo argomento con il tipo RetryContext. Ha RetryContext tre proprietà: PreviousRetryCount, ElapsedTime e RetryReason, che sono rispettivamente , longe TimeSpan .Exception Prima del primo tentativo di riconnessione, entrambi PreviousRetryCount e ElapsedTime saranno zero e RetryReason sarà l'eccezione che ha causato la perdita della connessione. Dopo ogni tentativo di ripetizione non riuscito, PreviousRetryCount verrà incrementato di uno, ElapsedTime verrà aggiornato in modo da riflettere la quantità di tempo impiegato per la riconnessione fino a questo momento e RetryReason sarà l'eccezione che ha causato l'ultimo tentativo di riconnessione non riuscito.

NextRetryDelay deve restituire un timeSpan che rappresenta il tempo di attesa prima del tentativo di riconnessione successivo o null se deve interrompere la HubConnection riconnessione.

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

In alternativa, è possibile scrivere codice che riconnetterà il client manualmente, come illustrato in Riconnettersi manualmente.