Wie implementiert man ein Singleton in C #?

Wenn Sie nur die Speicherung einige Globale Werte und haben einige Methoden, die nicht brauchen, Staat, brauchen Sie nicht, singleton. Stellen Sie einfach die Klasse und Ihre Eigenschaften/Methoden statisch.

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

   public static string MangleString( string someValue )
   {
   }
}

Singleton ist besonders nützlich, wenn Sie eine normale Klasse mit dem Staat, aber Sie wollen nur eine von Ihnen. Die links, die andere zur Verfügung gestellt haben sollte nützlich sein bei der Erforschung des Singleton-Musters.

InformationsquelleAutor der Antwort tvanfosson

Können Sie wirklich vereinfachen Sie die singleton-Implementierung, das ist, was ich verwenden:

    internal FooService() { }        
    static FooService() { }

    private static readonly FooService _instance = new FooService();

    public static FooService Instance
    {
        get { return _instance; }
    }

InformationsquelleAutor der Antwort FlySwat

Singletons nur dann Sinn machen, wenn beide der folgenden Bedingungen erfüllt sind:

1. Das Objekt muss globalen
2. Es muss nur einmal vorhanden sein einer single Instanz des Objekts

Beachten Sie, dass #2 nicht bedeutet, dass Sie würde wie das Objekt nur eine einzige Instanz - wenn das der Fall ist, einfach instanziieren Sie es nur einmal - es bedeutet, dass es muss (wie in, es ist gefährlich, für die dies nicht der Fall ist) immer nur eine einzige Instanz.

Wenn Sie möchten, dass global nur eine Globale Instanz von einige (nicht signleton) Objekt (oder machen es statische oder was auch immer).
Wenn Sie möchten, dass nur eine Instanz, wieder statisch ist dein Freund. Auch, einfach nur ein Objekt instanziieren.

Das ist meiner Meinung nach sowieso.

InformationsquelleAutor der Antwort Dan

Ignorierte die Frage von, ob oder nicht Sie sollten mit den Singleton-Muster, die schon an anderer Stelle diskutiert, ich würde implementieren eines singleton wie diese:

///<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() {

    }

}

InformationsquelleAutor der Antwort Sam Meldrum

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); }
    }

}

InformationsquelleAutor der Antwort awaisj

Was Sie beschreiben, ist lediglich statische Funktionen und Konstanten, nicht ein singleton. Das singleton-design-Muster (das ist sehr selten nötig) beschreibt eine Klasse, die ist instanziiert, aber nur einmal, automatisch, wenn Sie erstmals verwendet werden.

Er verbindet lazy-Initialisierung mit einem Scheck zu verhindern mehrfacher Instanziierung. Es ist nur wirklich nützlich für Klassen, wickeln Sie einige Konzept, das physisch in der Einzahl, wie ein wrapper um ein hardware-Gerät.

Statische Konstanten und Funktionen sind genau das: code, der braucht nicht eine Instanz auf alle.

Fragen Sie sich diese: "Wird diese Klasse zu brechen, wenn es mehr als eine Instanz?" Wenn die Antwort ist Nein, brauchen Sie nicht ein singleton.

InformationsquelleAutor der Antwort munificent

Ich würde persönlich gehen für ein dependency injection-framework, wie Unity, alle von Ihnen sind in der Lage, zu konfigurieren singleton-Objekte in den container und verbessern würde Kopplung durch den Wechsel von einer Klasse in Abhängigkeit von interface-Abhängigkeit.

InformationsquelleAutor der Antwort t3mujin

Ich geschrieben habe eine Klasse für mein Projekt die Verwendung des Singleton-Musters. Es ist sehr einfach zu bedienen. Hoffe, es wird für Sie arbeiten. Finden Sie bitte den folgenden code.

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;
    }
}
}

Nun kann der Variablen-Wert für den obigen code in Ihrer Anwendung wie diese..

[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");
}

Und können Sie abrufen dieser Wert wie diese..

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();
    }

InformationsquelleAutor der Antwort Sapnandu