Die Abhängigkeitsinjektion ist ziemlich neu und ich versuche herauszufinden, ob dies ein Anti-Muster ist.

Angenommen, ich habe 3 Baugruppen:

Foo.Shared - this has all the interfaces
Foo.Users - references Foo.Shared
Foo.Payment - references Foo.Shared

Foo.Users benötigt ein Objekt, das innerhalb von Foo.Payment erstellt wurde, und Foo.Payment benötigt auch Inhalte von Foo.Users. Dies schafft eine Art zirkuläre Abhängigkeit.

Ich habe in Foo.Shared eine Schnittstelle definiert, die das von mir verwendete Dependency Injection-Framework (in diesem Fall NInject) ersetzt.

public interface IDependencyResolver
{
    T Get<T>();
}

In der Containeranwendung habe ich eine Implementierung dieser Schnittstelle:

public class DependencyResolver:IDependencyResolver
{
    private readonly IKernel _kernel;

    public DependencyResolver(IKernel kernel)
    {
        _kernel = kernel;
    }

    public T Get<T>()
    {
        return _kernel.Get<T>();
    }
}

Die Konfiguration sieht folgendermaßen aus:

public class MyModule:StandardModule
{
    public override void Load()
    {
        Bind<IDependencyResolver>().To<DependencyResolver>().WithArgument("kernel", Kernel);
        Bind<Foo.Shared.ISomeType>().To<Foo.Payment.SomeType>(); // <- binding to different assembly
        ...
    }
}

Dadurch kann ich ein neues Objekt von instanziierenFoo.Payment.SomeType von innerhalb von Foo.Users ohne direkten Bezug:

public class UserAccounts:IUserAccounts
{
    private ISomeType _someType;
    public UserAccounts(IDependencyResolver dependencyResolver)
    {
        _someType = dependencyResolver.Get<ISomeType>(); // <- this essentially creates a new instance of Foo.Payment.SomeType
    }
}

Dies macht es unklar, welche genauen Abhängigkeiten derUserAccounts Klasse sind in diesem Fall, was mich denken lässt, dass es keine gute Praxis ist.

Wie kann ich das sonst noch erreichen?

Irgendwelche Gedanken?