protected override bool DisconnectCore(CircuitHost circuitHost, string connectionId)
{
if (BeforeDisconnect != null)
{
Assert.True(BeforeDisconnect?.Wait(TimeSpan.FromSeconds(10)), "BeforeDisconnect failed to be set");
}
return(base.DisconnectCore(circuitHost, connectionId));
}
public virtual Task DisconnectAsync(CircuitHost circuitHost, string connectionId)
{
Log.CircuitDisconnectStarted(_logger, circuitHost.CircuitId, connectionId);
Task circuitHandlerTask;
lock (CircuitRegistryLock)
{
if (DisconnectCore(circuitHost, connectionId))
{
circuitHandlerTask = circuitHost.Renderer.Dispatcher.InvokeAsync(() => circuitHost.OnConnectionDownAsync(default));
/// <summary>
/// Registers an active <see cref="CircuitHost"/> with the register.
/// </summary>
public void Register(CircuitHost circuitHost)
{
if (!ConnectedCircuits.TryAdd(circuitHost.CircuitId, circuitHost))
{
// This will likely never happen, except perhaps in unit tests, since CircuitIds are unique.
throw new ArgumentException($"Circuit with identity {circuitHost.CircuitId} is already registered.");
}
// Register for unhandled exceptions from the circuit. The registry is responsible for tearing
// down the circuit on errors.
circuitHost.UnhandledException += CircuitHost_UnhandledException;
}
public void SetCircuit(IDictionary <object, object> circuitHandles, object circuitKey, CircuitHost circuitHost)
{
circuitSet = true;
return;
}
public void SetCircuit(IDictionary <object, object?> circuitHandles, object circuitKey, CircuitHost circuitHost)
{
circuitHandles[circuitKey] = circuitHost?.Handle;
}
private void SetCircuit(CircuitHost circuitHost)
{
Context.Items[CircuitKey] = circuitHost?.Handle;
}
internal Circuit(CircuitHost circuitHost)
{
_circuitHost = circuitHost;
}
public async ValueTask <CircuitHost> CreateCircuitHostAsync(
IReadOnlyList <ComponentDescriptor> components,
CircuitClientProxy client,
string baseUri,
string uri,
ClaimsPrincipal user,
IPersistentComponentStateStore store)
{
var scope = _scopeFactory.CreateAsyncScope();
var jsRuntime = (RemoteJSRuntime)scope.ServiceProvider.GetRequiredService <IJSRuntime>();
jsRuntime.Initialize(client);
var navigationManager = (RemoteNavigationManager)scope.ServiceProvider.GetRequiredService <NavigationManager>();
var navigationInterception = (RemoteNavigationInterception)scope.ServiceProvider.GetRequiredService <INavigationInterception>();
if (client.Connected)
{
navigationManager.AttachJsRuntime(jsRuntime);
navigationManager.Initialize(baseUri, uri);
navigationInterception.AttachJSRuntime(jsRuntime);
}
else
{
navigationManager.Initialize(baseUri, uri);
}
var appLifetime = scope.ServiceProvider.GetRequiredService <ComponentStatePersistenceManager>();
await appLifetime.RestoreStateAsync(store);
var jsComponentInterop = new CircuitJSComponentInterop(_options);
var renderer = new RemoteRenderer(
scope.ServiceProvider,
_loggerFactory,
_options,
client,
_loggerFactory.CreateLogger <RemoteRenderer>(),
jsRuntime,
jsComponentInterop);
var circuitHandlers = scope.ServiceProvider.GetServices <CircuitHandler>()
.OrderBy(h => h.Order)
.ToArray();
var circuitHost = new CircuitHost(
_circuitIdFactory.CreateCircuitId(),
scope,
_options,
client,
renderer,
components,
jsRuntime,
navigationManager,
circuitHandlers,
_loggerFactory.CreateLogger <CircuitHost>());
Log.CreatedCircuit(_logger, circuitHost);
// Initialize per - circuit data that services need
(circuitHost.Services.GetRequiredService <ICircuitAccessor>() as DefaultCircuitAccessor).Circuit = circuitHost.Circuit;
circuitHost.SetCircuitUser(user);
return(circuitHost);
}
internal static void CreatedCircuit(ILogger logger, CircuitHost circuitHost) => CreatedCircuit(logger, circuitHost.CircuitId.Id, circuitHost.Client.ConnectionId);
