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，我添加了public async Task HeartBeat(DateTime now) => await Clients.All.InvokeAsync("Heartbeat", now);

显然，计时器、正在发送的数据(我只是发送一个DateTime)和客户端方法名称都可能不同。

更新。净核心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.ioke("HeartBeatTock")；}connection.start().then(args=>{heartBeatTockTimer=setInterval(sendHeartBeatTock，10000)；})；

例如，浏览器挂起IO后，invoke方法将抛出一个异常-由于它是异步的，因此无法通过简单的try/catch捕获该异常。我试图为我的心跳Tock做的是类似(伪代码)：

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

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

• 定期向客户端发送消息
• 按此处所述更改IIS中的空闲超时设置
• 如果连接关闭，请在客户端重新启动连接
• 使用不同的传输(例如，长轮询，因为您不能在IIS后面的Win7/Win2008 R2上使用webSockets)

Answer 2

我现在有了一个有效的解决方案(到目前为止已经在Chrome和FF中进行了测试)。我在这里发布了我的解决方案：

上面的问题中描述了心跳-"滴答"消息(服务器定期ping客户端)。客户端("Tock"部分)现在有：

• 一个注册连接的函数，以便可以重复回调方法(connection.on())；它们在重新启动"新集线器连接"后就会丢失，否则
• 注册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);
});
}

Answer 3

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