Ziemlich neu in Dependency Injection und ich versuche herauszufinden, ob dies ein Anti-Pattern ist.Den Dependency Injector durch Dependency Injection injizieren
Sagen wir, ich habe 3 Baugruppen:
Foo.Shared - this has all the interfaces
Foo.Users - references Foo.Shared
Foo.Payment - references Foo.Shared
Foo.Users braucht ein Objekt, das innerhalb Foo.Payment gebaut wird, und Foo.Payment muss auch Sachen von Foo.Users. Dies schafft eine Art zirkuläre Abhängigkeit.
Ich habe in Foo.Shared eine Schnittstelle definiert, die das Dependency Injection-Framework, das ich verwende (in diesem Fall NInject), als Proxy verwendet.
public interface IDependencyResolver
{
T Get<T>();
}
In der Container-Anwendung 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 wie folgt 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
...
}
}
Dies ermöglicht es mir ein neues Objekt der Foo.Payment.SomeType zu instanziiert von innen Foo.Users ohne eine direkte Referenz benötigen:
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, was die genauen Abhängigkeiten der UserAccounts Klasse in diesem Fall sind, die mich denken, dass es keine gute Praxis ist.
Wie sonst kann ich das erreichen?
Irgendwelche Gedanken?
+1 nur für den Zungenbrecher Titel. – womp
gleich hier, ich liebe den Titel :) –