public override Task SendConnectionsAsync(IReadOnlyList <string> connectionIds, string methodName, object[] args)
{
if (connectionIds == null)
{
throw new ArgumentNullException(nameof(connectionIds));
}
var publishTasks = new List <Task>(connectionIds.Count);
var message = new RedisInvocationMessage(target: methodName, arguments: args);
foreach (string connectionId in connectionIds)
{
var connection = _connections[connectionId];
// If the connection is local we can skip sending the message through the bus since we require sticky connections.
// This also saves serializing and deserializing the message!
if (connection != null)
{
publishTasks.Add(connection.WriteAsync(message.CreateInvocation()));
}
else
{
publishTasks.Add(PublishAsync(_channelNamePrefix + "." + connectionId, message));
}
}
return(Task.WhenAll(publishTasks));
}
public override Task SendGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList <string> excludedIds)
{
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
var message = new RedisInvocationMessage(methodName, excludedIds, args);
return(PublishAsync(_channelNamePrefix + ".group." + groupName, message));
}
public override Task InvokeGroupAsync(string groupName, string methodName, object[] args)
{
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
var message = new RedisInvocationMessage(target: methodName, excludedIds: null, arguments: args);
return(PublishAsync(_channelNamePrefix + ".group." + groupName, message));
}
public override Task SendUsersAsync(IReadOnlyList <string> userIds, string methodName, object[] args)
{
if (userIds.Count > 0)
{
var message = new RedisInvocationMessage(methodName, args);
var publishTasks = new List <Task>(userIds.Count);
foreach (var userId in userIds)
{
if (!string.IsNullOrEmpty(userId))
{
publishTasks.Add(PublishAsync(_channelNamePrefix + ".user." + userId, message));
}
}
return(Task.WhenAll(publishTasks));
}
return(Task.CompletedTask);
}
public override Task SendGroupsAsync(IReadOnlyList <string> groupNames, string methodName, object[] args)
{
if (groupNames == null)
{
throw new ArgumentNullException(nameof(groupNames));
}
var publishTasks = new List <Task>(groupNames.Count);
var message = new RedisInvocationMessage(target: methodName, arguments: args);
foreach (var groupName in groupNames)
{
if (!string.IsNullOrEmpty(groupName))
{
publishTasks.Add(PublishAsync(_channelNamePrefix + "." + groupName, message));
}
}
return(Task.WhenAll(publishTasks));
}
public override Task SendConnectionAsync(string connectionId, string methodName, object[] args)
{
if (connectionId == null)
{
throw new ArgumentNullException(nameof(connectionId));
}
var message = new RedisInvocationMessage(target: methodName, arguments: args);
// If the connection is local we can skip sending the message through the bus since we require sticky connections.
// This also saves serializing and deserializing the message!
var connection = _connections[connectionId];
if (connection != null)
{
return(connection.WriteAsync(message.CreateInvocation()));
}
return(PublishAsync(_channelNamePrefix + "." + connectionId, message));
}
public override Task SendUserAsync(string userId, string methodName, object[] args)
{
var message = new RedisInvocationMessage(methodName, args);
return(PublishAsync(_channelNamePrefix + ".user." + userId, message));
}
public override Task SendAllExceptAsync(string methodName, object[] args, IReadOnlyList <string> excludedIds)
{
var message = new RedisInvocationMessage(target: methodName, excludedIds: excludedIds, arguments: args);
return(PublishAsync(_channelNamePrefix + ".AllExcept", message));
}
public override Task SendAllAsync(string methodName, object[] args)
{
var message = new RedisInvocationMessage(target: methodName, arguments: args);
return(PublishAsync(_channelNamePrefix, message));
}
