Una nuova iniezione di dipendenza e sto cercando di capire se si tratta di un pattern anti.Iniettare l'iniettore delle dipendenze usando l'iniezione delle dipendenze
Diciamo che ho 3 gruppi:
Foo.Shared - this has all the interfaces
Foo.Users - references Foo.Shared
Foo.Payment - references Foo.Shared
Foo.Users ha bisogno di un oggetto che è costruito all'interno Foo.Payment, e Foo.Payment ha bisogno anche roba da Foo.Users. Questo crea una sorta di dipendenza circolare.
Ho definito un'interfaccia in Foo.Shared che esegue il proxy del framework di Dipendenza Injection che sto utilizzando (in questo caso NInject).
public interface IDependencyResolver
{
T Get<T>();
}
nell'applicazione contenitore, ho un'implementazione di questa interfaccia:
public class DependencyResolver:IDependencyResolver
{
private readonly IKernel _kernel;
public DependencyResolver(IKernel kernel)
{
_kernel = kernel;
}
public T Get<T>()
{
return _kernel.Get<T>();
}
}
La configurazione è simile al seguente:
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
...
}
}
Questo mi permette di creare un'istanza di un nuovo oggetto di Foo.Payment.SomeType
dall'interno di Foo.Users senza bisogno di un riferimento diretto:
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
}
}
Ciò rende poco chiaro quali siano esattamente le dipendenze della classe UserAccounts
in questa istanza, il che mi fa pensare che non sia una buona pratica.
In quale altro modo posso ottenere questo risultato?
Qualche idea?
+1 solo per il titolo di scioglilingua. – womp
stesso, adoro il titolo :) –