C#设计模式之单例模式

单例模式是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。简单来说，就是一个类只能创建一个该类的对象（实例）

注意

• 1、单例类只能有一个实例。

• 2、单例类必须自己创建自己的唯一实例。

• 3、单例类必须给所有其他对象提供这一实例。

代码实现

为了实现单例模式，我们需要让一个类只能创建一个该类的对象

class A
{
​
}
​
class Program
{
    static void Main(string[] args)
    {
        //创建了两个A类的对象，显然，就没能符合单例模式
        A a1 = new A();
        A a2 = new A();
    }
}

那么我们如何让一个类只能创建一个该类的对象呢，我们需要让创建多了之后便让C#报错。那么我们要分为两个 步骤。

• 1、让类不能创建实例

• 2、让类只能创建一个实例

  一、让类不能创建实例

  A a1 = new A();

  我们来看一下这个new A()后面的括号，这个括号是什么意思呢，其实就是调用了一个构造器。在C#中，当我们在类中不写任何的构造器，那么C#就会默认帮我们创建一个不带参数的构造器。

  那么我们现在来写一下构造器。

  class A
  {
      public A() { } //创建构造器
  }

  其实这个构造器也是一个方法，和别的方法不同的是，它没有返回值类型。

  我们写的这个构造器的访问权限是公有的，因此我们在这个类的外部也可以调用。因此，为了让外部调用不了这个构造器，我们需要把这个构造器的访问权限声明为私有的。

  class A
  {
      private A() { } //创建构造器，并把访问权限声明为私有的
  }
  ​
  class Program
  {
      static void Main(string[] args)
      {
          A A1 = new A();//此时，我们再次进行实例化那么编译器就会报错
          A A2 = new A();
      }
  }

  此时，我们就完成了第一个步骤，让类不能创建实例。

  二、让类只能创建一个实例

  当我们将构造器的访问权限设为私有后，虽然我们在类的外部不可以调用，但是我们可以这个类内部进行调用。

  class A
  {
      private A() { } //创建构造器，并把访问权限声明为私有的
      public A Foo()
      {
          A instance = new A();
          return instance;
      }
  }

  此时我们便在该类中进行了实例化。

  那么当我们只要调用Foo这个方法，我们便可以创建A这个实例。可是如果我们想要调用Foo这个方法，我们又要将A进行实例化。那么我们为了可以调用这个方法，我们就需要用static这个关键字。

      public static A Foo()
      {
          A instance = new A();
          return instance;
      }

  那么此时Foo这个方法就被定义为静态成员方法，而静态成员方法与对象是无关的，而是与类有关系。那么此时我们就可以在类外部调用这个方法。

  class Program
  {
      static void Main(string[] args)
      {
          A a = A.Foo();
      }
  }

  此时，我们也就完成了对A的实例化。最后，我们需要限制这个statci方法，也就是如果我们创建了一个对象就不再创建更多对象了。

  那么我们如何来限制呢？我们可以这样做。

  class A
  {
      private A() { } //创建构造器，并把访问权限声明为私有的
      public static A instance;
      public static A Foo()
      {
          if (instance == null)
          {
              instance = new A();
          }
          return instance;
      }
  }

  将instance声明为类A的一个静态成员，因为声明为static的类成员或者成员函数便能在类的范围内同享 。同时在Foo方法中写一个保护性的代码。

  至此，我们便创建完成了一个单例模式。