1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace Microsoft.AspNetCore.SignalR.Internal;
internal sealed class HubCallerClients : IHubCallerClients
{
private readonly string _connectionId;
private readonly IHubClients _hubClients;
private readonly string[] _currentConnectionId;
private readonly bool _parallelEnabled;
// Client results don't work in OnConnectedAsync
// This property is set by the hub dispatcher when those methods are being called
// so we can prevent users from making blocking client calls by returning a custom ISingleClientProxy instance
internal bool InvokeAllowed { get; set; }
public HubCallerClients(IHubClients hubClients, string connectionId, bool parallelEnabled)
{
_connectionId = connectionId;
_hubClients = hubClients;
_currentConnectionId = new[] { _connectionId };
_parallelEnabled = parallelEnabled;
}
IClientProxy IHubCallerClients<IClientProxy>.Caller => Caller;
public ISingleClientProxy Caller
{
get
{
if (!_parallelEnabled)
{
return new NotParallelSingleClientProxy(_hubClients.Client(_connectionId));
}
if (!InvokeAllowed)
{
return new NoInvokeSingleClientProxy(_hubClients.Client(_connectionId));
}
return _hubClients.Client(_connectionId);
}
}
public IClientProxy Others => _hubClients.AllExcept(_currentConnectionId);
public IClientProxy All => _hubClients.All;
public IClientProxy AllExcept(IReadOnlyList<string> excludedConnectionIds)
{
return _hubClients.AllExcept(excludedConnectionIds);
}
IClientProxy IHubClients<IClientProxy>.Client(string connectionId) => Client(connectionId);
public ISingleClientProxy Client(string connectionId)
{
if (!_parallelEnabled)
{
return new NotParallelSingleClientProxy(_hubClients.Client(connectionId));
}
if (!InvokeAllowed)
{
return new NoInvokeSingleClientProxy(_hubClients.Client(_connectionId));
}
return _hubClients.Client(connectionId);
}
public IClientProxy Group(string groupName)
{
return _hubClients.Group(groupName);
}
public IClientProxy Groups(IReadOnlyList<string> groupNames)
{
return _hubClients.Groups(groupNames);
}
public IClientProxy OthersInGroup(string groupName)
{
return _hubClients.GroupExcept(groupName, _currentConnectionId);
}
public IClientProxy GroupExcept(string groupName, IReadOnlyList<string> excludedConnectionIds)
{
return _hubClients.GroupExcept(groupName, excludedConnectionIds);
}
public IClientProxy User(string userId)
{
return _hubClients.User(userId);
}
public IClientProxy Clients(IReadOnlyList<string> connectionIds)
{
return _hubClients.Clients(connectionIds);
}
public IClientProxy Users(IReadOnlyList<string> userIds)
{
return _hubClients.Users(userIds);
}
private sealed class NotParallelSingleClientProxy : ISingleClientProxy
{
private readonly ISingleClientProxy _proxy;
public NotParallelSingleClientProxy(ISingleClientProxy hubClients)
{
_proxy = hubClients;
}
public Task<T> InvokeCoreAsync<T>(string method, object?[] args, CancellationToken cancellationToken = default)
{
throw new InvalidOperationException("Client results inside a Hub method requires HubOptions.MaximumParallelInvocationsPerClient to be greater than 1.");
}
public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
{
return _proxy.SendCoreAsync(method, args, cancellationToken);
}
}
private sealed class NoInvokeSingleClientProxy : ISingleClientProxy
{
private readonly ISingleClientProxy _proxy;
public NoInvokeSingleClientProxy(ISingleClientProxy hubClients)
{
_proxy = hubClients;
}
public Task<T> InvokeCoreAsync<T>(string method, object?[] args, CancellationToken cancellationToken = default)
{
throw new InvalidOperationException("Client results inside OnConnectedAsync Hub methods are not allowed.");
}
public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
{
return _proxy.SendCoreAsync(method, args, cancellationToken);
}
}
}
|
