Working on GroupExcept

Author: mikaelm12

samples/ChatSample/PresenceHubLifetimeManager.cs

@@ -171,5 +171,10 @@ public override Task RemoveGroupAsync(string connectionId, string groupName)
         {
             return _wrappedHubLifetimeManager.RemoveGroupAsync(connectionId, groupName);
         }
+
+        public override Task InvokeGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList<string> excludedIds)
+        {
+            return _wrappedHubLifetimeManager.InvokeGroupExceptAsync(groupName, methodName, args, excludedIds);
+        }
     }
 }

src/Microsoft.AspNetCore.SignalR.Core/DefaultHubLifetimeManager.cs

@@ -129,6 +129,25 @@ public override Task InvokeGroupAsync(string groupName, string methodName, objec
             return Task.CompletedTask;
         }
 
+        public override Task InvokeGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList<string> excludedIds)
+        {
+            if (groupName == null)
+            {
+                throw new ArgumentNullException(nameof(groupName));
+            }
+
+            var group = _groups[groupName];
+            if (group != null)
+            {
+                var message = CreateInvocationMessage(methodName, args);
+                var tasks = group.Values.Where(connection => !excludedIds.Contains(connection.ConnectionId))
+                    .Select(c => c.WriteAsync(message));
+                return Task.WhenAll(tasks);
+            }
+
+            return Task.CompletedTask;
+        }
+
         private InvocationMessage CreateInvocationMessage(string methodName, object[] args)
         {
             return new InvocationMessage(GetInvocationId(), nonBlocking: true, target: methodName, argumentBindingException: null, arguments: args);

src/Microsoft.AspNetCore.SignalR.Core/HubCallerClients.cs

@@ -39,6 +39,11 @@ public IClientProxy Group(string groupName)
             return _hubClients.Group(groupName);
         }
 
+        public IClientProxy GroupExcept(string groupName, IReadOnlyList<string> excludeIds)
+        {
+            return _hubClients.GroupExcept(groupName, excludeIds);
+        }
+
         public IClientProxy User(string userId)
         {
            return _hubClients.User(userId);

src/Microsoft.AspNetCore.SignalR.Core/HubContext.cs

@@ -37,6 +37,11 @@ public virtual IClientProxy Group(string groupName)
             return new GroupProxy<THub>(_lifetimeManager, groupName);
         }
 
+        public IClientProxy GroupExcept(string groupName, IReadOnlyList<string> excludeIds)
+        {
+            return new GroupExceptProxy<THub>(_lifetimeManager, groupName, excludeIds);
+        }
+
         public virtual IClientProxy User(string userId)
         {
             return new UserProxy<THub>(_lifetimeManager, userId);

src/Microsoft.AspNetCore.SignalR.Core/HubContext`T.cs

@@ -39,6 +39,11 @@ public virtual T Group(string groupName)
             return TypedClientBuilder<T>.Build(new GroupProxy<THub>(_lifetimeManager, groupName));
         }
 
+        public T GroupExcept(string groupName, IReadOnlyList<string> excludeIds)
+        {
+            return TypedClientBuilder<T>.Build(new GroupExceptProxy<THub>(_lifetimeManager, groupName, excludeIds));
+        }
+
         public virtual T User(string userId)
         {
             return TypedClientBuilder<T>.Build(new UserProxy<THub>(_lifetimeManager, userId));

src/Microsoft.AspNetCore.SignalR.Core/HubLifetimeManager.cs

@@ -20,6 +20,8 @@ public abstract class HubLifetimeManager<THub>
 
         public abstract Task InvokeGroupAsync(string groupName, string methodName, object[] args);
 
+        public abstract Task InvokeGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList<string> excludedIds);
+
         public abstract Task InvokeUserAsync(string userId, string methodName, object[] args);
 
         public abstract Task AddGroupAsync(string connectionId, string groupName);

src/Microsoft.AspNetCore.SignalR.Core/IHubClients`T.cs

@@ -15,6 +15,8 @@ public interface IHubClients<T>
 
         T Group(string groupName);
 
+        T GroupExcept(string groupName, IReadOnlyList<string> excludeIds);
+
         T User(string userId);
     }
 }

src/Microsoft.AspNetCore.SignalR.Core/Proxies.cs

@@ -40,6 +40,25 @@ public Task InvokeAsync(string method, params object[] args)
         }
     }
 
+    public class GroupExceptProxy<THub> : IClientProxy
+    {
+        private readonly string _groupName;
+        private readonly HubLifetimeManager<THub> _lifetimeManager;
+        private IReadOnlyList<string> _excludedIds;
+
+        public GroupExceptProxy(HubLifetimeManager<THub> lifetimeManager, string groupName, IReadOnlyList<string> excludedIds)
+        {
+            _lifetimeManager = lifetimeManager;
+            _groupName = groupName;
+            _excludedIds = excludedIds;
+        }
+
+        public Task InvokeAsync(string method, params object[] args)
+        {
+            return _lifetimeManager.InvokeGroupExceptAsync(_groupName, method, args, _excludedIds);
+        }
+    }
+
     public class AllClientProxy<THub> : IClientProxy
     {
         private readonly HubLifetimeManager<THub> _lifetimeManager;

src/Microsoft.AspNetCore.SignalR.Core/TypedHubClients.cs

@@ -32,6 +32,11 @@ public T Group(string groupName)
             return TypedClientBuilder<T>.Build(_hubClients.Group(groupName));
         }
 
+        public T GroupExcept(string groupName, IReadOnlyList<string> excludeIds)
+        {
+            return TypedClientBuilder<T>.Build(_hubClients.GroupExcept(groupName, excludeIds));
+        }
+
         public T User(string userId)
         {
             return TypedClientBuilder<T>.Build(_hubClients.User(userId));

src/Microsoft.AspNetCore.SignalR.Redis/RedisHubLifetimeManager.cs

@@ -190,7 +190,19 @@ public override Task InvokeGroupAsync(string groupName, string methodName, objec
                 throw new ArgumentNullException(nameof(groupName));
             }
 
-            var message = new InvocationMessage(GetInvocationId(), nonBlocking: true, target: methodName, argumentBindingException: null, arguments: args);
+            var message = new RedisExcludeClientsMessage(GetInvocationId(), nonBlocking: true, target: methodName, excludedIds: null, arguments: args);
+
+            return PublishAsync(_channelNamePrefix + ".group." + groupName, message);
+        }
+
+        public override Task InvokeGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList<string> excludedIds)
+        {
+            if (groupName == null)
+            {
+                throw new ArgumentNullException(nameof(groupName));
+            }
+
+            var message = new RedisExcludeClientsMessage(GetInvocationId(), nonBlocking: true, target: methodName, excludedIds: excludedIds, arguments: args);
 
             return PublishAsync(_channelNamePrefix + ".group." + groupName, message);
         }
@@ -547,11 +559,16 @@ private Task SubscribeToGroup(string groupChannel, GroupData group)
             {
                 try
                 {
-                    var message = DeserializeMessage<HubInvocationMessage>(data);
+                    var message = DeserializeMessage<RedisExcludeClientsMessage>(data);
 
-                    var tasks = new List<Task>(group.Connections.Count);
+                    var tasks = new List<Task>();
                     foreach (var groupConnection in group.Connections)
                     {
+                        if (message.ExcludedIds.Contains(groupConnection.ConnectionId))
+                        {
+                            continue;
+                        }
+
                         tasks.Add(groupConnection.WriteAsync(message));
                     }