如何设计一个只能由 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

您可以在类中简单地使用带有私有静态字段的单例模式。

像这样：

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

     public static Singleton MainInstance
     {
         return _mainInstance;
     }
}

您的唯一实例将存储在类的 _mainInstance 静态字段中，并且不可能创建任何其他实例。

Answer 3

您可以使用内部构造函数使类只能由其程序集中的其他类实例化：

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 4

让我们试试吧：你需要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 5

单例模式意味着该类只有一个实例。如果你的班级有某种克隆方法，那么每个人都可以克隆这个实例。所以我看不到你的问题。

您的单例实现几乎是正确的，只是 _mainInstance 和 MainInstance 需要为 static。

Answer 6

类似Monostate Pattern？尽管所有实例都共享相同的状态，所以这可能不是您想要的。