Comment implémenter un singleton en C#?

Si vous êtes juste le stockage de certaines valeurs et certaines des méthodes qui n'ont pas besoin de l'état, vous n'avez pas besoin de singleton. Juste faire de la classe et de ses propriétés et méthodes statiques.

public static class GlobalSomething
{
   public static int NumberOfSomething { get; set; }

   public static string MangleString( string someValue )
   {
   }
}

Singleton est plus utile lorsque vous avez une classe normale de l'état, mais vous voulez seulement l'un d'entre eux. Les liens que d'autres ont fourni doit être utile dans l'exploration du pattern Singleton.

Singletons n'a de sens que si les deux de ces conditions est vraie:

1. L'objet doit être mondiale
2. Il ne doit jamais exister une unique instance de l'objet

Noter que le n ° 2 ne signifie pas que vous auriez comme l'objet n'avoir qu'un seul exemple - si c'est le cas, il suffit d'instancier qu'une seule fois - il n'y a doit (comme dans l', c'est dangereux pour ce n'est pas vrai) ne sera jamais que d'une seule instance.

Si vous voulez mondiale, il suffit de faire une instance globale de certains (non signleton) de l'objet (ou le rendre statique ou quoi que ce soit).
Si vous souhaitez qu'une seule instance, à nouveau, statique est votre ami. Aussi, il suffit d'instancier un objet.

C'est mon avis de toute façon.

Hmm, tout cela semble un peu complexe.

Pourquoi avez-vous besoin d'une injection de dépendance cadre pour obtenir un singleton? À l'aide d'un conteneur IOC est très bien pour certains, enterprise application, (tant que ce n'est pas galvaudé, bien sûr), mais, ah, le mec veut juste savoir aboiut mise en œuvre du modèle.

Pourquoi ne pas toujours avec impatience instancier, puis fournir une méthode qui retourne la statique, la plupart du code écrit ci-dessus puis s'en va. Suivre l'ancienne C2 adage - DoTheSimplestThingThatCouldPossiblywork...

En ignorant la question de savoir si ou non vous devriez être en utilisant le pattern Singleton, qui a été discuté ailleurs, je voudrais mettre en œuvre un singleton comme ceci:

///<summary>
///Thread-safe singleton implementation
///</summary>
public sealed class MySingleton {

    private static volatile MySingleton instance = null;
    private static object syncRoot = new object();

    ///<summary>
    ///The instance of the singleton
    ///safe for multithreading
    ///</summary>
    public static MySingleton Instance {
        get {
            //only create a new instance if one doesn't already exist.
            if (instance == null) {
                //use this lock to ensure that only one thread can access
                //this block of code at once.
                lock (syncRoot) {
                    if (instance == null) {
                        instance = new MySingleton();
                    }
                }
            }
            //return instance where it was just created or already existed.
            return instance;
        }
    }


    ///<summary>
    ///This constructor must be kept private
    ///only access the singleton through the static Instance property
    ///</summary>
    private MySingleton() {

    }

}

public class Globals
{
    private string setting1;
    private string setting2;

    #region Singleton Pattern Implementation

    private class SingletonCreator
    {
        internal static readonly Globals uniqueInstance = new Globals();

        static SingletonCreator()
        {
        }
    }

    ///<summary>Private Constructor for Singleton Pattern Implementaion</summary>
    ///<remarks>can be used for initializing member variables</remarks>
    private Globals()
    {

    }

    ///<summary>Returns a reference to the unique instance of Globals class</summary>
    ///<remarks>used for getting a reference of Globals class</remarks>
    public static Globals GetInstance
    {
        get { return SingletonCreator.uniqueInstance; }
    }

    #endregion

    public string Setting1
    {
        get { return this.setting1; }
        set { this.setting1 = value; }
    }

    public string Setting2
    {
        get { return this.setting2; }
        set { this.setting2 = value; }
    }

    public static int Constant1 
    {
        get { reutrn 100; }
    }

    public static int Constat2
    {
        get { return 200; }
    }

    public static DateTime SqlMinDate
    {
        get { return new DateTime(1900, 1, 1, 0, 0, 0); }
    }

}

Ce que vous décrivez est statique des fonctions et des constantes, pas un singleton. Le modèle de conception singleton (ce qui est très rarement nécessaire) décrit une classe qui est instancié, mais une seule fois, automatiquement, lors de la première utilisation.

Il combine l'initialisation tardive avec un contrôle pour éviter que plusieurs d'instanciation. Il n'y a vraiment utile pour les classes qui encapsulent un concept qui est physiquement singulier, comme un wrapper autour d'un périphérique matériel.

Statique des constantes et des fonctions sont ce qu'ils sont: le code qui n'a pas besoin d'une instance à tous.

Demandez-vous ceci: "cette pause de la classe si il n'y a plus d'une instance de celui-ci?" Si la réponse est non, vous n'avez pas besoin d'un singleton.

Personnellement, je pencherais pour une injection de dépendance cadre, à l'instar de l'Unité, tous d'entre eux sont en mesure de configurer singleton éléments dans le conteneur, et permettrait d'améliorer le couplage par le déplacement d'une classe de la dépendance à l'interface de la dépendance.

J'ai écrit une classe pour mon projet en utilisant le pattern Singleton. Il est très facile à utiliser. Espérons que cela fonctionnera pour vous. Veuillez trouver le code qui suit.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace TEClaim.Models
{
public class LogedinUserDetails
{
    public string UserID { get; set; }
    public string UserRole { get; set; }
    public string UserSupervisor { get; set; }
    public LogedinUserDetails()
    {

    }

    public static LogedinUserDetails Singleton()
    {
        LogedinUserDetails oSingleton;

        if (null == System.Web.HttpContext.Current.Session["LogedinUserDetails"])
        {               
            oSingleton = new LogedinUserDetails();
            System.Web.HttpContext.Current.Session["LogedinUserDetails"] = oSingleton;
        }
        else
        {              
            oSingleton = (LogedinUserDetails)System.Web.HttpContext.Current.Session["LogedinUserDetails"];
        }

        //Return the single instance of this class that was stored in the session
        return oSingleton;
    }
}
}

Maintenant, vous pouvez définir la valeur de la variable pour le code ci-dessus dans votre application comme cela..

[HttpPost]
public ActionResult Login(FormCollection collection)
{
  LogedinUserDetails User_Details = LogedinUserDetails.Singleton();
  User_Details.UserID = "12";
  User_Details.UserRole = "SuperAdmin";
  User_Details.UserSupervisor = "815978";
  return RedirectToAction("Dashboard", "Home");
}

Et vous pouvez récupérer les valeur comme cela..

public ActionResult Dashboard()
    {
        LogedinUserDetails User_Details = LogedinUserDetails.Singleton();
        ViewData["UserID"] = User_Details.UserID;
        ViewData["UserRole"] = User_Details.UserRole;
        ViewData["UserSupervisor"] = User_Details.UserSupervisor;

        return View();
    }

public class Singleton
{
   private static Singleton _instance;
   public static Singleton Instance => _instance ?? (_instance = new Singleton());
}