.Net Core SignalR-连接超时-心跳计时器-连接状态更改处理

Question

只是要事先弄清楚，这个问题是关于.Net Core SignalR的，而不是以前的版本。

新的SignalR在IIS后面的WebSockets出现问题（我无法让它们在Chrome / Win7 / IIS Express上运行）。因此，我使用服务器发送事件（SSE）。但是，问题在于大约2分钟后那些超时，连接状态从2变为3。自动重新连接已被删除（显然，在以前的版本中，它的运行情况并不理想）。

我现在想实现一个心跳计时器，以阻止客户端超时，每30秒滴答一滴就可以很好地完成工作。

11月10日更新

我现在设法实现了服务器端心跳信号，该信号基本上取自Ricardo Peres的https://weblogs.asp.net/ricardoperes/signalr-in-asp-net-core

• 在startup.cs中，添加到 public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider serviceProvider)

    app.UseSignalR(routes =>  
    {  
        routes.MapHub<TheHubClass>("signalr");  
    });

    TimerCallback SignalRHeartBeat = async (x) => {   
    await serviceProvider.GetService<IHubContext<TheHubClass>>().Clients.All.InvokeAsync("Heartbeat", DateTime.Now); };
    var timer = new Timer(SignalRHeartBeat).Change(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(30));            

• HubClass

对于HubClass，我添加了 public async Task HeartBeat(DateTime now) => await Clients.All.InvokeAsync("Heartbeat", now);

显然，计时器，正在发送的数据（我只是在发送DateTime）和客户端方法名称都可以不同。

更新.Net Core 2.1+

见下面的评论；计时器回调不应再使用。现在，我实现了一个IHostedService（或更确切地说是抽象BackgroundService）来做到这一点：

public class HeartBeat : BackgroundService
{
    private readonly IHubContext<SignalRHub> _hubContext;
    public HeartBeat(IHubContext<SignalRHub> hubContext)
    {
        _hubContext = hubContext;
    }
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _hubContext.Clients.All.SendAsync("Heartbeat", DateTime.Now, stoppingToken);
            await Task.Delay(30000, stoppingToken);
        }            
    }
}

在启动类中，将其连接到以下位置services.AddSignalR();：

services.AddHostedService<HeartBeat>();

• 客户

public class HeartBeat : BackgroundService
{
    private readonly IHubContext<SignalRHub> _hubContext;
    public HeartBeat(IHubContext<SignalRHub> hubContext)
    {
        _hubContext = hubContext;
    }
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _hubContext.Clients.All.SendAsync("Heartbeat", DateTime.Now, stoppingToken);
            await Task.Delay(30000, stoppingToken);
        }            
    }
}

剩余的最初问题

剩下的是如何正确重新连接客户端，例如，在IO暂停后（浏览器的计算机进入睡眠状态，失去连接，更改了Wifi或其他功能）

我实现了一个客户端心跳，该心跳正常运行，至少直到连接断开为止：

• 集线器类别： public async Task HeartBeatTock() => await Task.CompletedTask;

• 客户：

  var heartBeatTockTimer; 函数sendHeartBeatTock（）{connection.invoke（“ HeartBeatTock”）; } connection.start（）。then（args => {heartBeatTockTimer = setInterval（sendHeartBeatTock，10000）;}）;

例如，在浏览器挂起IO后，invoke方法将引发异常-由于它是异步的，因此无法通过简单的try / catch捕获。我为HeartBeatTock尝试执行的操作类似于（伪代码）：

function sendHeartBeatTock
    try connection.invoke("HeartbeatTock)
    catch exception
         try connection.stop()
         catch exception (and ignore it)
         finally
              connection = new HubConnection().start()
    repeat try connection.invoke("HeartbeatTock")
    catch exception
        log("restart did not work")
        clearInterval(heartBeatTockTimer)
        informUserToRefreshBrowser()

现在，由于某些原因，此方法不起作用。由于异步运行，代码块执行后，invoke引发异常。看起来好像公开了.catch（）方法，但是我不确定如何正确地实现我的想法。另一个原因是，开始新连接将需要我重新实现所有服务器调用，例如“ connection.on（“ send” ...）-看起来很愚蠢。

关于如何正确实现重新连接客户端的任何提示将不胜感激。

Answer 1

我现在有了一个可行的解决方案（到目前为止已在 Chrome 和 FF 中进行了测试）。为了激励您想出更好的东西，或者在您自己想出类似的东西时节省一点时间，我在这里发布我的解决方案：

心跳“Tick”消息（服务器例行 ping 客户端）在上面的问题中进行了描述。客户端（“Tock”部分）现在拥有：

• 注册连接的函数，以便可以重复回调方法（connection.on()）；否则，在重新启动“新的 HubConnection”后它们就会丢失
• 注册TockTimer的函数
• 以及一个实际发送 Tock ping 的函数

tock 方法在发送时捕获错误，并尝试启动新连接。由于计时器持续运行，我正在注册一个新连接，然后只需坐下来等待下一次调用。将客户端放在一起：

// keeps the connection object
var connection = null;
// stores the ID from SetInterval
var heartBeatTockTimer = 0;
// how often should I "tock" the server
var heartBeatTockTimerSeconds = 10;
// how often should I retry after connection loss?
var maxRetryAttempt = 5;
// the retry should wait less long then the TockTimer, or calls may overlap
var retryWaitSeconds = heartBeatTockTimerSeconds / 2;
// how many retry attempts did we have?
var currentRetryAttempt = 0;
// helper function to wait a few seconds
$.wait = function(miliseconds) {
    var defer = $.Deferred();
    setTimeout(function() { defer.resolve(); }, miliseconds);
    return defer;
};
// first routine start of the connection
registerSignalRConnection();
function registerSignalRConnection() {
    ++currentRetryAttempt;
    if (currentRetryAttempt > maxRetryAttempt) {
        console.log("Clearing registerHeartBeatTockTimer");
        clearInterval(heartBeatTockTimer);
        heartBeatTockTimer = 0;
        throw "Retry attempts exceeded.";
    }
    if (connection !== null) {
        console.log("registerSignalRConnection was not null", connection);
        connection.stop().catch(err => console.log(err));
    }
    console.log("Creating new connection");
    connection = new signalR.HubConnection("/signalr", { transport: signalR.TransportType.ServerSentEvents });
    connection.on("Heartbeat", serverTime => { console.log(serverTime); });
    connection.start().then(() => {
        console.log("Connection started, starting timer.");
        registerHeartBeatTockTimer();
    }).catch(exception => {
        console.log("Error connecting", exception, connection);
    });
}
function registerHeartBeatTockTimer() {
    // make sure we're registered only once
    if (heartBeatTockTimer !== 0) return;
    console.log("Registering registerHeartBeatTockTimer");
    if (connection !== null)
        heartBeatTockTimer = setInterval(sendHeartBeatTock, heartBeatTockTimerSeconds * 1000);
    else
        console.log("Connection didn't allow registry");
}

function sendHeartBeatTock() {
    console.log("Standard attempt HeartBeatTock");
    connection.invoke("HeartBeatTock").then(() => { 
         console.log("HeartbeatTock worked.") })
         .catch(err => {
             console.log("HeartbeatTock Standard Error", err);
             $.wait(retryWaitSeconds * 1000).then(function() {
                 console.log("executing attempt #" + currentRetryAttempt.toString());
             registerSignalRConnection();
         });
         console.log("Current retry attempt: ", currentRetryAttempt);
     });
 }