SignalRASP.NET Core Cliente de .NET

Volver a conectar automáticamente

se HubConnection puede configurar para volver a conectarse automáticamente mediante el método en WithAutomaticReconnect HubConnectionBuilder . No se volverá a conectar automáticamente de forma predeterminada.

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

Sin ningún parámetro, configura el cliente para esperar 0, 2, 10 y 30 segundos respectivamente antes de intentar cada intento de reconexión, deteniéndose después de cuatro WithAutomaticReconnect() intentos fallidos.

Antes de iniciar los intentos de reconexión, HubConnection pasará al estado y se HubConnectionState.Reconnecting desenlazará el Reconnecting evento. Esto proporciona una oportunidad para advertir a los usuarios de que se ha perdido la conexión y deshabilitar los elementos de la interfaz de usuario. Las aplicaciones no interactivas pueden iniciar la puesta en cola o la colocación de mensajes.

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 el cliente se vuelve a conectar correctamente dentro de sus cuatro primeros intentos, volverá a pasar HubConnection al estado y se Connected desenlazará el Reconnected evento. Esto proporciona una oportunidad para informar a los usuarios de que la conexión se ha restablecido y quitar de la cola los mensajes en cola.

Puesto que la conexión parece completamente nueva para el servidor, se proporciona un nuevo a ConnectionId los controladores Reconnected de eventos.

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() no configurará para reintentar los errores de inicio iniciales, por lo que los errores de inicio deben HubConnection controlarse 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);
        }
    }
}

Si el cliente no se vuelve a conectar correctamente dentro de sus cuatro primeros intentos, el pasará al estado y HubConnection Disconnected se desenlazará el Closed evento. Esto proporciona una oportunidad para intentar reiniciar la conexión manualmente o informar a los usuarios de que la conexión se ha perdido permanentemente.

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

Para configurar un número personalizado de intentos de reconexión antes de desconectarse o cambiar el tiempo de reconexión, acepta una matriz de números que representa el retraso en milisegundos que se debe esperar antes de iniciar cada intento de WithAutomaticReconnect reconexión.

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.

En el ejemplo anterior se configura para HubConnection que empiece a intentar volver a conectarse inmediatamente después de que se pierda la conexión. Esto también se aplica a la configuración predeterminada.

Si se produce un error en el primer intento de reconexión, el segundo intento de reconexión también se iniciará inmediatamente en lugar de esperar 2 segundos como lo haría en la configuración predeterminada.

Si se produce un error en el segundo intento de reconexión, el tercer intento de reconexión se iniciará en 10 segundos, que es de nuevo como la configuración predeterminada.

A continuación, el comportamiento personalizado difiere de nuevo del comportamiento predeterminado al detenerse después del tercer error de intento de reconexión. En la configuración predeterminada, habría un intento de reconexión más en otros 30 segundos.

Si desea tener aún más control sobre el tiempo y el número de intentos de reconexión automática, acepta un objeto que implementa la interfaz , que tiene WithAutomaticReconnect un único método denominado IRetryPolicy NextRetryDelay .

NextRetryDelay toma un único argumento con el tipo RetryContext . tiene RetryContext tres propiedades: PreviousRetryCount , y , que son , y , y , ElapsedTime RetryReason long TimeSpan Exception respectivamente. Antes del primer intento de reconexión, y serán cero, y será la excepción que hizo que PreviousRetryCount se perdiera la ElapsedTime RetryReason conexión. Después de cada intento de reintento con error, se incrementará en uno, se actualizará para reflejar la cantidad de tiempo invertido en volver a conectarse hasta ahora y será la excepción que hizo que se produjese un error en el último intento de PreviousRetryCount ElapsedTime RetryReason reconexión.

NextRetryDelay debe devolver un TimeSpan que representa el tiempo de espera antes del siguiente intento de reconexión o si debe dejar de volver a null HubConnection conectarse.

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

Como alternativa, puede escribir código que vuelva a conectar el cliente manualmente, como se muestra en Volver a conectar manualmente.