En évitant les variables statiques avec Singleton

Une manière d'utiliser un singleton (levée de http://msdn.microsoft.com/en-us/library/ff650316.aspx)

using System;

public class Singleton
{
   private static Singleton instance;

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new Singleton();
         }
         return instance;
      }
   }

   ///non-static members
   public string Foo { get; set; }        

}

Puis,

var foo = Singleton.Instance.Foo;
Singleton.Instance.Foo = "Potential thread collision here.";

Noter que le membre de l'instance est un champ statique. Vous ne pouvez pas mettre en œuvre un singleton sans l'aide d'une variable statique, et (me semble - il a été un certain temps) cette instance sera partagé entre toutes les demandes. À cause de cela, il est intrinsèquement pas thread-safe.

Au lieu de cela, envisager de placer ces valeurs dans une base de données ou d'autres persistante magasin c'est de fil en plus de l'environnement, et la création d'une classe qui s'interface avec la partie de votre base de données pour fournir un accès transparent.

public static class Foo
{
  public static string Bar
  {
    get { ///retrieve Bar from the db }
    set { ///update Bar in the db }
  }
}

OriginalL'auteur 3Dave

Laisser l'adresse de vos déclarations à la fois:

Un de mes collègues m'a dit que je devrais ne jamais utiliser de variables statiques parce que si vous changer en un seul endroit, ils sont changés partout.

Il semble assez clair que votre collègue signifie que la caractéristique fondamentale de la statique des variables: il y a seulement un instance d'une variable statique. N'importe comment beaucoup de cas de toute la classe que vous créez, tout accès à une variable statique est à la même variable. Il n'y a pas une variable distincte pour chaque instance.

Il m'a dit qu'au lieu d'utiliser des variables statiques, je devrais utiliser un Singleton).

Ce n'est pas bon mondiale conseils. Les variables statiques et les singletons ne sont pas en compétition les uns avec les autres et ne sont pas vraiment substituts les uns des autres. Un singleton est une instance d'une classe, géré de telle manière qu'une seule instance est possible de créer. Une variable statique est de même lié à un seul (statique) instance d'une classe, mais peut être attribué non seulement d'une instance de classe, mais tout type de données comme un scalaire. En réalité, à utiliser efficacement le pattern singleton, vous doit de le stocker dans une variable statique. Il n'y a pas de façon "d'utiliser un singleton au lieu d'une variable statique".

Sur l'autre main, peut-être qu'il voulait dire quelque chose de légèrement différent: peut-être qu'il essayait de dire qu'au lieu de votre classe statique avoir beaucoup de différentes variables statiques, la méthode, les propriétés et les champs (au total, membres) qui fonctionnent comme si elles étaient une classe, vous devez faire ces champs non statique, et d'exposer l'emballage de la classe comme une instance du Singleton. Vous auriez encore besoin d'un privé statique champ avec une méthode ou une propriété (ou peut-être juste utiliser une seule propriété) pour exposer le singleton.

Je sais que Singleton est pour limiter le nombre d'instances d'une classe à une. Comment peut-Singleton m'aider avec des variables statiques?

Une classe statique des variables et un singleton sont semblables en ce qu'ils sont à être instanciée qu'une seule fois (l'ancien appliquées par le compilateur et le dernier appliquées par votre mise en œuvre). La raison pour laquelle vous voulez utiliser un singleton au lieu d'une variable statique à l'intérieur d'une classe, c'est quand votre singleton doit être un vrai instance d'une classe, et consiste pas simplement de la collecte des membres statiques d'une classe statique. Ce singleton puis sera affectée à une variable statique de sorte que tous les appelants peuvent acquérir un exemplaire de cette même instance. Comme je l'ai dit ci-dessus, vous pouvez convertir tous les différents membres statiques de votre classe statique pour être membres de l'instance de votre nouveau non-statique de la classe qui vous permettra d'exposer comme un singleton.

Je tiens également à mentionner que les autres réponses données jusqu'à présent ont toutes les questions autour de la sécurité des threads. Ci-dessous sont quelques-uns de corriger les modèles pour la gestion des Singletons.

Vous pouvez voir qu'une instance de la Singleton classe, qui a de l'instance (ou non statique) membres, est créé soit par l'initialisation statique ou dans le constructeur statique, et est affecté à la variable _singleton.. Nous utilisons ce modèle pour s'assurer qu'il est instancié qu'une seule fois. Ensuite, la méthode statique Instance fournit un accès en lecture seule à la sauvegarde de champ variable, qui contient notre une, et une seule instance de Singleton.

public class Singleton {
   //static members
   private static readonly Singleton _singleton = new Singleton();
   public static Singleton Instance => _singleton

   //instance members
   private Singleton() { } //private so no one else can accidentally create an instance
   public string Gorp { get; set; }
}

ou, exactement la même chose mais avec un statique explicite constructeur:

public class Singleton {
   //static members
   private static readonly Singleton _singleton; //instead of here, you can...
   static Singleton() {
      _singleton = new Singleton(); //do it here
   }
   public static Singleton Instance => _singleton;

   //instance members
   private Singleton() { } //private so no one else can accidentally create an instance
   public string Gorp { get; set; }
}

Vous pouvez également utiliser une propriété par défaut sans un accord explicite de champ (à suivre) ou dans un constructeur statique peut affecter la seule propriété (non illustré).

public class Singleton {
   //static members
   public static Singleton Instance { get; } = new Singleton();

   //instance members
   private Singleton() { } //private so no one else can accidentally create an instance
   public string Gorp { get; set; }
}

Depuis constructeurs statiques sont garanti exactement une fois, qu'il soit implicite ou explicite, alors il y a sans fil les questions de sécurité. Notez que tout l'accès à la Singleton classe peut déclencher initialisation statique, même de type à réflexion accès.

Vous pouvez penser à des membres statiques d'une classe comme presque comme un distinct, bien relié, classe:

1. D'Instance (non statique) des membres de la fonction comme une classe normale. Ils ne vivent pas jusqu'à ce que vous effectuez new Class() sur eux. Chaque fois que vous faites new, vous obtenez une nouvelle instance. Les membres de l'Instance ont accès à tous les membres statiques, y compris les membres privés (dans la même classe).

2. Membres statiques sont comme les membres d'une autre, spécial instance de la classe que vous ne pouvez pas créer explicitement à l'aide de new. À l'intérieur de cette classe, seuls les membres statiques ne peuvent être accessibles ou de l'ensemble. Il y a un implicite ou explicite d'un constructeur statique qui .Net s'exécute à l'heure d'un premier accès (tout comme l'instance de classe, seulement vous n'avez pas explicitement le créer, il est créé si nécessaire). Les membres statiques d'une classe peuvent être consultées par tout autre classe, à tout moment, dans ou hors d'une instance, bien que dans le respect des modificateurs d'accès tels que internal ou private.

OriginalL'auteur ErikE

Juste pour répondre à votre question (je l'espère): au Lieu d'utiliser une classe statique contenant membres statiques comme Class1 vous pouvez implémenter le pattern Singleton comme dans Class2 (merci de ne pas commencer une discussion à propos de l'initialisation tardive à ce stade):

public static class Class1
{
    public static void DoSomething ()
    {
    }
}

public static class Class2
{
    private Class2() {
    }

    private Class2 instance;

    public Class2 GetInstance(){
        if (instance == null)
            instance = new Class2();
        return instance;
    }

    public void DoSomething ()
    {
    }
}

Au lieu de l'appeler Class1.DoSomething() vous pouvez utiliser Class2.GetInstance().DoSomething().

Edit: Comme vous pouvez le voir il y a encore un (privé) champ statique à l'intérieur de Class2 le tenant de l'instance.

Edit2 en réponse à user966638 commentaire:
Dois-je comprendre que vous corriger ce que vous avez le code comme ceci:

public class Foo {
    private static Bar bar;
}

Et votre collègue suggère de le remplacer par cela?

public class Foo {
    private BarSingleton bar;
}

Cela pourrait être le cas si vous voulez avoir différentes Foo cas où chaque instance, le bar de l'attribut peut être défini à null par exemple. Mais je ne suis pas sûr s'il voulait dire ce qu'est exactement le cas d'utilisation il parle.

OriginalL'auteur Silas