Muito novo na injeção de dependência e estou tentando descobrir se isso é um padrão anti.

Digamos que eu tenha 3 montagens:

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

Foo.Users precisa de um objeto que é construído dentro Foo.Payment, e Foo.Payment também precisa de material de Foo.Users. Isso cria algum tipo de dependência circular.

Eu defini uma interface em Foo.Shared que proxies a estrutura de Injeção de Dependência que estou usando (neste caso, NInject).

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

No aplicativo contêiner, eu tenho uma implementação dessa interface:

public class DependencyResolver:IDependencyResolver
{
    private readonly IKernel _kernel;

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

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

A configuração é assim:

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

Isso me permite instanciar um novo objeto deFoo.Payment.SomeType de dentro de Foo.Users sem precisar de uma referência direta:

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

Isso não deixa claro quais são as dependências exatas doUserAccounts classe estão neste caso, o que me faz pensar que não é uma boa prática.

Como mais posso fazer isso?

Alguma ideia?