8

只是要预先明确,这个问题是关于 .Net Core SignalR,而不是以前的版本。

新的 SignalR 与 IIS 后面的 WebSockets 存在问题(我无法让它们在 Chrome/Win7/IIS express 上工作)。因此,我使用的是服务器发送事件 (SSE)。但是,问题是大约 2 分钟后超时,连接状态从 2 变为 3。自动重新连接已被删除(显然在以前的版本中它并不能很好地工作)。

我现在想实现一个心跳计时器来阻止客户端超时,每 30 秒一次的滴答声就可以完成这项工作。

11 月 10 日更新

我现在已经设法实现服务器端 Heartbeat,基本上取自 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,我添加了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>();
  • 客户
    var connection = new signalR.HubConnection("/signalr", { transport: signalR.TransportType.ServerSentEvents });
    connection.on("Heartbeat", serverTime => { console.log(serverTime); });

初始问题的剩余部分

剩下的是如何正确地重新连接客户端,例如在 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"...)——这看起来很傻。

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

4

3 回答 3

2

这是在 IIS 后面运行 SignalR Core 时出现的问题。IIS 将在 2 分钟后关闭空闲连接。长期计划是添加保持活动消息,作为副作用,这将阻止 IIS 关闭连接。要暂时解决此问题,您可以:

  • 定期向客户端发送消息
  • 按照此处所述更改 IIS 中的空闲超时设置
  • 如果连接关闭,则在客户端重新启动连接
  • 使用不同的传输方式(例如长轮询,因为您不能在 IIS 后面的 Win7/Win2008 R2 上使用 webSockets)
于 2017-11-09T19:18:39.150 回答
1

基于 ExternalUse 的答案的客户端版本...

import * as signalR from '@aspnet/signalr'
import _ from 'lodash'

var connection = null;
var sendHandlers = [];
var addListener = f => sendHandlers.push(f);

function registerSignalRConnection() {

    if (connection !== null) {
        connection.stop().catch(err => console.log(err));
    }

    connection = new signalR.HubConnectionBuilder()
        .withUrl('myHub')
        .build();

    connection.on("Heartbeat", serverTime =>
        console.log("Server heartbeat: " + serverTime));

    connection.on("Send", data =>
        _.each(sendHandlers, value => value(data)));

    connection.start()
        .catch(exception =>
            console.log("Error connecting", exception, connection));
}

registerSignalRConnection();

setInterval(() =>
    connection.invoke("HeartBeatTock")
        .then(() => console.log("Client heatbeat."))
        .catch(err => {    
            registerSignalRConnection();
        }), 10 * 1000);

export { addListener };
于 2018-12-03T00:35:13.377 回答
1

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

上述问题中描述了 Heartbeat-“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);
     });
 }
于 2017-11-12T13:06:34.497 回答