public MassTransitHubLifetimeManager(IPublishEndpoint publishEndpoint,
IClientFactory clientFactory,
IHubProtocolResolver hubProtocolResolver)
{
_publishEndpoint = publishEndpoint;
_groupManagementRequestClient = clientFactory.CreateRequestClient <GroupManagement <THub> >(TimeSpan.FromSeconds(20));
_protocols = hubProtocolResolver.AllProtocols;
}
public MassTransitHubLifetimeManager(IPublishEndpoint publishEndpoint,
IRequestClient <GroupManagement <THub> > groupManagementRequestClient,
IHubProtocolResolver hubProtocolResolver)
{
_publishEndpoint = publishEndpoint;
_groupManagementRequestClient = groupManagementRequestClient;
_protocols = hubProtocolResolver.AllProtocols;
}
public MassTransitMessageDataHubLifetimeManager(HubLifetimeManagerOptions <THub> hubLifetimeManagerOptions,
IBus bus,
IHubProtocolResolver hubProtocolResolver,
IMessageDataRepository repository)
: base(hubLifetimeManagerOptions, bus, bus.CreateClientFactory().CreateRequestClient <GroupManagement <THub> >(), hubProtocolResolver)
{
_repository = repository;
}
public MassTransitMessageDataHubLifetimeManager(IPublishEndpoint publishEndpoint,
IClientFactory clientFactory,
IHubProtocolResolver hubProtocolResolver,
IMessageDataRepository repository)
: base(publishEndpoint, clientFactory, hubProtocolResolver)
{
_repository = repository;
}
public PostgreSqlHubLifetimeManager(IOptions <PostgreSqlOptions> options, IHubProtocolResolver hubProtocolResolver,
Func <NpgsqlConnection> connectionFactory)
{
_connectionFactory = connectionFactory;
_options = options.Value;
_channels = new PostgreSqlChannels(options.Value.Prefix + typeof(THub).FullName);
_protocol = new PostgreSqlProtocol(hubProtocolResolver.AllProtocols);
_ = EnsureRedisServerConnection();
}
/// <summary>
/// Initializes a new instance of the <see cref="HubConnectionHandler{THub}"/> class.
/// </summary>
/// <param name="lifetimeManager">The hub lifetime manager.</param>
/// <param name="protocolResolver">The protocol resolver used to resolve the protocols between client and server.</param>
/// <param name="globalHubOptions">The global options used to initialize hubs.</param>
/// <param name="hubOptions">Hub specific options used to initialize hubs. These options override the global options.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="userIdProvider">The user ID provider used to get the user ID from a hub connection.</param>
/// <param name="serviceScopeFactory">The service scope factory.</param>
/// <remarks>This class is typically created via dependency injection.</remarks>
public HubConnectionHandler(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
IServiceScopeFactory serviceScopeFactory
)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >();
_userIdProvider = userIdProvider;
_enableDetailedErrors = false;
bool disableImplicitFromServiceParameters;
List <IHubFilter>?hubFilters = null;
if (_hubOptions.UserHasSetValues)
{
_maximumMessageSize = _hubOptions.MaximumReceiveMessageSize;
_enableDetailedErrors = _hubOptions.EnableDetailedErrors ?? _enableDetailedErrors;
_maxParallelInvokes = _hubOptions.MaximumParallelInvocationsPerClient;
disableImplicitFromServiceParameters = _hubOptions.DisableImplicitFromServicesParameters;
if (_hubOptions.HubFilters != null)
{
hubFilters = new List <IHubFilter>(_hubOptions.HubFilters);
}
}
else
{
_maximumMessageSize = _globalHubOptions.MaximumReceiveMessageSize;
_enableDetailedErrors = _globalHubOptions.EnableDetailedErrors ?? _enableDetailedErrors;
_maxParallelInvokes = _globalHubOptions.MaximumParallelInvocationsPerClient;
disableImplicitFromServiceParameters = _globalHubOptions.DisableImplicitFromServicesParameters;
if (_globalHubOptions.HubFilters != null)
{
hubFilters = new List <IHubFilter>(_globalHubOptions.HubFilters);
}
}
_dispatcher = new DefaultHubDispatcher <THub>(
serviceScopeFactory,
new HubContext <THub>(lifetimeManager),
_enableDetailedErrors,
disableImplicitFromServiceParameters,
new Logger <DefaultHubDispatcher <THub> >(loggerFactory),
hubFilters,
lifetimeManager);
}
protected BaseMassTransitHubLifetimeManager(HubLifetimeManagerOptions <THub> hubLifetimeManagerOptions,
IPublishEndpoint publishEndpoint,
IRequestClient <GroupManagement <THub> > groupManagementRequestClient,
IHubProtocolResolver hubProtocolResolver)
{
_hubLifetimeManagerOptions = hubLifetimeManagerOptions;
PublishEndpoint = publishEndpoint;
GroupManagementRequestClient = groupManagementRequestClient;
Protocols = hubProtocolResolver.AllProtocols;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="bus"></param>
/// <param name="hubProtocolResolver"></param>
/// <param name="logger"></param>
public RebusHubLifetimeManager(IBus bus, IHubProtocolResolver hubProtocolResolver, ILogger <RebusHubLifetimeManager <THub> > logger)
{
_bus = bus;
_logger = logger;
_protocols = hubProtocolResolver.AllProtocols;
Connections = new HubConnectionStore();
GroupConnections = new ConcurrentDictionary <string, HubConnectionStore>();
UserConnections = new ConcurrentDictionary <string, HubConnectionStore>();
ServerName = $"{Environment.MachineName}-{Guid.NewGuid():N}";
}
public RabbitMQHubLifetimeManager(ILoggerFactory loggerFactory,
ILogger <RabbitMQHubLifetimeManager <THub> > logger,
IOptions <RabbitMQOptions> options,
IHubProtocolResolver hubProtocolResolver)
{
_logger = logger;
_bus = new RabbitMQBus(options.Value,
new RabbitMQProtocol(hubProtocolResolver.AllProtocols),
loggerFactory.CreateLogger <RabbitMQBus>(),
_serverName);
_ = EnsureRabbitMQServerConnection();
}
public RedisHubLifetimeManager(ILogger <RedisHubLifetimeManager <THub> > logger,
IOptions <RedisOptions> options,
IHubProtocolResolver hubProtocolResolver)
{
_logger = logger;
_options = options.Value;
_ackHandler = new AckHandler();
_channels = new RedisChannels(typeof(THub).FullName);
_protocol = new RedisProtocol(hubProtocolResolver.AllProtocols);
var writer = new LoggerTextWriter(logger);
RedisLog.ConnectingToEndpoints(_logger, options.Value.Options.EndPoints, _serverName);
_redisServerConnection = _options.Connect(writer);
_redisServerConnection.ConnectionRestored += (_, e) =>
{
// We use the subscription connection type
// Ignore messages from the interactive connection (avoids duplicates)
if (e.ConnectionType == ConnectionType.Interactive)
{
return;
}
RedisLog.ConnectionRestored(_logger);
};
_redisServerConnection.ConnectionFailed += (_, e) =>
{
// We use the subscription connection type
// Ignore messages from the interactive connection (avoids duplicates)
if (e.ConnectionType == ConnectionType.Interactive)
{
return;
}
RedisLog.ConnectionFailed(_logger, e.Exception);
};
if (_redisServerConnection.IsConnected)
{
RedisLog.Connected(_logger);
}
else
{
RedisLog.NotConnected(_logger);
}
_bus = _redisServerConnection.GetSubscriber();
SubscribeToAll();
SubscribeToGroupManagementChannel();
SubscribeToAckChannel();
}
public RedisHubLifetimeManager(ILogger <RedisHubLifetimeManager <THub> > logger,
IOptions <RedisOptions> options,
IHubProtocolResolver hubProtocolResolver)
{
_logger = logger;
_options = options.Value;
_ackHandler = new AckHandler();
_channels = new RedisChannels(typeof(THub).FullName);
_protocol = new RedisProtocol(hubProtocolResolver.AllProtocols);
RedisLog.ConnectingToEndpoints(_logger, options.Value.Options.EndPoints, _serverName);
}
public ShardingRedisHubLifetimeManager(ILogger <RedisHubLifetimeManager <THub> > logger,
IOptions <ShardingRedisOptions> options,
IHubProtocolResolver hubProtocolResolver)
{
_logger = logger;
_options = options.Value;
_ackHandler = new AckHandler();
_channels = new RedisChannels(typeof(THub).FullName);
_protocol = new RedisProtocol(hubProtocolResolver.AllProtocols);
_ = EnsureRedisServerConnection();
}
public ProxyHubConnectionHandler(
HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
IServiceScopeFactory serviceScopeFactory,
IValueManagerStorageContainerInitializer storageContainerAccessor)
: base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory)
{
this.storageContainerInitializer = storageContainerAccessor;
}
public DefaultHubMessageSerializer(IHubProtocolResolver hubProtocolResolver, IList <string> globalSupportedProtocols, IList <string> hubSupportedProtocols)
{
var supportedProtocols = hubSupportedProtocols ?? globalSupportedProtocols ?? Array.Empty <string>();
foreach (var protocolName in supportedProtocols)
{
var protocol = hubProtocolResolver.GetProtocol(protocolName, (supportedProtocols as IReadOnlyList <string>) ?? supportedProtocols.ToList());
if (protocol != null)
{
_hubProtocols.Add(protocol);
}
}
}
public HubHost(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
HubDispatcher <THub> hubDispatcher,
IOptions <HubHostOptions> options,
ILoggerFactory loggerFactory)
{
_lifetimeManager = lifetimeManager ?? throw new ArgumentNullException(nameof(lifetimeManager));
_protocolResolver = protocolResolver ?? throw new ArgumentNullException(nameof(protocolResolver));
_hubDispatcher = hubDispatcher ?? throw new ArgumentNullException(nameof(hubDispatcher));
_options = options != null ? options.Value : throw new ArgumentNullException(nameof(options));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_logger = loggerFactory.CreateLogger <HubHost <THub> >();
}
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider)
{
try
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(timeout);
while (await _connectionContext.Transport.Reader.WaitToReadAsync(cts.Token))
{
while (_connectionContext.Transport.Reader.TryRead(out var buffer))
{
if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage))
{
var protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, this);
var transportCapabilities = Features.Get <IConnectionTransportFeature>()?.TransportCapabilities
?? throw new InvalidOperationException("Unable to read transport capabilities.");
var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0)
? (IDataEncoder)Base64Encoder
: PassThroughEncoder;
var transferModeFeature = Features.Get <ITransferModeFeature>() ??
throw new InvalidOperationException("Unable to read transfer mode.");
transferModeFeature.TransferMode =
(protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0)
? TransferMode.Binary
: TransferMode.Text;
ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder);
_logger.UsingHubProtocol(protocol.Name);
UserIdentifier = userIdProvider.GetUserId(this);
return(true);
}
}
}
}
}
catch (OperationCanceledException)
{
_logger.NegotiateCanceled();
}
return(false);
}
public HubEndPoint(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
IHubInvoker <THub> hubInvoker)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_logger = loggerFactory.CreateLogger <HubEndPoint <THub> >();
_userIdProvider = userIdProvider;
_hubInvoker = hubInvoker;
}
public MsmqHubLifetimeManager(
ILogger <MsmqHubLifetimeManager <THub> > logger,
IOptions <MsmqOptions> options,
IHubProtocolResolver hubProtocolResolver,
IMsmqBus msmqBus)
{
this.logger = logger;
this.options = options.Value;
this.protocol = new MsmqProtocol(hubProtocolResolver.AllProtocols);
this.msmqBus = msmqBus;
this.queues = new MsmqQueues(this.options.ApplicationName);
this.ackHandler = new AckHandler();
MsmqLog.ConnectingToEndpoints(this.logger, this.options.ConnectionString, this.options.ApplicationName);
_ = this.EnsureMsmqServerConnection();
}
public HubEndPoint(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IHubContext <THub> hubContext,
IOptions <HubOptions> hubOptions,
ILogger <HubEndPoint <THub> > logger,
IServiceScopeFactory serviceScopeFactory)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_hubContext = hubContext;
_hubOptions = hubOptions;
_logger = logger;
_serviceScopeFactory = serviceScopeFactory;
DiscoverHubMethods();
}
public HubEndPoint(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
HubDispatcher <THub> dispatcher)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubEndPoint <THub> >();
_userIdProvider = userIdProvider;
_dispatcher = dispatcher;
}
public HubConnectionHandler(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
HubDispatcher <THub> dispatcher)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >();
_userIdProvider = userIdProvider;
_dispatcher = dispatcher;
_enableDetailedErrors = _hubOptions.EnableDetailedErrors ?? _globalHubOptions.EnableDetailedErrors ?? false;
}
public HubEndPoint(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IHubContext <THub> hubContext,
IOptions <HubOptions> hubOptions,
ILoggerFactory loggerFactory,
IServiceScopeFactory serviceScopeFactory,
IUserIdProvider userIdProvider)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_hubContext = hubContext;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_logger = loggerFactory.CreateLogger <HubEndPoint <THub> >();
_serviceScopeFactory = serviceScopeFactory;
_userIdProvider = userIdProvider;
DiscoverHubMethods();
}
public DefaultHubMessageSerializer(IHubProtocolResolver hubProtocolResolver, IList <string> globalSupportedProtocols, IList <string> hubSupportedProtocols)
{
var supportedProtocols = hubSupportedProtocols ?? globalSupportedProtocols ?? Array.Empty <string>();
foreach (var protocolName in supportedProtocols)
{
// blazorpack is meant to only be used by the ComponentHub
// We remove it from the list here except when the Hub has a single protocol that is "blazorpack" because
// that identifies it as the ComponentHub
if (supportedProtocols.Count > 1 && string.Equals(protocolName, "blazorpack", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var protocol = hubProtocolResolver.GetProtocol(protocolName, (supportedProtocols as IReadOnlyList <string>) ?? supportedProtocols.ToList());
if (protocol != null)
{
_hubProtocols.Add(protocol);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HubConnectionHandler{THub}"/> class.
/// </summary>
/// <param name="lifetimeManager">The hub lifetime manager.</param>
/// <param name="protocolResolver">The protocol resolver used to resolve the protocols between client and server.</param>
/// <param name="globalHubOptions">The global options used to initialize hubs.</param>
/// <param name="hubOptions">Hub specific options used to initialize hubs. These options override the global options.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="userIdProvider">The user ID provider used to get the user ID from a hub connection.</param>
/// <param name="dispatcher">The hub dispatcher used to dispatch incoming messages to hubs.</param>
/// <remarks>This class is typically created via dependency injection.</remarks>
public HubConnectionHandler(HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
#pragma warning disable PUB0001 // Pubternal type in public API
HubDispatcher <THub> dispatcher
#pragma warning restore PUB0001
)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >();
_userIdProvider = userIdProvider;
_dispatcher = dispatcher;
_enableDetailedErrors = _hubOptions.EnableDetailedErrors ?? _globalHubOptions.EnableDetailedErrors ?? false;
}
public ServiceLifetimeManager(
IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager,
IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger,
AzureSignalRMarkerService marker,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions)
: base(
serviceConnectionManager,
protocolResolver,
globalHubOptions,
hubOptions, logger)
{
// after core 3.0 UseAzureSignalR() is not required.
#if NETSTANDARD2_0
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
#endif
_clientConnectionManager = clientConnectionManager;
}
/// <summary>
/// Constructs the <see cref="RedisHubLifetimeManager{THub}"/> with types from Dependency Injection.
/// </summary>
/// <param name="logger">The logger to write information about what the class is doing.</param>
/// <param name="options">The <see cref="RedisOptions"/> that influence behavior of the Redis connection.</param>
/// <param name="hubProtocolResolver">The <see cref="IHubProtocolResolver"/> to get an <see cref="IHubProtocol"/> instance when writing to connections.</param>
/// <param name="globalHubOptions">The global <see cref="HubOptions"/>.</param>
/// <param name="hubOptions">The <typeparamref name="THub"/> specific options.</param>
public RedisHubLifetimeManager(ILogger <RedisHubLifetimeManager <THub> > logger,
IOptions <RedisOptions> options,
IHubProtocolResolver hubProtocolResolver,
IOptions <HubOptions>?globalHubOptions,
IOptions <HubOptions <THub> >?hubOptions)
{
_logger = logger;
_options = options.Value;
_ackHandler = new AckHandler();
_channels = new RedisChannels(typeof(THub).FullName !);
if (globalHubOptions != null && hubOptions != null)
{
_protocol = new RedisProtocol(new DefaultHubMessageSerializer(hubProtocolResolver, globalHubOptions.Value.SupportedProtocols, hubOptions.Value.SupportedProtocols));
}
else
{
var supportedProtocols = hubProtocolResolver.AllProtocols.Select(p => p.Name).ToList();
_protocol = new RedisProtocol(new DefaultHubMessageSerializer(hubProtocolResolver, supportedProtocols, null));
}
RedisLog.ConnectingToEndpoints(_logger, options.Value.Configuration.EndPoints, _serverName);
_ = EnsureRedisServerConnection();
}
public HubProxyHandler(
IOptionsMonitor <UpstreamOptions> upstreamSettings,
HubLifetimeManager <THub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <THub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
IServiceScopeFactory serviceScopeFactory,
HttpServerlessMessageHandler <THub> upstream)
: base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory)
{
_protocolResolver = protocolResolver;
_upstreamSettings = upstreamSettings;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >();
_userIdProvider = userIdProvider;
_upstream = upstream;
_enableDetailedErrors = true;
}
public HubProxyHandler(
HubLifetimeManager <Hub> lifetimeManager,
IHubProtocolResolver protocolResolver,
IOptions <HubOptions> globalHubOptions,
IOptions <HubOptions <Hub> > hubOptions,
ILoggerFactory loggerFactory,
IUserIdProvider userIdProvider,
IServiceScopeFactory serviceScopeFactory,
IHubProxyInvoker rest)
: base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory)
{
_protocolResolver = protocolResolver;
_lifetimeManager = lifetimeManager;
_loggerFactory = loggerFactory;
_hubOptions = hubOptions.Value;
_globalHubOptions = globalHubOptions.Value;
_logger = loggerFactory.CreateLogger <HubConnectionHandler <Hub> >();
_userIdProvider = userIdProvider;
_rest = rest;
_enableDetailedErrors = false;
_maximumMessageSize = _globalHubOptions.MaximumReceiveMessageSize;
_enableDetailedErrors = _globalHubOptions.EnableDetailedErrors ?? _enableDetailedErrors;
}
public ServiceLifetimeManager(IServiceConnectionManager <THub> serviceConnectionManager,
IClientConnectionManager clientConnectionManager, IHubProtocolResolver protocolResolver,
ILogger <ServiceLifetimeManager <THub> > logger, AzureSignalRMarkerService marker)
: base(serviceConnectionManager, protocolResolver)
{
// after core 3.0 UseAzureSignalR() is not required.
#if !NETCOREAPP3_0
if (!marker.IsConfigured)
{
throw new InvalidOperationException(MarkerNotConfiguredError);
}
#endif
_serviceConnectionManager = serviceConnectionManager;
_clientConnectionManager = clientConnectionManager;
_allProtocols = protocolResolver.AllProtocols;
_logger = logger;
}
/// <summary>
/// Constructs the <see cref="RedisHubLifetimeManager{THub}"/> with types from Dependency Injection.
/// </summary>
/// <param name="logger">The logger to write information about what the class is doing.</param>
/// <param name="options">The <see cref="RedisOptions"/> that influence behavior of the Redis connection.</param>
/// <param name="hubProtocolResolver">The <see cref="IHubProtocolResolver"/> to get an <see cref="IHubProtocol"/> instance when writing to connections.</param>
public RedisHubLifetimeManager(ILogger <RedisHubLifetimeManager <THub> > logger,
IOptions <RedisOptions> options,
IHubProtocolResolver hubProtocolResolver)
: this(logger, options, hubProtocolResolver, globalHubOptions : null, hubOptions : null)
{
}
