Detect dead connections with SignalR

Question

SignalR version: SignalR 2.4.1

.Net Framework version: 4.8 (I am not using .Net Core)

SignalR transport: websockets

I am developing a background service for SignalR (PresenceMonitor) where I need to detect whether a connection with specific clientid is alive or not. I am using the following code for Presence Monitor to start with what I want to achieve:

using System;
using System.Data.Entity.SqlServer;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using Microsoft.AspNet.SignalR.Transports;

namespace UserPresence
{
    /// <summary>
    /// This class keeps track of connections that the <see cref="UserTrackingHub"/>
    /// has seen. It uses a time based system to verify if connections are *actually* still online.
    /// Using this class combined with the connection events SignalR raises will ensure
    /// that your database will always be in sync with what SignalR is seeing.
    /// </summary>
    public class PresenceMonitor
    {
        private readonly ITransportHeartbeat _heartbeat;
        private Timer _timer;

        // How often we plan to check if the connections in our store are valid
        private readonly TimeSpan _presenceCheckInterval = TimeSpan.FromSeconds(10);

        // How many periods need pass without an update to consider a connection invalid
        private const int periodsBeforeConsideringZombie = 3;

        // The number of seconds that have to pass to consider a connection invalid.
        private readonly int _zombieThreshold;

        public PresenceMonitor(ITransportHeartbeat heartbeat)
        {
            _heartbeat = heartbeat;
            _zombieThreshold = (int)_presenceCheckInterval.TotalSeconds * periodsBeforeConsideringZombie;
        }

        public void StartMonitoring()
        {
            if (_timer == null)
            {
                _timer = new Timer(_ =>
                {
                    try
                    {
                        Check();
                    }
                    catch (Exception ex)
                    {
                        // Don't throw on background threads, it'll kill the entire process
                        Trace.TraceError(ex.Message);
                    }
                }, 
                null, 
                TimeSpan.Zero, 
                _presenceCheckInterval);
            }
        }

        private void Check()
        {
            using (var db = new UserContext())
            {
                // Get all connections on this node and update the activity
                foreach (var trackedConnection in _heartbeat.GetConnections())
                {
                    if (!trackedConnection.IsAlive)
                    {
                        continue;
                    }

                    Connection connection = db.Connections.Find(trackedConnection.ConnectionId);

                    // Update the client's last activity
                    if (connection != null)
                    {
                        connection.LastActivity = DateTimeOffset.UtcNow;
                    }
                    else
                    {
                        // We have a connection that isn't tracked in our DB!
                        // This should *NEVER* happen
                        // Debugger.Launch();
                    }
                }

                // Now check all db connections to see if there's any zombies

                // Remove all connections that haven't been updated based on our threshold
                var zombies = db.Connections.Where(c =>
                    SqlFunctions.DateDiff("ss", c.LastActivity, DateTimeOffset.UtcNow) >= _zombieThreshold);

                // We're doing ToList() since there's no MARS support on azure
                foreach (var connection in zombies.ToList())
                {
                    db.Connections.Remove(connection);
                }

                db.SaveChanges();
            }
        }
    }
} 

The issue I am facing is here:

 // Get all connections on this node and update the activity
                foreach (var trackedConnection in _heartbeat.GetConnections())
                {

Scanning all the connections when there are large number of connections is deeply affecting the performance of my application and is giving lot of CPU spikes.

In my database, I already have the mapping for connection ids per user. Based on that I already a have field in my cache per user whether that user has any connection in db or not. Those mappings are are already cached. I would scan each of those mappings and would check whether the connection (connection id) for that specific user is is alive or not. I tried looking for ITransportHeartbeat Interface for the same but unfortunately, that interface gives us just these four methods:

//
// Summary:
//     Manages tracking the state of connections.
public interface ITransportHeartbeat
{
    //
    // Summary:
    //     Adds a new connection to the list of tracked connections.
    //
    // Parameters:
    //   connection:
    //     The connection to be added.
    //
    // Returns:
    //     The connection it replaced, if any.
    ITrackingConnection AddOrUpdateConnection(ITrackingConnection connection);
    //
    // Summary:
    //     Gets a list of connections being tracked.
    //
    // Returns:
    //     A list of connections.
    IList<ITrackingConnection> GetConnections();
    //
    // Summary:
    //     Marks an existing connection as active.
    //
    // Parameters:
    //   connection:
    //     The connection to mark.
    void MarkConnection(ITrackingConnection connection);
    //
    // Summary:
    //     Removes a connection from the list of tracked connections.
    //
    // Parameters:
    //   connection:
    //     The connection to remove.
    void RemoveConnection(ITrackingConnection connection);
} 

Ther is no method where I can get the state of connection by connectionid. Is there any way where I can get a specific connection information without scannig all the connetcions. I am aware of the traditional way to get that which could be using this: _heartbeat.GetConnections().Select(b => b.ConnectionId). But that code also will scan all the connections.

I am aware of OnDisconnected event also which we could use on a Hub itself but the OnDisconnected even doesn't guarantee to fire always (browser can close, internet shut down, site restart).

Is there any code which I could hook in my Hub itself to detect the ping done by the Heartbeat API? I could store the last pings per connection (kind of denormalize the way of detecting last ping) and can detect whether that connection is dead or not?

SignalR for .Net Core has something like that:

var heartbeat = Context.Features.Get<IConnectionHeartbeatFeature>();
heartbeat.OnHeartBeat(MyAction,  

but I am looking for a similar feature like that in SignalR for .NET Framework.