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

Question

在我的网络应用程序中，我想在开机时从服务器加载所有数据到客户端。之后，我希望所有通信都通过 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

您应该检查数据是否真实。它可以是上次更改的哈希值或日期时间。

当客户端重新连接时，您应该将上次更改的实际数据哈希或日期时间发送给客户端。

例如

{
clients: '2016-05-05T09:05:05',
orders: '2016-09-20T10:11:11'
}

客户端应用程序将决定需要更新哪些数据。

在客户端，您可以将数据保存到 LocalStorage 或 SessionStorage。

Answer 2

At the moment what happens for example is that when an end user refreshes the browser (F5) I can not know what SignalR notifications this client has missed during the connection problems and so I load all the data from the server all over again (it sucks).

按 F5 刷新浏览器是硬重置，所有现有的 SignalR 连接都将丢失。将建立新的连接以获取数据。连接问题发生在 SignalR 注意到 http 连接问题的情况下，例如由于临时网络问题。浏览器刷新不是连接问题，而是用户有意重新创建新连接的行为。

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

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

Managing signalR notifications to synchronize client and server (c#)

javascript

c#

signalr

asp.net-web-api

angularjs