Wie gebe ich einen parameter an den Konstruktor mit Einfachen Injektor?

Macht Einfach Injektor ermöglichen die übergabe von Parametern an den Konstruktor, wenn Sie das Problem beheben? Ich würde gerne wissen, ob diese beiden frameworks zu tun, was die Einheit ist ResolverOverride oder DependencyOverride beide tun.

InformationsquelleAutor der Frage Ray | 2014-02-14

  1. 18

    Ich vermute, dass diese Frage über den übergang der primitiven Werte an den Konstruktor zu der Zeit der service ist wirklich behoben.

    Lassen Sie uns eine einfache test-Klasse:

    public interface IFoo
{

}

public class Foo : IFoo
{
    public Foo(string value)
    {

    }
}

    Die Klasse "Foo nimmt einem string-argument, wir würden gerne liefern, wenn die Lösung der "ifoo") vom service.

    var container = new ServiceContainer();
container.Register<string, IFoo>((factory, value) => new Foo(value));
var firstFoo = container.GetInstance<string, IFoo>("SomeValue");
var secondFoo = container.GetInstance<string, IFoo>("AnotherValue");

    Wenn wir wollen, zu können, erstellen Sie neue Instanzen der Klasse " Foo ohne Verwendung der container direkt an, wir können einfach injizieren einer Funktion delegieren.

    public interface IBar { }

public class Bar : IBar
{
    public Bar(Func<string, IFoo> fooFactory)
    {
        var firstFoo = fooFactory("SomeValue");
        var secondFoo = fooFactory("AnotherValue");
    }
}

    Die "Zusammensetzung root" sieht nun wie folgt aus:

    var container = new ServiceContainer();
container.Register<string, IFoo>((factory, value) => new Foo(value));
container.Register<IBar, Bar>();
var bar = container.GetInstance<IBar>();

    Wenn die Frage über die übergabe eines "statischen" primitiven Wert an den contructor, das geschieht einfach durch die Registrierung einer factory delegieren, wie dies.

    var container = new ServiceContainer();
container.Register<IFoo>((factory) => new Foo("SomeValue"));
var firstInstance = container.GetInstance<IFoo>();
var secondInstance = container.GetInstance<IFoo>();

    Der Unterschied ist, dass dieser Ansatz nicht, lassen Sie Sie übergeben einen Wert, beheben Zeit. Der Wert ist statisch bei der Registrierung angegebenen Zeit.

    InformationsquelleAutor der Antwort seesharper

  2. 17

    Wahrscheinlich die einfachste option, mit Einfache Injektor ist die Registrierung mit einem Delegierten

    [Test]
public void Test1()
{
    Container container = new Container();

    container.Register<IClassWithParameter>(() => new ClassWithParameter("SomeValue"));

    var result = container.GetInstance<IClassWithParameter>();
}

public interface IClassWithParameter { }

public class ClassWithParameter : IClassWithParameter
{
    public ClassWithParameter(string parameter)
    {
    }
}

    Sich um eine erweiterte option für die Injektion primitive Abhängigkeiten detaillierte hier

    InformationsquelleAutor der Antwort qujck

  3. 3

    Den oben funktionieren, wenn Ihr Konstruktor hat keine weiteren Abhängigkeiten (oder Sie lösen diese Abhängigkeiten manuell). Wenn Sie müssen das Szenario unten, wenn es runterfällt:

    public class Test : ITest
{
   private IFoo _foo;
   public Test(string parameter, IFoo foo)
   {
      _foo = foo;
      ....
   }
}

    Nun haben Sie nicht nur manuell injizieren Sie die Zeichenfolge, sondern auch Foo. So, jetzt Ihr nicht mit Abhängigkeit Injektion an alle (wirklich). Auch Einfache Injektor Zustand:

    Einfache Injektor nicht erlauben, die Injektion primitiven Typen (wie
    Integer und string) in Konstruktoren.

    Meiner Lesart ist, dass Sie sagen "Tu das nicht".

    Extensibillity Punkte

    Eine weitere option ist die Verwendung "Extensibillity Punkte" für dieses Szenario.

    Um dies zu tun, müssen Sie Ihre abstrakten hard-codierte Elemente aus der injizierten Elemente:

    public class Test : ITest
{
   private IFoo _foo;
   public Test(IFoo foo)
   {
      _foo = foo;
      ....
   }

  public void Init(string parameter)
  {

  }
}

    Können Sie jetzt injizieren Sie Ihr dependanices und Ihre hardcoded Elemente:

    _container.Register<ITest, Test>();
_container.RegisterInitializer<Test>(instance => {instance.Init("MyValue");});

    Wenn Sie nun mit einer weiteren Abhängigkeit, der Injektion funktioniert nun ohne update der config, d.h. dein code ist schön entkoppelt noch:

    public class Test : ITest
{
   private IFoo _foo;
   private IBar _bar;
   public Test(IFoo foo, IBar bar)
   {
      _foo = foo;
      _bar = bar;
      ....
   }

  public void Init(string parameter)
  {

  }
}

    InformationsquelleAutor der Antwort Liam

Schreibe einen Kommentar