SignalR 2.0 .NET istemcisini sunucu hub'ına yeniden bağlamak için en iyi uygulama

Bir mobil uygulamada .NET istemcisi ile SignalR 2.0 kullanıyorum ve çeşitli bağlantı kesme türlerini ele alması gerekiyor. Bazen SignalR istemcisi otomatik olarak yeniden bağlanır - ve bazen HubConnection.Start()tekrar arayarak doğrudan yeniden bağlanması gerekir .

SignalR bazen sihirli bir şekilde otomatik olarak yeniden bağlandığından, bir özelliği mi yoksa yapılandırma ayarını mı kaçırdığımı merak ediyorum.

Otomatik olarak yeniden bağlanan bir istemci kurmanın en iyi yolu nedir?

Closed()Olayı işleyen javascript örnekleri gördüm ve ardından n saniye sonra Bağlan. Önerilen herhangi bir yaklaşım var mı?

Okuduğum belgelerine ve SignalR bağlantılarının ömrü hakkında çeşitli makaleler, ama yine de istemci yeniden bağlanma nasıl ele alınacağı üzerinde anlamış değilim.

Sonunda bunu çözdüm. İşte bu soruya başladığımdan beri öğrendiklerim:

Arka plan: Xamarin / Monotouch ve .NET SignalR 2.0.3 istemcisini kullanarak bir iOS uygulaması oluşturuyoruz. Varsayılan SignalR protokollerini kullanıyoruz - ve web soketleri yerine SSE kullanıyor gibi görünüyor. Xamarin / Monotouch ile web soketlerini kullanmanın mümkün olup olmadığından henüz emin değilim. Her şey Azure web siteleri kullanılarak barındırılır.

Uygulamanın SignalR sunucumuza hızlı bir şekilde yeniden bağlanmasına ihtiyacımız vardı, ancak bağlantının kendi kendine yeniden bağlanmadığı veya yeniden bağlanmanın tam olarak 30 saniye sürdüğü (temel protokol zaman aşımından dolayı) sorunlar yaşamaya devam ettik.

Test ettiğimiz üç senaryo vardı:

Senaryo A - uygulama ilk yüklendiğinde bağlanma. Bu, ilk günden itibaren kusursuz bir şekilde çalıştı. Bağlantı, 3G mobil bağlantılarda bile .25 saniyeden daha kısa sürede tamamlanır. (radyonun zaten açık olduğunu varsayarak)

Senaryo B - uygulama 30 saniye boşta kaldıktan / kapatıldıktan sonra SignalR sunucusuna yeniden bağlanma. Bu senaryoda, SignalR istemcisi sonunda herhangi bir özel çalışma olmaksızın sunucuya kendi başına yeniden bağlanacaktır - ancak yeniden bağlanmayı denemeden önce tam olarak 30 saniye beklediği görülmektedir. (uygulamamız için çok yavaş)

Bu 30 saniyelik bekleme süresi boyunca, etkisi olmayan HubConnection.Start () 'ı çağırmayı denedik. HubConnection.Stop () 'u çağırmak da 30 saniye sürer. SignalR sitesinde çözülmüş gibi görünen ilgili bir hata buldum , ancak v2.0.3'te hala aynı sorunu yaşıyoruz.

Senaryo C - uygulama 120 saniye veya daha uzun süre boşta kaldıktan / kapatıldıktan sonra SignalR sunucusuna yeniden bağlanma. Bu senaryoda, SignalR aktarım protokolü zaten zaman aşımına uğradı, bu nedenle istemci asla otomatik olarak yeniden bağlanmaz. Bu, müşterinin neden bazen ancak her zaman kendi kendine yeniden bağlantı kurduğunu açıklar. İyi haber, HubConnection.Start () 'ı çağırmak neredeyse anında senaryo A gibi çalışır.

Bu nedenle, uygulamanın 30 saniyeye karşı 120 saniyeden fazla kapalı olmasına bağlı olarak yeniden bağlanma koşullarının farklı olduğunu anlamam biraz zaman aldı. Ve SignalR izleme günlükleri temeldeki protokolde neler olup bittiğini aydınlatsa da, koddaki taşıma düzeyi olaylarını ele almanın bir yolu olduğuna inanmıyorum. (Closed () olayı, senaryo B'de 30 saniye sonra, C senaryosunda anında tetiklenir; State özelliği, bu yeniden bağlanma bekleme süreleri sırasında "Bağlı" der; başka ilgili olay veya yöntem yoktur)

Çözüm: Çözüm ortada. SignalR'ın yeniden bağlanma sihrini yapmasını beklemiyoruz. Bunun yerine, uygulama etkinleştirildiğinde veya telefonun ağ bağlantısı geri yüklendiğinde, yalnızca olayları temizliyoruz ve HubConnection referansını kaldırıyoruz (30 saniye sürdüğü için onu atamıyoruz, umarım çöp toplama işi halleder. ) ve yeni bir örnek oluşturma. Şimdi her şey harika çalışıyor. Bazı nedenlerden dolayı, sadece yeni bir örnek oluşturmak yerine kalıcı bir bağlantıyı yeniden kullanmamız ve yeniden bağlanmamız gerektiğini düşündüm.

Bildiğim tek yöntem, bağlantısız olayda otomatik olarak yeniden bağlanmayı denemek için bir zamanlayıcı ayarlamak.

JavaScript'te şu şekilde yapılır:

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

Dokümantasyonda önerilen yaklaşım budur:

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

OP bir .NET istemcisi istediğinden (aşağıdaki bir winform uygulaması),

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

İbubi cevabı için bazı güncellemeler ekledim . Birinin buna ihtiyacı olabilir. Bazı durumlarda, tekrar bağlantı durdurulduktan sonra sinyalin "kapalı" olayı yükselmediğini buldum. "StateChanged" olayını kullanarak çözdüm. SignalR sunucusuna bağlanan yöntem:

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

Yeniden bağlanma yöntemi:

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

Sunucuya sonsuz bağlanma girişimleri yöntemi (Ayrıca ilk bağlantı oluşturmak için bu yöntemi kullanıyorum):

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

Sihirli yeniden bağlanma sorununu önlemek için yeniden bağlanma durumu başlamadan önce androidinizden sunucu yöntemini çağırmayı deneyebilirsiniz.

SignalR Hub C #

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

Android'de

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