我有 ASP.NET Core Web 应用程序设置，其中 SignalR 与 Redis 横向扩展。 使用内置组效果很好:

Clients.Group("Group_Name");

并在多个负载均衡器中存活。我假设 SignalR 会自动将这些组保留在 Redis 中，以便所有服务器都知道我们有哪些组以及谁订阅了它们。

但是，在我的情况下，我不能只依赖组(或用户)，因为无法将 connectionId(比如在重载 OnDisconnectedAsync 时，只有连接 ID 是已知的)映射回其组，并且您始终需要 Group_Name 来标识组。我需要它来识别组中的哪一部分在线，所以当 OnDisconnectedAsync 被调用时，我知道这个人属于哪个组，以及他在对话的哪一边。

我做了一些研究，他们都建议(包括 Microsoft Docs)使用类似的东西:

static readonly ConcurrentDictionary<string, ConversationInformation> connectionMaps;

在集线器本身。

现在，这是一个很好的解决方案(并且是线程安全的)，只是它只存在于一个负载均衡服务器的内存中，而其他服务器有这个字典的不同实例。

问题是，我是否必须手动保留 connectionMaps？例如使用 Redis？

类似于:

public class ChatHub : Hub
{
    static readonly ConcurrentDictionary<string, ConversationInformation> connectionMaps;

    ChatHub(IDistributedCache distributedCache)
    {

        connectionMaps = distributedCache.Get("ConnectionMaps");
       /// I think connectionMaps should not be static any more.
    }
}

如果是，它是线程安全的吗？如果不是，您能否建议一个与负载平衡一起使用的更好的解决方案？

最佳答案

为此一直在与同样的问题作斗争。我想到的是将集合保存在 redis 缓存中，同时利用 StackExchange.Redis.IDatabaseAsync 和锁来处理并发。 不幸的是，这使整个过程同步，但无法完全解决这个问题。

这是我正在做的事情的核心，它获得了一个锁并从缓存中返回一个反序列化的集合

    private async Task<ConcurrentDictionary<int, HubMedia>> GetMediaAttributes(bool requireLock)
        {
            if(requireLock)
            {
                var retryTime = 0;
                try
                {
                    while (!await _redisDatabase.LockTakeAsync(_mediaAttributesLock, _lockValue, _defaultLockDuration))
                    {
                        //wait till we can get a lock on the data, 100ms by default
                        await Task.Delay(100);
                        retryTime += 10;
                        if (retryTime > _defaultLockDuration.TotalMilliseconds)
                        {
                            _logger.LogError("Failed to get Media Attributes");
                            return null;
                        }
                    }
                }
                catch(TaskCanceledException e)
                {
                    _logger.LogError("Failed to take lock within the default 5 second wait time " + e);
                    return null;
                }

            }
            var mediaAttributes = await _redisDatabase.StringGetAsync(MEDIA_ATTRIBUTES_LIST);
            if (!mediaAttributes.HasValue)
            {
                return new ConcurrentDictionary<int, HubMedia>();
            }
            return JsonConvert.DeserializeObject<ConcurrentDictionary<int, HubMedia>>(mediaAttributes);
        }

在我完成操作后像这样更新集合

        private async Task<bool> UpdateCollection(string redisCollectionKey, object collection, string lockKey)
        {
            var success = false;
            try
            {
                success = await _redisDatabase.StringSetAsync(redisCollectionKey, JsonConvert.SerializeObject(collection, new JsonSerializerSettings
                {
                    ReferenceLoopHandling = ReferenceLoopHandling.Ignore
                }));
            }
            finally
            {
                await _redisDatabase.LockReleaseAsync(lockKey, _lockValue);
            }
            return success;
        }

当我完成后，我只是确保释放锁以供其他实例获取和使用

private async Task ReleaseLock(string lockKey)
        {
            await _redisDatabase.LockReleaseAsync(lockKey, _lockValue);
        }

如果您找到更好的方法，我们将很高兴听到。努力寻找任何关于数据保留和共享的横向扩展文档。

关于asp.net-core - 将 SignalR hub 与 Redis 结合使用时如何跨负载均衡器服务器跨越 ConcurrentDictionary，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54001813/