Get the name of calling class

[silkfire]

How do I get the name / type of the class that's trying to resolve a dependency, let's say via ctor injection? I tried to resolve IInjectionContext and StaticInjectionContext in ExportFactory but neither of the objects contained any useful information.

[ipjohnson]

Hmmm you should be able to get it from the StaticInjectionContext . I'm guessing the static context wasn't passed through correctly for the ExportFactory.

I'll see if I can take a look tonight or tomorrow. I don't think it should be hard to address

[silkfire]

Thanks! There's an enum value there indicating how the dependency call was made, but it seems to always be set to Root, maybe that's related (should be Constructor Injection or something like that).

[ipjohnson]

That's what I suspected when the factory is being created it's being rooted and it's not carrying any context information over. That's incorrect and shouldn't be too hard to address.

[ipjohnson]

So it's not as simple as I originally thought because for simple cases it's working as seen in the test

What does the registration look like does it have a lifestyle on it? If so that can cause it to be rooted.

[silkfire]

That's correct, I'm setting a Singleton lifestyle on the registered dependency.

[ipjohnson]

could you put together a quick sample, I wasn't able to reproduce this but I'm not sure I have it setup the same way you do.

[silkfire]

You're correct, Ian, it seems to work if I don't specify the Singleton lifestyle. The test below should be sufficient to reproduce this scenario:

namespace GraceTests
{
    using Grace.DependencyInjection;
    using Xunit;


    public class DependencyResolutionTests
    {
        [Fact]
        public void Given_a_dependency_injection_request_from_a_constructor_request_type_should_be_constructor_parameter()
        {
            var container = new DependencyInjectionContainer();

            container.Configure(_ =>
            {
                _.ExportFactory<StaticInjectionContext, DependencyImpl>(ctx =>
                {
                    Assert.Equal(RequestType.ConstructorParameter, ctx.TargetInfo.InjectionDependencyType);

                    return new DependencyImpl();
                }).As<IDependency>().Lifestyle.Singleton();
            });


            var service = container.Locate<Service>();
        }
    }


    internal class Service
    {
        public Service(IDependency dependency) { }
    }

    internal interface IDependency {}

    internal class DependencyImpl : IDependency { }
}

[ipjohnson]

The normal Singleton lifestyle "roots" everything so that no context is carried over as well as no dependencies can be carried. This is to insure that an instance is created the same no matter which parent is constructed first (otherwise you can end up with race conditions where it constructs differently between runs).

I can make some changes to the deferred singleton lifestyle to make this possible but I can't do it today.

[silkfire]

Don't feel stressed, I'm okay with waiting awhile for a proper solution. Great that you were able to pinpoint the cause of this :)

[silkfire]

Any update on this one, Ian? ☝🏻

[ipjohnson]

Sorry I've been pretty busy as of late. I have some time this weekend to address a couple Grace items and I'll do a release with this in.

[ipjohnson]

Ok I've implemented a change to make this possible. Normally a singleton is "rooted" this is to prevent a dependency from being constructed differently based on a race condition. This change makes it so which ever path resolves the dependency first dictates how the dependency is constructed.

Are you able to test it in the nightly?

[ipjohnson]

I've released this to nuget. Marking as completed.