如何設計一個可以僅由1個類實例化的單例

Question

我想設計一個類，它將以類似於單例的方式存在，該類將有一個主實例，但也可能有多個克隆的主要實例。只有1個類可以創建主實例，其他人都可以創建一個克隆。像這樣的東西（c＃）：

class Singleton 
{ 
    private static Singleton _mainInstance; 
    private Singleton() {..} 
    public void Clone() {..} 

    public static Singleton MainInstance 
    { 
     if (_mainInstance == null) 
     { 
      _mainInstance = new Singleton();  // how to secure this for only 1 class? 
     } 
     return _mainInstance; 
    } 
} 


class MainClass 
{ 
    public MainClass() 
    { 
     Singleton.MainInstance .... 
    } 
} 

MainClass應該是唯一允許實例化單例的類。在C++中，可以通過完全隱藏創建邏輯並將MyClass作爲Singleton的朋友來完成。

Answer 1

下面是一個完整的工作實現，演示了兩種可能的方法來完成你想要的。

這兩種方法都使用工廠概念;由於Singleton的構造函數是私有的，因此只有嵌套的Factory類才能創建Singleton類的新實例。由於嵌套Factory類本身是私有的，獲得工廠實例的唯一方法是通過Singleton.GetFactoryFirstOneWins方法（「第一個獲勝」方法）或Singleton.AssignFactories方法（「間接分配」方法）。

interface IFactory<T> 
{ 
    T CreateInstance(); 
} 

class Singleton 
{ 
    class Factory : IFactory<Singleton> 
    { 
     public Singleton CreateInstance() 
     { 
      // return a clone of _MainInstance 
      return new Singleton(_MainInstance); 
     } 
    } 

    // *** Begin "First one wins" approach 
    static IFactory<Singleton> _FactoryFirstOneWins; 

    public static IFactory<Singleton> GetFactoryFirstOneWins() 
    { 
     if (_FactoryFirstOneWins != null) 
      throw new InvalidOperationException("A factory has already been created."); 

     return _FactoryFirstOneWins = new Factory(); 
    } 
    // *** End "First one wins" approach 

    // *** Begin "Indirect assignment" approach 
    public static void AssignFactories() 
    { 
     MainClass.SingletonFactory = new Factory(); 
    } 
    // *** End "Indirect assignment" approach 

    private static readonly Singleton _MainInstance = new Singleton(); 

    public static Singleton MainInstance 
    { 
     get { return _MainInstance; } 
    } 

    private Singleton() 
    { 
     // perform initialization logic 
     this.SomeValue = 5; // pick some arbitrary number 
    } 

    private Singleton(Singleton instance) 
    { 
     // perform cloning logic here to make "this" a clone of "instance" 
     this.SomeValue = instance.SomeValue; 
    } 

    public int SomeValue { get; set; } 

    public void DoSomething() 
    { 
     Console.WriteLine("Singleton.DoSomething: " + this.SomeValue); 
     // ... 
    } 
} 


class MainClass 
{ 
    private static IFactory<Singleton> _SingletonFactory; 

    public static IFactory<Singleton> SingletonFactory 
    { 
     get { return _SingletonFactory; } 
     set { _SingletonFactory = value; } 
    } 

    public Singleton Singleton { get; private set; } 

    public MainClass() 
    { 
     this.Singleton = SingletonFactory.CreateInstance(); 
    } 

    public void DoWork() 
    { 
     Console.WriteLine("MainClass.DoWork"); 
     this.Singleton.DoSomething(); 
     // ... 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     // you could either use the "First one wins" approach 
     MainClass.SingletonFactory = Singleton.GetFactoryFirstOneWins(); 

     // or use the "Indirect assignment" approach 
     Singleton.AssignFactories(); 

     // create two separate MainClass instances 
     MainClass mc1 = new MainClass(); 
     MainClass mc2 = new MainClass(); 

     // show that each one utilizes a Singleton cloned from Singleton.MainInstance 
     mc1.DoWork(); 
     mc2.DoWork(); 

     // updating mc1.Singleton.SomeValue does not affect any other instances of MainClass 
     mc1.Singleton.SomeValue = 7; 
     mc1.DoWork(); 
     mc2.DoWork(); 

     // updating Singleton.MainInstance.SomeValue affects any new instances of MainClass, but not existing instances 
     Singleton.MainInstance.SomeValue = 10; 
     MainClass mc3 = new MainClass(); 
     mc1.DoWork(); 
     mc2.DoWork(); 
     mc3.DoWork(); 
    } 
} 

Answer 2

你可以簡單地在你的類中使用帶有私有靜態字段的Singleton模式。

像這樣：

class Singleton 
{ 
    private static Singleton _mainInstance = new Singleton(); 
    private Singleton() { } 
    public void Clone() {..} 

    public static Singleton MainInstance 
    { 
     return _mainInstance; 
    } 
} 

你將有你的存儲類的_mainInstance靜態字段裏面你唯一的實例，就不可能創造任何其他實例。

Answer 3

單例模式意味着只有一個該類的實例。如果你的類有某種克隆方法，那麼每個人都可以克隆這個實例。所以我看不到你的問題。

您的單例執行幾乎是正確的，只有_mainInstance和MainInstance需要爲static。

Answer 4

您可以使用內部的構造函數只有在其裝配其他類使一個類實例化的：

class InternalInstantiation { 
    internal InternalInstantiation() {} 
    public void Clone() {} 
} 

class MainClass { 
    private InternalInstantiation _instance = 
    new InternalInstantiation(); 
} 

此外，您還可以嵌套在另一個內部類實例化一個類有私有構造函數。

class PrivateInstantiation { 
    private PrivateInstantiation() { } 
    public void Clone() {} 

    public class MainClass { 
    private PrivateInstantiation _instance = 
     new PrivateInstantiation(); 
    } 
} 

您還可以創建私有實例化的類中的主類注入它的一個實例（沒有其他類可以使用）方案：

public class MainClass { 
    internal PrivateInstantiation PrivateInstantiation { get; set; } 
    public MainClass() { 
    PrivateInstantiation.CreateAndSet(this); 
    } 
} 

class PrivateInstantiation { 
    private PrivateInstantiation() { } 
    public void Clone() {} 
    public static void CreateAndSet(MainClass mc) { 
    mc.PrivateInstantiation = new PrivateInstantiation(); 
    } 
} 

請注意，我沒有打電話你的班級是一個單身人士，因爲Clone方法的出現似乎並沒有使它成爲一個單身人士。

Answer 5

讓我們試試吧：你需要prototype模式，而不是單身。

The PROTOTYPE PATTERN comes under the classification of Creational Patterns. The creational patterns deals with the best way to create objects. This helps to copy or clone the existing objects to create new ones rather than creating from the scratch.

Answer 6

有點像Monostate Pattern？儘管這些實例都具有相同的狀態，所以這可能不太符合您的要求。