如何设计只能由一个类实例化的单例

下面是一个完整的工作实现,它演示了实现您所需的两种可能方法。

两种方法都使用工厂概念;因为 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();
    }
}

您可以简单地将Singleton模式与类内的私有静态字段一起使用。

这样地:

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

     public static Singleton MainInstance
     {
         return _mainInstance;
     }
}

您将只有一个实例存储在类的mainInstance静态字段中,并且不可能创建任何其他实例。

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

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 方法似乎不能使其成为一个整体。

让我们试试:你需要 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.

你的单例实现几乎是正确的,只是 _mainInstance 和 MainInstance static .

类似于 Monostate Pattern 是吗?尽管这些实例都共享相同的状态,但这可能不是您所要查找的。