Sharing singleton instances between Resolve and ResolveAll and subtypes

[zastrowm]

I have a use case where I want to use singletons and I want to guarantee that those singletons are only constructed once. However, I'm not sure how to register the types in the assembly to do this - I'm noticing that instances are created for each type (concrete type and interface-type) that is requested

As an example, say we have type IBaseInterface with Subtypes A and B; let's create a container configuration that can resolve both

 _diContainer
      .RegisterAssemblyContaining<IBaseInterface>(
        type => typeof(IBaseInterface).IsAssignableFrom(type),
        configurator: opt => opt.WithSingletonLifetime()
      );

and then I resolve them both:

var a = container.Resolve<A>();
var b = container.Resolve<B>();

Later I want to have both instances in an array:

var allOfThem = containers.ResolveAll<IBaseInterface>();

What I'm seeing is that ResolveAll creates different instances instead of reusing the pre-existing instances of A & B. Is it possible to configure it in such a way that A & B will never be constructed more than once? I looked through the documentation but couldn't find anything specific to this situation.

---

For convenience I've written a test (in the style of AssemblyTests.cs) of what I'm trying to accomplish:

[Fact]
public void ResolveAllResolvesExistingInstance()
{
    using var container = new StashboxContainer();
    container.RegisterAssemblyContaining<ITA_T1>(
        type => typeof(ITA_T1).IsAssignableFrom(type),
        configurator: opt => opt.WithSingletonLifetime()
    );

    var all = container.ResolveAll<ITA_T1>();
    var instance = container.Resolve<TA_T1>();

    // sanity test that there is a TA_T1
    Assert.Contains(all, it => it is TA_T1);

    // however they aren't the same instance
    Assert.Contains(all, it => it == instance);
}

[zastrowm]

It looks like I can get the desired behavior by manually registering the types in the assembly and using AsImplementedTypes:

using var container = new StashboxContainer();

foreach (var type in typeof(ITA_T1).Assembly.GetTypes()
            .Where(it => it.Name.StartsWith("TA_") && it.IsClass && !it.IsAbstract))
{
    container.Register(
    type,
    configurator: opt => opt.WithSingletonLifetime()
                            .AsImplementedTypes()
    );
}

var all = container.ResolveAll<ITA_T1>();

// sanity test that there is a TA_T1
Assert.Contains(all, it => it is TA_T1);

// however they aren't the same instance
var instance = container.Resolve<TA_T1>();
Assert.Contains(all, it => it == instance);

[z4kn4fein]

Hi @zastrowm, thank you for the report, and sorry for the late reply!

I see you've found a workaround, but I realized this is a bug. The container should map each found implemented type in the assembly to the same registration.

I've fixed this issue and published a pre-release version to NuGet 5.8.0-preview-791.
Can I ask for verification that it works now with the following form?

_diContainer.RegisterAssemblyContaining<IBaseInterface>(
    type => typeof(IBaseInterface).IsAssignableFrom(type),
    configurator: opt => opt.WithSingletonLifetime()
);

Thanks!

[zastrowm]

...
I've fixed this issue and published a pre-release version to NuGet 5.8.0-preview-791.
Can I ask for verification ...

Yes, that works! Thanks for the quick turnaround!

[z4kn4fein]

Thanks for the feedback!
I've released the fix in v5.8.0