Całkiem nowy w wstrzykiwaniu zależności i próbuję dowiedzieć się, czy jest to anty-wzór.

Powiedzmy, że mam 3 zespoły:

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

Foo.Users potrzebuje obiektu zbudowanego w ramach Foo.Payment, a Foo.Payment także potrzebuje rzeczy z Foo.Users. Stwarza to pewnego rodzaju zależność kołową.

Zdefiniowałem interfejs w Foo.Shared, który pośredniczy w używanej przeze mnie strukturze Dependency Injection (w tym przypadku NInject).

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

W aplikacji kontenerowej mam implementację tego interfejsu:

public class DependencyResolver:IDependencyResolver
{
    private readonly IKernel _kernel;

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

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

Konfiguracja wygląda następująco:

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
        ...
    }
}

Dzięki temu mogę utworzyć instancję nowego obiektuFoo.Payment.SomeType od wewnątrz Foo.Users bez potrzeby bezpośredniego odniesienia:

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
    }
}

To sprawia, że ​​nie jest jasne, jakie dokładnie zależnościUserAccounts klasa jest w tym przypadku, co sprawia, że ​​myślę, że to nie jest dobra praktyka.

Jak inaczej mogę to osiągnąć?

jakieś pomysły?