Guidance for managing service lifetimes across different parts of your application

[furqansafdar]

I'm working on a project where I need to register a service (IExpressionParser) using DryIoc. The service should behave like a singleton for the lifetime of a RuleApp instance, but different RuleApp instances should have their own independent instances of IExpressionParser.

I tried using Reuse.Scoped to manage this, but parts of my code do not use scopes when resolving dependencies via constructor injection. As a result, I'm seeing multiple instances of IExpressionParser being created in different parts of the code, even during the lifetime of the same RuleApp.

Here’s what I’ve tried so far:

Registering IExpressionParser with Reuse.Scoped and opening a scope for RuleApp.
Directly registering it as a singleton using Reuse.Singleton and resolving it manually, but this does not isolate instances per RuleApp.
What would be the best approach to ensure that:

IExpressionParser is created once per RuleApp instance and shared across all dependencies within that RuleApp.
Code that does not explicitly use scopes can still resolve the correct IExpressionParser for the current RuleApp.
Is there a pattern or feature in DryIoc that allows managing service lifetimes like this, where instances are scoped per logical context (RuleApp), without requiring explicit scope management in all parts of the code?

private void RuleAppService_Opened(object? sender, EventArgs e)
{
    var ruleAppService = sender as RuleApplicationService;

    //container.Register<IExpressionParser>(Reuse.Singleton, Made.Of(() => CreateParser()));
    container.Register<IExpressionParser>(Reuse.Scoped, Made.Of(() => CreateParser()));

    using (var scope = container.OpenScope())
    {
        foreach (var endpoint in ruleApp.EndPoints)
        {
            //endpoint.Integrate(container.Resolve<IExpressionParser>());
            endpoint.Integrate(scope.Resolve<IExpressionParser>());
        }
    }
}

private static GenericExpressionParser CreateParser()
{
    return new GenericExpressionParser();
}

One approach I have taken, not sure if this is an elegant and optimized way to handle this problem.

private void RuleAppService_Opened(object? sender, EventArgs e)
{
    var ruleAppService = sender as RuleApplicationService;

    container.Unregister<IGenericExpressionParser>();

    container.Register<IExpressionParser, GenericExpressionParser>(Reuse.Singleton);

    using (var scope = container.OpenScope())
    {
        foreach (var endpoint in ruleApp.EndPoints)
        {
            endpoint.Integrate(container.Resolve<IExpressionParser>());
        }
    }
}

[dadhi]

Hi @furqansafdar

Did you try to use Reuse.ScopedToService ?
See the docs for the details https://github.com/dadhi/DryIoc/blob/master/docs/DryIoc.Docs/ReuseAndScopes.md#reusescopedto-service-type

[furqansafdar]

Hi @dadhi

Could you please provide further guidance on how to use this? I tried to understand the documentation, but I’m having trouble grasping this new and bit advanced concept.

By the way one important bit that it's not RuleApp who need to use IExpressionParser alone but every part of the application will require IExpressionParser until the RuleApp is not changed by the RuleAppService.

Further, any comment about the approach I mentioned in the question?

[dadhi]

@furqansafdar

From the example in the docs:

        var container = new Container();

        // `openResolutionScope` option is required to open the scope for the `Foo`, read the sub-section below to see why.
        container.Register<Foo>(setup: Setup.With(openResolutionScope: true));

        container.Register<Dependency>();
        container.Register<SubDependency>(Reuse.ScopedToService<Foo>());

        var foo = container.Resolve<Foo>();
        Assert.AreSame(foo.Sub, foo.Dep.Sub);

Imagine Foo is yours IExpressionParser that has some nested dependencies.
You register the Foo this way container.Register<Foo>(setup: Setup.With(openResolutionScope: true)) to command DryIoc to open a scope and only then resolve/inject the Foo from this scope. Basically it will be equal to the code like below generated for you by Container:

var foo = container.OpenScope(new ResolutionScopeName(typeof(Foo))).Resolve<Foo>();

Then you may register dependencies with Reuse.ScopedToService<Foo>().
That means that they may be injected only in Foo, and another thing, that they will be disposed together with the Foo scope.
They may be arbitrarily nested as well.

The slight problem with the approach of implicit opened scope for Foo, that you are not in control of its disposal. You don't have a variable holding the scope, so you can call scope.Dispose() on it. To avoid complete memory leak, in this case DryIoc will store the Foo scope in its parent scope if any or in the singletons, so it may be disposed together with the Container.

But ideally, you want this control on the user side. It can be solved by injecting the scope instance into the Foo itself. And then disposing the scope with all dependencies and sub-dependencies by doing foo.Dispose().

You only need to modify your Foo for this (the registration setup stays the same):

    class Foo : IDisposable
    {
        public Dependency Dep { get; }
        private readonly IResolverContext _scope;
        public Foo(Dependency dep, IResolverContext scope) 
        { 
            Dep = dep;
            _scope = scope;
        }

        public void Dispose() => _scope.Dispose();
    }

For better understanding, I would suggest grabbing the tests from the documentation and pasting them in your test project and debugging them, and adjusting for your case to see the outcomes.