Prática recomendada para reconectar o cliente SignalR 2.0 .NET ao hub do servidor

Estou usando o SignalR 2.0 com o cliente .NET em um aplicativo móvel que precisa lidar com vários tipos de desconexões. Às vezes, o cliente SignalR se reconecta automaticamente - e às vezes ele precisa ser reconectado diretamente chamando HubConnection.Start()novamente.

Como o SignalR se reconecta automaticamente de forma mágica algumas vezes, estou me perguntando se estou perdendo um recurso ou definição de configuração.

Qual é a melhor maneira de configurar um cliente que se reconecta automaticamente?

Eu vi exemplos de javascript que manipulam o Closed()evento e, em seguida, Connect após n-segundos. Existe alguma abordagem recomendada?

Eu li a documentação e vários artigos sobre o tempo de vida das conexões SignalR, mas ainda não estou certo sobre como lidar com a reconexão do cliente.

Eu finalmente descobri isso. Aqui está o que aprendi desde o início desta pergunta:

Histórico: Estamos construindo um aplicativo iOS usando Xamarin / Monotouch e o cliente .NET SignalR 2.0.3. Estamos usando os protocolos SignalR padrão - e parece estar usando SSE em vez de web sockets. Ainda não tenho certeza se é possível usar sockets web com Xamarin / Monotouch. Tudo é hospedado usando sites do Azure.

Precisávamos que o aplicativo se reconectasse ao nosso servidor SignalR rapidamente, mas continuamos tendo problemas onde a conexão não se reconectava por conta própria - ou a reconexão demorava exatamente 30 segundos (devido a um tempo limite de protocolo subjacente).

Acabamos testando três cenários:

Cenário A - conectando na primeira vez que o aplicativo foi carregado. Isso funcionou perfeitamente desde o primeiro dia. A conexão é concluída em menos de 0,25 segundos, mesmo em conexões móveis 3G. (presumindo que o rádio já esteja ligado)

Cenário B - reconectar ao servidor SignalR após o aplicativo ficar inativo / fechado por 30 segundos. Nesse cenário, o cliente SignalR eventualmente se reconectará ao servidor por conta própria sem nenhum trabalho especial - mas parece esperar exatamente 30 segundos antes de tentar se reconectar. (muito lento para nosso aplicativo)

Durante esse período de espera de 30 segundos, tentamos chamar HubConnection.Start () que não teve efeito. E chamar HubConnection.Stop () também leva 30 segundos. Encontrei um bug relacionado no site SignalR que parece estar resolvido , mas ainda estamos tendo o mesmo problema na v2.0.3.

Cenário C - reconectando-se ao servidor SignalR após o aplicativo ficar inativo / fechado por 120 segundos ou mais. Nesse cenário, o protocolo de transporte SignalR já atingiu o tempo limite, portanto o cliente nunca se reconecta automaticamente. Isso explica por que o cliente às vezes, mas nem sempre se reconectava sozinho. A boa notícia é que chamar HubConnection.Start () funciona quase que instantaneamente como o cenário A.

Então, demorei um pouco para perceber que as condições de reconexão eram diferentes com base no fato de o aplicativo ter sido fechado por 30 segundos versus mais de 120 segundos. E embora os logs de rastreamento SignalR iluminem o que está acontecendo com o protocolo subjacente, não acredito que haja uma maneira de lidar com os eventos de nível de transporte no código. (o evento Closed () dispara após 30 segundos no cenário B, instantaneamente no cenário C; a propriedade State diz "Conectado" durante esses períodos de espera de reconexão; nenhum outro evento ou método relevante

Solução: a solução é óbvia. Não estamos esperando que o SignalR faça sua mágica de reconexão. Em vez disso, quando o aplicativo é ativado ou a conexão de rede do telefone é restaurada, estamos simplesmente limpando os eventos e retirando a referência do HubConnection (não podemos descartá-lo porque leva 30 segundos, espero que a coleta de lixo cuide disso ) e criando uma nova instância. Agora tudo está funcionando muito bem. Por algum motivo, pensei que deveríamos reutilizar uma conexão persistente e reconectar em vez de apenas criar uma nova instância.

Definir um cronômetro no evento desconectado para tentar reconectar automaticamente é o único método que conheço.

Em javascript, é feito assim:

$.connection.hub.disconnected(function() {
   setTimeout(function() {
       $.connection.hub.start();
   }, 5000); // Restart connection after 5 seconds.
});

Esta é a abordagem recomendada na documentação:

http://www.asp.net/signalr/overview/signalr-20/hubs-api/handling-connection-lifetime-events#clientdisconnect

Como o OP está pedindo um cliente .NET (uma implementação winform abaixo),

private async Task<bool> ConnectToSignalRServer()
{
    bool connected = false;
    try
    {
        Connection = new HubConnection("server url");
        Hub = Connection.CreateHubProxy("MyHub");
        await Connection.Start();

        //See @Oran Dennison's comment on @KingOfHypocrites's answer
        if (Connection.State == ConnectionState.Connected)
        {
            connected = true;
            Connection.Closed += Connection_Closed;
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
    return connected;
}

private async void Connection_Closed()
{   // A global variable being set in "Form_closing" event 
    // of Form, check if form not closed explicitly to prevent a possible deadlock.
    if(!IsFormClosed) 
    {
        // specify a retry duration
        TimeSpan retryDuration = TimeSpan.FromSeconds(30);
        DateTime retryTill = DateTime.UtcNow.Add(retryDuration);

        while (DateTime.UtcNow < retryTill)
        {
            bool connected = await ConnectToSignalRServer();
            if (connected)
                return;
        }
        Console.WriteLine("Connection closed")
    }
}

Eu adiciono alguma atualização para a resposta do ibubi . Pode ser que alguém precise. Descobri que em alguns casos o signalr não sobe no evento "fechado" após a reconexão ser interrompida. Eu resolvi isso usando o evento "StateChanged". Método que se conecta ao servidor SignalR:

private async Task<bool> ConnectToSignalRServer()
        {
            bool connected = false;
            try
            {
                var connection = new HubConnection(ConnectionUrl);
                var proxy = connection.CreateHubProxy("CurrentData");
                await connection.Start();

                if (connection.State == ConnectionState.Connected)
                {
                    await proxy.Invoke("ConnectStation");

                    connection.Error += (ex) =>
                    {
                        Console.WriteLine("Connection error: " + ex.ToString());
                    };
                    connection.Closed += () =>
                    {
                        Console.WriteLine("Connection closed");
                    };
                    connection.StateChanged += Connection_StateChanged;
                    Console.WriteLine("Server for Current is started.");
                    connected = true;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            return connected;
        }

Método para reconectar:

private async void Connection_StateChanged(StateChange obj)
        {
            if (obj.NewState == ConnectionState.Disconnected)
            {
                await RestartConnection();
            }
        }

Método de tentativas intermináveis ​​de conexão com o servidor (também uso este método para criar a primeira conexão):

public async Task RestartConnection()
        {
            while (!ApplicationClosed)
            {
                bool connected = await ConnectToSignalRServer();
                if (connected)
                    return;
            }
        }

Você pode tentar invocar o método do servidor do seu android antes de iniciar o estado de reconexão para evitar o problema de reconexão mágica.

SignalR Hub C #

 public class MyHub : Hub
    {
        public void Ping()
        {
            //ping for android long polling
        }
 }

No Android

private final int PING_INTERVAL = 10 * 1000;

private boolean isConnected = false;
private HubConnection connection;
private ClientTransport transport;
private HubProxy hubProxy;

private Handler handler = new Handler();
private Runnable ping = new Runnable() {
    @Override
    public void run() {
        if (isConnected) {
            hubProxy.invoke("ping");
            handler.postDelayed(ping, PING_INTERVAL);
        }
    }
};

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    System.setProperty("http.keepAlive", "false");

    .....
    .....

    connection.connected(new Runnable() {
        @Override
        public void run() {
            System.out.println("Connected");
            handler.postDelayed(ping, PING_INTERVAL);
    });
}