Resolve parameters according to the parent tree that triggered the resolve?

Question

I have code similar to this:

class A: IA { ... }
class B: IB {
    public B(IA a, ...) { ... }
    ...
}
class C1 {
    public C1(IA a, IB b, ...) { ... }
}
class C2 {
    public C2(IA a, IB b, ...) { ... }
}

What I want is only two instances of A -- one to go with C1 and one to go with C2. I want two instances of B. The instance of B passed to C1 should get the same instance of A created for C1. C2 and his parameters should have a different instance of A. How can I configure this scenario in Autofac? It looked like the Owned instance lifetime feature was supposed to handle this, but the posted example was only one layer deep, not two.

My real situation is much more complex. I have a dozen inheritors of IB and a half dozen C defs that take various combinations of the IB inheritors. I wanted to avoid using the named instances because that would bloat my bootstrapper significantly and make it difficult to maintain.

Secondary question: does DryIoc support this? I could be talked into switching.

dadhi · Answer 1 · 2015-09-02T19:17:46.390

In DryIoc (which is mine) it may be directly achieved using Reuse.InResolutionScopeOf:

container.Register<C1>(setup: Setup.With(openResolutionScope: true), serviceKey: Some.Blah);
container.Register<C2>(setup: Setup.With(openResolutionScope: true), serviceKey: Some.Blah);

container.Register<IA, A>(reuse: Reuse.InResolutionScopeOf(serviceKey: Some.Blah));

That's it. openResolutionScope: true creates scope in object graph.serviceKey is required to identify/find the scope in graph. For instance if C1 and C2 would implement same interface IC then no need in service key. You just say Reuse.InResolutionScopeOf<IC>() and it will be one IA for each IC object in graph.

If you're the author of DryIoc, you need to disclose it. Otherwise folks here would consider this as a spam or something. Thanks. — Sriram Sakthivel, Sep 02 '15 at 14:16

score 2 · Accepted Answer · edited May 23 '17 at 12:14

2

You're looking for something called "instance per graph" lifetime scope. It is not supported natively by autofac. If you're not stuck with autofac you can use Castle Windsor as explained in this related/duplicate question.

If you're looking for a solution with autofac itself, you can implement it with InstancePerMatchingLifetimeScope or InstancePerLifetimeScope.

Here's how you configure your container

private IContainer Build()
{
    ContainerBuilder builder = new ContainerBuilder();

    builder.RegisterType<A>().As<IA>().InstancePerMatchingLifetimeScope("SomeTag");
    builder.RegisterType<B>().As<IB>().InstancePerMatchingLifetimeScope("SomeTag");
    builder.RegisterType<C1>();

    return builder.Build();
}

Here's how you use it

[Test]
public void PerGraphLifeStyle()
{
    var container = Build();

    C1 c1;
    C1 c2;
    using (var scope = container.BeginLifetimeScope("SomeTag"))
    {
        c1 = scope.Resolve<C1>();
        Assert.AreSame(c1.A, c1.B.A);
    }

    using (var scope = container.BeginLifetimeScope("SomeTag"))
    {
        c2 = scope.Resolve<C1>();
        Assert.AreSame(c1.A, c1.B.A);
    }

    Assert.AreNotSame(c1.A, c2.A);
}

Dummy classes I created for testing are below

internal interface IA
{
}

class A : IA
{

}

internal interface IB
{
    IA A { get; set; }
}

class B : IB
{
    public B(IA a)
    {
        A = a;
    }

    public IA A { get; set; }
}
class C1
{
    public IA A { get; set; }
    public IB B { get; set; }

    public C1(IA a, IB b)
    {
        A = a;
        B = b;
    }
}

edited May 23 '17 at 12:14

Community

1
1

answered May 12 '15 at 21:57

Sriram Sakthivel

72,067
7
111
189

Thanks for the excellent code demonstration. I'll have to think on this a little farther as I don't actually call `Resolve` on any of my C objects. They're all a ways down the chain. I only resolve a couple of high level objects out of my container and the rest (600ish) are filled in through factories and construction of necessary constructor dependencies. – Brannon May 12 '15 at 22:23
@Brannon I know it is a pain if you don't call `Resolve` yourself for these objects. One way is to hide these code inside the factory class. So you call `factory.CreateC1()` factory will encapsulate a container and create LifetimeScope and call resolve for you. – Sriram Sakthivel May 13 '15 at 06:44
Autofac directly supports "instance-per-graph" with `InstancePerOwned` lifetime (very similar to how DryIoc does it): `c.RegisterType().InstancePerOwned(); // A is reused in C` – dadhi May 25 '15 at 07:37
@dadhi Is it same as the instance per graph? It forces us to use `Owned` type in our entity right? Which means we're tightly coupled to our IOC container --which is a bad thing. Correct me if I'm wrong. – Sriram Sakthivel May 25 '15 at 07:41
There are pros and cons to the approach, but that's another thing: pros: Using Owned easily provides IDispose for you. cons: Yes, you need to reference container to use Owned wrapper. DryIoc supports this without wrapper, but to be able to Dispose - you still need `ResolutionScoped`. – dadhi May 25 '15 at 07:42
__Update:__ Now DryIoc rc1 is capable to inject `IDisposable scope` so you can control scope disposal without additional wrappers. – dadhi Jun 03 '15 at 08:11

Resolve parameters according to the parent tree that triggered the resolve?

2 Answers2