Façons d'installer un singleton Ninject

J'ai une classe (MyFacade) que j'ai injecté paramètre(s) avec Ninject:

class MyFacade
{
    IDemoInterface demo;

    public MyFacade(IDemoInterface demo)
    {
        this.demo = demo;
    }

    public void MyMethod()
    {
        Console.WriteLine(demo.GetInfo());
    }
}

Bien sûr, j'ai pour l'installation de l' Ninject pour injecter le cas de la mise en œuvre de mes paramètre (IDemoInterface)

Je sais, je peux instancier MyFacade objet en faisant kernel.Get<MyFacade>(); sans réglage de rien d'autre. Actuellement, mon façade ne dispose pas d'une interface (parce que c'est ma seule la mise en œuvre, peut-être que je vais ajouter son interface standard propose)

si je veux faire de cette façade singlenton, je connais deux façons: créer un constructeur vide et passer un paramètre en faisant cela, kernel.Get<IDemoInterface>(); ou par le programme d'installation Ninject comme: kernel.Bind<MyFacade>().To<MyFacade>().InSingletonScope();

Le deuxième look une meilleure approche, mais connaissez-vous une autre façon de le configurer dans un singleton?

source d'informationauteur Jaider

  1. 25

    Lors de la configuration de vos fixations, vous devez lier vos dépendances. Il est toujours préférable pour l'installation de vos dépendances dans vos fixations, à la différence d'une kernel.Get<T>() dans un constructeur. Vous êtes à l'aide du CIO, afin de tirer parti du framework que vous utilisez pour faire l'injection pour vous.

    Dans votre deuxième exemple de liaison, ce qui vous manque est obligatoire dans votre IDemoInterface. Vos fixations devrait ressembler à ceci:

    //bind the dependency to the implementation.
kernel.Bind<IDemoInterface>().To<DemoInterface>();
//since you bound your dependency, ninject should now have 
//all the dependencies required to instantiate your `MyFacade` object.
kernel.Bind<MyFacade>.To<MyFacade>().InSingletonScope();
  2. 4

    Si vous ne souhaitez pas que le conteneur pour gérer le cycle de vie de votre singleton en utilisant InSingletonScope()mais veut toujours à obtenir de l'injection, je pense, de 2 façons d'aller à ce sujet. De choisir celui qui convient le mieux à vos besoins. Considérez les points suivants ISingleton (nom de votre interface) mise en œuvre:

    public class ConcreteSingleton : ISingleton
{
    private static readonly Lazy<ConcreteSingleton> _instance = new Lazy<ConcreteSingleton>(() => new ConcreteSingleton());

    private ConcreteSingleton() { }

    public static ConcreteSingleton Instance
    {
        get
        {
            return _instance.Value;
        }
    }
}

    1. Modifier la classe singleton avoir un GetInstance(...) méthode

      Dans cette méthode (mon préféré), vous ne serez pas à l'appel de kernel.Inject(instance) à chaque fois, seulement pour la première fois le singleton est initialisé. Ajout de la méthode suivante pour votre ConcreteSingleton classe:

      public static ConcreteSingleton GetInstance(IKernel kernelForInjection)
{
    if (_instance.IsValueCreated == false)
    {
        kernelForInjection.Inject(_instance.Value);
    }

    return _instance.Value;
}

      Et à l'aide de cette liaison:

      kernel.Bind<ISingleton>().ToMethod(c => ConcreteSingleton.GetInstance(c.Kernel));

      Permettra d'obtenir le comportement souhaité de ne pas avoir de constructeur public, mais l'activation de votre façade pour être efficace injecté.

    2. Effectuer l'injection à chaque fois que le ISingleton instance est demandé

      Si pour une raison quelconque vous n'êtes pas autorisé à modifier vos ConcreteSingleton: Cette approche permettra d'envelopper le singleton création en un prestataire de services de manière efficace d'injecter de l'instance pour la première fois, il est créé. Il est important de noter que le fournisseur lui-même doit être enregistré comme un singleton.

      internal class ConcreteSingletonProvider : Provider<ISingleton>
{
    public IKernel Kernel { get; set; }

    //Just a wrapper
    private readonly Lazy<ISingleton> _lazy = new Lazy<ISingleton>(() => ConcreteSingleton.Instance);

    public ConcreteSingletonProvider(IKernel kernel)
    {
        Kernel = kernel;
    }

    protected override ISingleton CreateInstance(IContext context)
    {
        if (_lazy.IsValueCreated == false)
        {
            Kernel.Inject(ConcreteSingleton.Instance);
        }
        return _lazy.Value;
    }
}

      Et de vos fixations doivent être comme ceci:

      kernel.Bind<ISingleton>().ToProvider<ConcreteSingletonProvider>();
kernel.Bind<ConcreteSingletonProvider>().ToSelf().InSingletonScope();

      Ce gist a un travail complet de l'échantillon pour l'approche ci-dessus.

    Espère que ça aide!