管理signalR通知以同步客户端和服务器(c#)

Question

在我的Web应用程序中,我想在启动时从服务器加载所有数据到客户端.从那以后,我希望所有的通信都通过Signalr来管理 - 这意味着每个更新服务器将通知发送到所有的客户,他们会要求更新的数据.

但是,当SingalR连接损坏然后返回时,我不知道该怎么办.我不想再次加载所有数据.我想要做的是在服务器端为每个断开连接的客户端实现某种类型的通知管理,并且每当再次建立SignalR连接时 - 向该特定客户端推送他错过的所有通知.

我们在客户端的signalR监听器是在单独的监听器而不是短生命控制器上进行的,因此我们可以防止每次视图更改的GET请求,并使应用程序更快,更友好.由于这种方法,即使与最终用户所在的当前视图无关,也可以处理和处理后台的新通知,如下所示:

// This service is initialized once only
public class Service1 {
        static inject = ['$rootScope']
    array : Item[];

    // This is a singleton!
    public constructor ($rootScope){

        // Get all items from the server
        GetAllItemsFromServer();

        // Listener for signalR updates
        var listener = $rootScope.$on("ItemsNotificationFromServer", UpdateItems);

        $rootScope.$on('destroy', {
            // Stop the listener
            listener();
        })
    }   

    // Getting all the items from the server on each controller creation
    GetAllItemsFromServer(){
        // Getting the items
    }

    // Handle the notification from the server
    public UpdateItems(event, result) : void 
        //..
    }
}

例如,当最终用户刷新浏览器时(F5),我无法知道此客户端在连接问题期间错过了什么SignalR通知,因此我再次从服务器加载所有数据(很糟糕) ).

为了防止它我想到实现这样的事情 -

namespace MapUsersSample
{
    public class UserContext : DbContext
    {
        // All those are cleaned when server is powered up
        public DbSet<Connection> Connections { get; set; }
        public DbSet<Notification> Notifications {get; set;}
    }

    public class Connection
    {
        [Key]
        [DatabaseGenerationOptions.None]
        public string ConnectionID { get; set; }
        public bool Connected { get; set; }

        // I fill this when disconnected
        public List<Notification> MissedNotifications {get; set;}

        public Connection(string id)
        {
            this.ConnectionID = id;
            this.Connected = true;
            this.MissedNotifications = new List<Notification>();
        }
    }

    public abstract class Notification()
    {
        public int Id {get; set;}
        public DateTime CreationTime {get; set;}
    }

    .. // Many notifications implement this
}

public class MyHub : Hub
{
    private readonly DbContext _db;
    public class MyHub(DbContext db)
    {
        this._db = db;
    }

    // Adding a new connection or updating status to true
    public override Task OnConnected()
    {
        var connection = GetConnection(Context.ConnectionId);

        if (connection == null)
            _db.Connections.Add(new Connection(Context.ConnectionId));
        else 
            connection.Connected = true;

        return base.OnConnected()
    }

    // Changing connection status to false
    public override Task OnDisconnected()
    {
        var connection = GetConnection(Context.ConnectionId);

        if (connection == null)
        {
            Log("Disconnect error: failed to find a connection with id : " + Context.ConnectionId);
            return;
        }
        else {
            connection.Connected = false;
        }
        return base.OnDisconnected();
    }

    public override Task OnReconnected()
    {
       var connection = GetConnection(Context.ConnectionId);

        if (connection == null)
        {
            Log("Reconnect error - failed to find a connection with id : " + Context.ConnectionId);
            return;
        }
        else {
            connection.Connected = true;
        }

        // On reconnect, trying to send to the client all the notifications that he has missed
        foreach (var notification in connection.MissedNotifications){
            Clients.Client(connection.ConnectionID).handleNotification(notification);
        }

        return base.OnReconnected();
    }

    // This method is called from clients that receive a notification
    public clientNotified(int connectionId, int notificationId)
    {
        // Getting the connection
        var connection = GetConnection(connectionId);

        if (connection == null){
            Log("clientNotified error - failed to find a connection with id : " + Context.ConnectionId);
            return;
        }

        // Getting the notification that the client was notified about
        var notificationToRemove = _dbConnection.Notifications.FirstOrDefault(n => n.Id == notificationId);

        if (notificationToRemove == null)
        {
            Log("clientNotified error - failed to find notification with id : " + notificationId);
            return;
        }

        // Removing from the missed notifications
        connection.MissedNotifications.Remove(notificationToRemove);
    }

    private Connection GetConnection(int connectionId) 
    {
        return _db.Connections.find(connectionId);
    }


}

// Notifications outside of the hub
public class Broadcaster
{
    DbContext _db;
    public Broadcaster(DbContext db)
    {
        _hubContext = GlobalHost.ConnectionManager.GetHubContext<MoveShapeHub>();
        _dbConnection = db;
    }

    public void NotifyClients(Notification notification)
    {
        var openConnections = _db.Connections.Where(x => x.Connected);
        var closedConnections = _db.Connections.Where(x => !x.Connected);

        // Adding all notifications to be sent when those connections are back
        foreach (var connection in closedConnections){
            connection.MissedNotifications.add(notification);
        }

        // Notifying all open connections
        foreach (var connection in openConnections){
            _hubContext.Clients.Client(connection.ConnectionID).handleNotification(notification);
        }
    }
}


client side java script:

handleNotification(notification){
    hubProxy.Server.clientNotified(hub.connection.id, notification.Id)

    // Keep handling the notification here..
}

我还没有测试它,但在我向我的团队提出这个想法之前,这种方法很受欢迎吗？还没有看到人们采取这种方法,我想知道为什么？这里有风险吗？

Answer 1

例如，目前发生的情况是，当最终用户刷新浏览器（F5）时，我无法知道该客户端在连接问题期间错过了哪些 SignalR 通知，因此我重新从服务器加载所有数据（这很糟糕） ）。

按 F5 刷新浏览器是硬重置，所有现有的 SignalR 连接都会丢失。将建立新的连接来获取数据。当 SignalR 注意到 http 连接出现问题（例如由于临时网络问题）时，就会出现连接问题。浏览器刷新不是连接问题，而是用户故意重新创建新连接的行为。

因此，管理错过通知的代码仅适用于 signalR 连接问题。我认为它不适用于浏览器刷新，但这是一个新连接，因此您不会错过任何内容。