Bastante nuevo en la inyección de dependencia y estoy tratando de averiguar si este es un patrón anti.

Digamos que tengo 3 asambleas:

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

Foo.Users necesita un objeto construido dentro de Foo.Payment, y Foo.Payment también necesita cosas de Foo.Users. Esto crea algún tipo de dependencia circular.

He definido una interfaz en Foo.Shared que promueve el marco de Inyección de Dependencias que estoy usando (en este caso, NInject).

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

En la aplicación contenedora, tengo una implementación de esta interfaz:

public class DependencyResolver:IDependencyResolver
{
    private readonly IKernel _kernel;

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

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

La configuración se ve así:

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

Esto me permite instanciar un nuevo objeto deFoo.Payment.SomeType Desde el interior de Foo.Users sin necesidad de una referencia directa:

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

Esto hace que no quede claro cuáles son las dependencias exactas de laUserAccounts Las clases son en este caso, lo que me hace pensar que no es una buena práctica.

¿De qué otra manera puedo lograr esto?

¿Alguna idea?