Prevent externally provided IServiceScopes from being disposed prematurely.

[dotnetjunkie]

Simple Injector allows framework dependencies to be resolved (cross wired) by making use of the .AddSimpleInjector and .UseSimpleInjector extension methods. This allows the following:

using (AsyncScopedLifestyle.BeginScope(container))
{
    var sc = container.GetInstance<IServiceScope>();
    sc.ServiceProvider.GetService<SomeScoped>();
}

In this case, the framework's IServiceScope is internally created and cached by the Simple Injector scope and when the Simple Injector scope is disposed of, so will the IServiceScope be with its SomeScoped registation.

But now consider the following example where an already-existing IServiceScope is provided:

using (AsyncScopedLifestyle.BeginScope(container))
{
    container.GetInstance<ServiceScopeProvider>().ServiceScope = serviceScope;

    var sc = container.GetInstance<IServiceScope>();
    Assert.AreSame(serviceScope, sc);
    sc.ServiceProvider.GetService<SomeScoped>();
}

In this case the resolved IServiceScope is the externally provided instance. With the v5.3 integration, however, with the disposal of the Simple Injector scope, that externally provided IServiceScope with its SomeScoped registration are disposed as well.

This last, however, is an error. Since that IServiceScope is externally provided, it is not created by Simple Injector, and Simple Injector should, threrefore, not dispose of it.

This is important, because even though the Simple Injector scope is disposed, the IServiceScope might live on for some time and there might be code that uses some scoped, disposable framework dependency. Such dependency would break.

In the latter case, the externally provided IServiceScope should not be disposed of.

[dotnetjunkie]

bug-20 branch created.

[ScarletKuro]

I think I’ve encountered that problem, but I’m not 100% sure.

My setup is a bit unusual and somewhat complicated. I have a legacy WPF application where I use Simple Injector. I’m gradually rewriting the UI to use Blazor, so it has become a Blazor Hybrid WPF application.

Blazor requires an IServiceProvider, which needs to be passed to the WebView:

BlazorWebView.Services = serviceProvider;

Because of this, I’m using SimpleInjector.Integration.GenericHost so I can register services for Blazor while continuing to use Simple Injector.

My windows are scoped (flowing scopes)...

container.Register<IWindowService, InternalWindowService>(Lifestyle.Scoped);

This is because they depend on a TCP session, the windows open based on TCP packets (it’s a POS system with tcp communication).

So I have something like this:

internal class InternalWindowService : IWindowService
{
    private readonly Scope _scope;
    private readonly IServiceScope _serviceScope;
    private readonly ILogger<InternalWindowService> _logger;
    private readonly JoinableTaskFactory _joinableTaskFactory;

    public InternalWindowService(
        ILogger<InternalWindowService> logger,
        Scope scope,
        IServiceScope serviceScope,
        JoinableTaskFactory joinableTaskFactory)
    {
        _logger = logger;
        _scope = scope;
        _serviceScope = serviceScope;
        _joinableTaskFactory = joinableTaskFactory;
    }

    public async Task OpenCouponsAsync()
    {
        _logger.LogInformation("Opening Coupon window (async).");

        await _joinableTaskFactory.SwitchToMainThreadAsync();
        // acessor is passed to Blazor as [Parameter], haven't found a better way, even if I cross wire them, `WebViewManager` calls `CreateAsyncScope` which means the instance in Blazor will be not the same as the one the SimpleInjector created. 
        // Even if we remove SimleInjector from the formula the msft doesn't support nested scoping anyway, I had a prototype that does it, but it gets complicated too quickly.
        var accessor = _scope.GetInstance<IPosExecutionContextAccessor<CouponRequest, PosCouponReplyAggregate>>();
        var mainWindow = new MainWindow(_serviceScope.ServiceProvider, accessor);

        mainWindow.ShowDialog();

        await TaskScheduler.Default;
    }
    ....
}

(InternalWindowService is resolved from the SimpleInjector)
From IServiceScope, I obtain the msft IServiceProvider. I haven’t found another way to access it, I can’t inject IServiceProvider directly, and I also can’t pass Scope as an IServiceProvider, because internally the WebViewManager creates a scope from IServiceProvider, which results in exception simpleinjector/SimpleInjector#874

In my Blazor UI, I have a close button that flows back to MainWindow and calls Close(). This results in exceptions:

When I do the same thing in my prototype I made to to see if this idea has potential (which doesn’t use Simple Injector at all), I don’t get that exception.

For now, I’ve found a workaround that avoids the exception, but it’s quite hacky.

[ScarletKuro]

Nvm, once I started to work on a minimal reproduction simpleinjector vs msft di, and set in wpf ShutdownMode="OnExplicitShutdown", they both behave the same way when closing wpf from the blazor view, so this has nothing to do with the simpleinjector.