Question

I have a problem with Ninject trying to resolve an interface type where the concrete type derives from an abstract base class that implements the interface.

EDIT: This is on Windows Mobile using .NET CF.

My particular issue involves presenters and views, so I stick to that in this example instead of foos and bars.

I want to inject factories for presenters and views to allow for late creation of those instances deep down the UI view stack.

Below I’ve omitted all error checking for better readability.

My factory interface:

public interface IFactory<T>
{
    T Create();
}

My presenter and view:

public sealed class Presenter
{
    private readonly View view;

    public Presenter(View view)
    {
        this.view = view;
    }
}

public sealed class View
{
    public View()
    {
    }
}

First, I’ll show what works perfectly, that Ninject resolves as expected. This will not include the abstract base class I mentioned at the beginning. After this, I’ll add the slight modifications with the abstract base class that will make Ninject throw when trying to resolve the dependencies.

We see above that the presenter depends on the view, so the presenter factory will depend on the view factory:

public sealed class GoodPresenterFactory : IFactory<Presenter>
{
    private readonly IFactory<View> viewFactory;

    public GoodPresenterFactory(IFactory<View> viewFactory)
    {
        this.viewFactory = viewFactory;
    }

    public Presenter Create()
    {
        return new Presenter(this.viewFactory.Create());
    }
}

public sealed class ViewFactory : IFactory<View>
{
    public ViewFactory()
    {
    }

    public View Create()
    {
        return new View();
    }
}

Wiring this up with Ninject:

Bind<IFactory<Presenter>>().To<GoodPresenterFactory>();
Bind<IFactory<View>>().To<ViewFactory>();

And then resolving the presenter factory:

var presenterFactory = container.Get<IFactory<Presenter>>();

Everything up until now works perfectly. The dependency on the view factory inside the presenter factory is resolved as expected.

Now, I have a million classes that looks like GoodPresenterFactory above and I therefore wanted a small base class to handle some trivial common stuff, like the dependency on the view factory in the presenter factory:

public abstract class FactoryBase<T, U> : IFactory<T>
{
    protected readonly U dependency;

    protected FactoryBase(U dependency)
    {
        this.dependency = dependency;
    }

    public abstract T Create();
}

Then the presenter factory will change and something in that change will make Ninject fail resolving:

public sealed class BadPresenterFactory : FactoryBase<Presenter, IFactory<View>>
{
    public BadPresenterFactory(IFactory<View> viewFactory)
        : base(viewFactory)
    {
    }

    public override Presenter Create()
    {
        return new Presenter(this.dependency.Create());
    }
}

And changing the Ninject wiring accordingly:

Bind<IFactory<Presenter>>().To<BadPresenterFactory>();
Bind<IFactory<View>>().To<ViewFactory>();

Those changes will make Ninject throw an ArgumentNullException when doing

var presenterFactory = container.Get<IFactory<Presenter>>();

Call stack from the exception:

at System.Reflection.RuntimeMethodInfo.GetParentDefinition()
at System.Reflection.CustomAttribute.IsDefined(MemberInfo member, Type caType, Boolean inherit)
at System.Reflection.RuntimeMethodInfo.IsDefined(Type attributeType, Boolean inherit)
at System.Attribute.IsDefined(MemberInfo element, Type attributeType, Boolean inherit)
at System.Attribute.IsDefined(MemberInfo element, Type attributeType)
at Ninject.Infrastructure.Language.ExtensionsForMemberInfo.HasAttribute(MemberInfo member, Type type)
at Ninject.Selection.Heuristics.StandardInjectionHeuristic.ShouldInject(MemberInfo member)
at Ninject.Selection.Selector.<>c__DisplayClassa.<SelectMethodsForInjection>b__9(IInjectionHeuristic h)
at System.Linq.Enumerable.Any[TSource](IEnumerable`1 source, Func`2 predicate)
at Ninject.Selection.Selector.<SelectMethodsForInjection>b__8(MethodInfo m)
at System.Linq.Enumerable.<WhereIterator>d__0`1.MoveNext()
at Ninject.Planning.Strategies.MethodReflectionStrategy.Execute(IPlan plan)
at Ninject.Planning.Planner.<>c__DisplayClass2.<GetPlan>b__0(IPlanningStrategy s)
at Ninject.Infrastructure.Language.ExtensionsForIEnumerableOfT.Map[T](IEnumerable`1 series, Action`1 action)
at Ninject.Planning.Planner.GetPlan(Type type)
at Ninject.Activation.Providers.StandardProvider.Create(IContext context)
at Ninject.Activation.Context.Resolve()
at Ninject.KernelBase.<Resolve>b__4(IContext context)
at System.Linq.Enumerable.<SelectIterator>d__d`2.MoveNext()
at System.Linq.Enumerable.<CastIterator>d__b0`1.MoveNext()
at System.Linq.Enumerable.Single[TSource](IEnumerable`1 source)
at Ninject.ResolutionExtensions.Get[T](IResolutionRoot root, IParameter[] parameters)
at NinjectTest.Program.Main()

If I modify FactoryBase so that it has no dependency, it’s just a naked base class, then Ninject also fails.

public abstract class NakedFactoryBase<T> : IFactory<T>
{
    protected NakedFactoryBase()
    {
    }

    public abstract T Create();
}

public sealed class PointlessPresenterFactory : NakedFactoryBase<Presenter>
{
    private readonly IFactory<View> viewFactory;

    public PointlessPresenterFactory(IFactory<View> viewFactory)
    {
        this.viewFactory = viewFactory;
    }

    public override Presenter Create()
    {
        return new Presenter(this.viewFactory.Create());
    }
}

As you can see, that failing PointlessPresenterFactory is identical to the succeeding GoodPresenterFactory, apart from the direct IFactory<Presenter> implementation in GoodPresenterFactory, as opposed to the completeley naked base class used in PointlessPresenterFactory.

Any idea why Ninject fails to resolve when the factory base class is used?

Answer 1

This issue has been fixed in build 2.3.0.46 and will be part of the next release (2.4).

NOTE: because CF seems not to allow to detect is a method is generic or not the Inject attribute can not be defined on base methods anymore. It has to be defined on the overload method.