Come utilizzare un provider in Ninject

Question

Ho il seguente codice

public class Something { 
    [Inject] 
    public Configuration config {get;set;} //singleton 
    [Inject] 
    public Provider<WindowHandler> windowsProvider { get; set; } //NOT singleton 

    public void Search(string text) { 
     WindowHandler handler = windowsProvider.Create(xxxxxx); 
     //use the new handler that was created 
    } 
} 

ma sembra il provider prende un IContext dove ho messo xxxxxx. Non dovrei usare IContext da quando ho fatto il bootstrap e creato Something.cs dal kernel. Dov'è il parametro no Create metodo sul provider ??? (Vengo dal punto di vista della terra di Guice dove sarebbe codificato come sopra).

quindi la domanda è Come faccio a farlo correttamente?

grazie, Dean

Answer 1

Sembra che si sta tentando di utilizzare un provider come una fabbrica nel codice.

Un provider in termini di Ninject è una factory che viene fornita a Ninject per creare oggetti creati appositamente. Pertanto ottiene il contesto risolvibile che può essere utilizzato per creare istanze diverse a seconda dell'istanza in cui viene iniettata.

public class FooProvider : Provider<IFoo> 
{ 
    public override IFoo CreateInstance(IContext ctx) 
    { 
     // add here your special IFoo creation code 
     return new Foo(); 
    } 
} 

kernel.Bind<IFoo>().ToProvider<FooProvider>(); 

Ciò che si vuole è una fabbrica nella vostra coder che crea un'istanza di WindowHandler. Quindi creare un'interfaccia per creare l'esempio così:

public interface IWindowHandlerFactory 
{ 
    WindowHandler Create(); 
} 

Bind<IWindowHandlerFactory>().ToFactory(); 

alternativa si può iniettare Func<WindowHandler> senza aggiungere una configurazione. Ma questo è meno significativo a mio parere.

NOTA: Tutto questo richiede Ninject.Extensions.Factory disponibile come versione preliminare 3.0.0-rc2 da Nuget.

Consulta anche: http://www.planetgeek.ch/2011/12/31/ninject-extensions-factory-introduction/

Answer 2

Beh, la mia soluzione finale era quello di imbrogliare in Ninject 2.0 con il seguente codice ...

 var windowFactory = kernel.Get<IEWindowFactory>(); 
     var tabFactory = kernel.Get<IETabFactory>(); 
     windowFactory.Kernel = kernel; 
     tabFactory.Kernel = kernel; 

e nell'elenco binding devo

Bind<IEWindowFactory>().ToSelf().InSingletonScope(); 
Bind<IETabFactory>().ToSelf().InSingletonScope(); 

e successivamente avvio la mia app

var main = kernel.Get<MainForm>(); 
main.Start(); 

e naturalmente le fabbriche vengono iniettate dove ne ho bisogno nella gerarchia di quel MainForm.

così ho messo il kernel manualmente all'avvio e quando ho riavviato la mia app, naturalmente queste fabbriche sono campi in classi con l'annotazione [Ninject] e quindi possono creare oggetti. non è il più pulito finché non otteniamo 3.0, ma funziona (e odio le classi di produzione extra che devo scrivere per il codice, ma vabbè).