How to properly use Ninject's NamedScope extension?

Question

I have a pattern that comes up all the time when I'm working. I am almost exclusively a web developer, and Ninject's InRequestScope handles 99% of my needs.

Here's the pattern:

// abstractions

interface IFoo {
    void FooMe();
    int GetSomeValue();
}

interface IBar {
    void BarMe();
}

interface IFooBar {
    void FooAndBar();
}

// concrete classes

class Foo : IFoo {
    public void FooMe() { Console.WriteLine("I have fooed"); }
    public void GetSomeValue() { return 123; }
}

class Bar : IBar {
    private readonly IFoo _Foo;

    public Bar(IFoo foo) { _Foo = foo; }

    public void BarMe() { Console.WriteLine("Bar: {0}", _Foo.GetSomeValue()); }
}

class FooBar : IFooBar {
    private readonly IFoo _Foo;
    private readonly IBar _Bar;

    public Bar(IFoo foo, IBar bar) { _Foo = foo; _Bar = bar; }
    public void FooAndBar() {
        _Foo.FooMe();
        _Bar.BarMe();
    }
}

// bindings
kernel.Bind<IFoo>().To<Foo>();
kernel.Bind<IBar>().To<Bar>();
kernel.Bind<IFooBar>().To<FooBar>();

What I want to do is set it up such that every time I kernel.Get<IFooBar> it creates exactly one Foo and injects it into the constructors of both Bar and FooBar.

I've experimented with this off and on using the Named Scope extension, but I've never been able to get it to work.

What is the proper binding syntax for this?

...sounds to me like you want `InSingletonScope` ... is that not the case? — Simon Whitehead, Aug 20 '14 at 23:11
No, each time I call Get to get a IFooBar, I want new instances of Foo, Bar, and FooBar, but only a single Foo shared between Bar and FooBar. — Bryan Slatner, Aug 21 '14 at 14:00

score 2 · Accepted Answer · answered Aug 21 '14 at 05:12

2

so what you've got to do is define some name:

const string FooBarScopeName = "FooBarScope";

and then define the scope:

kernel.Bind<IFooBar>().To<FooBar>()
      .DefinesNamedScope(FooBarScopeName);

and bind the Foo in the named scope (the name must match!):

kernel.Bind<IFoo>().To<Foo>();
      .InNamedScope(FooBarScope);

Alternative:

There's also InCallScope() which can be used if there's one kernel.Get() for each time a IFooBar is created. In that case, simply do:

kernel.Bind<IFoo>().To<Foo>().InCallScope();

answered Aug 21 '14 at 05:12

BatteryBackupUnit

12,934
1
42
68

1

InCallScope seems to do what I want for this particular application. I put together a complete test project and fiddled with it. I think where I ran into trouble before with named scopes is that once you start using them you wind up creating a lot of them. At least in my case. It seemed so inelegant that I figured there must be a better way. – Bryan Slatner Aug 21 '14 at 21:23

How to properly use Ninject's NamedScope extension?

1 Answers1