单例模式-C#

在C#中实现单例模式，主要目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个实例。以下是一个简单的单例模式实现示例，它使用了一个私有静态变量来保存类的唯一实例，并提供了一个公有的静态方法来获取这个实例。此外，还使用了私有构造函数来防止通过new关键字在类的外部创建实例。

单例模式的优点：

1. 单例模式可以保证一个类只有一个实例，减少内存开销，降低系统的复杂度，并加强系统的稳定性。
1. 单例模式可以避免对资源的多重占用，保证系统的一致性。
1. 单例模式可以全局访问点，可以提供一个访问点，使得外界可以直接访问该实例。
1. 单例模式可以提供一个统一的访问点，简化调用，提高代码的可读性和可维护性。

单例模式的缺点：

1. 单例模式一般没有接口，扩展困难。
1. 单例模式违反了依赖倒置原则，一个模块应该依赖于抽象，而不是具体的实现。
1. 单例模式对测试不利，难以对单例进行单元测试。
1. 单例模式在多线程环境下需要进行线程同步，可能会导致性能问题。
1. 单例模式在一些框架中使用单例模式，可能会导致系统的复杂性。
1. 单例模式在一些语言中不容易实现，比如Java中不能通过反射创建对象。
1. 单例模式在一些场景下会增加系统的复杂度，比如多线程的应用场景。
1. 单例模式在一些框架中使用单例模式，可能会导致系统的复杂性。
1. 单例模式在一些语言中不容易实现，比如Java中不能通过反射创建对象。
1. 单例模式在一些场景下会增加系统的复杂度，比如多线程的应用场景。

懒汉式（线程不安全）

这是最基本的实现方式，但在多线程环境下可能会创建多个实例。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace SingletonPattern
{/// <summary>/// 懒汉式（线程不安全）/// 这是最基本的实现方式，但在多线程环境下可能会创建多个实例。/// </summary>internal class Singleton_LazyNoSafety{// 私有静态变量，用于存储类的唯一实例private static Singleton_LazyNoSafety instance;// 私有构造函数，防止外部创建实例  private Singleton_LazyNoSafety() {Console.WriteLine("单例模式：懒汉式（线程不安全）！");}// 公有静态方法，返回类的唯一实例  public static Singleton_LazyNoSafety GetInstance(){// 如果实例不存在，则创建实例if (instance == null){instance = new Singleton_LazyNoSafety();}return instance;}}
}

懒汉式（线程安全）

通过在GetInstance方法上添加lock关键字来确保线程安全。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace SingletonPattern
{/// <summary>/// 懒汉式（线程安全）/// 通过在GetInstance方法上添加lock关键字来确保线程安全。/// </summary>public class Singleton_LazySafety{private static Singleton_LazySafety instance;/** lock 关键字是用于同步代码块，确保在同一时间内只有一个线程可以执行该代码块。* lock 关键字通过锁定一个对象来工作，任何线程在尝试进入被 lock 保护的代码块之前，都必须先获得该对象的锁。* 如果一个线程已经获得了锁，其他线程就必须等待，直到锁被释放。当线程退出 lock 代码块时，无论是因为正常执行完毕还是由于异常退出，锁都会被自动释放。*/private static readonly object lockObj = new object();private Singleton_LazySafety(){Console.WriteLine("单例模式：懒汉式（线程安全）！");}public static Singleton_LazySafety GetInstance(){lock (lockObj){if (instance == null){instance = new Singleton_LazySafety();}}return instance;}}
}

饿汉式

这种方式基于类加载机制避免了多线程同步问题，但是在类装载时就完成实例化，没有达到Lazy Loading的效果。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace SingletonPattern
{/// <summary>/// 饿汉式/// 这种方式基于类加载机制避免了多线程同步问题，但是在类装载时就完成实例化，没有达到Lazy Loading的效果。/// </summary>public class Singleton_Hungry{// 私有静态变量，用于存储类的唯一实例private static Singleton_Hungry instance;// 私有构造函数，防止外部创建实例  public Singleton_Hungry(){Console.WriteLine("单例模式：饿汉式！");//在类被加载时就会创建实例对象，不会被打印到控制台}// 公有静态方法，返回类的唯一实例  public static Singleton_Hungry GetInstance() { return instance; }}
}

双重检查锁定（Double-Checked Locking）

这种方式既保证了线程安全，又避免了每次调用GetInstance时都进行同步，从而提高了性能。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace SingletonPattern
{/// <summary>/// 双重检查锁定（Double-Checked Locking）/// 这种方式既保证了线程安全，又避免了每次调用GetInstance时都进行同步，从而提高了性能。/// </summary>public class Singleton_DoubleCheckedLocking{// 使用volatile关键字确保多线程环境下的可见性  private static volatile Singleton_DoubleCheckedLocking instance;private static readonly object lockObject = new object();private Singleton_DoubleCheckedLocking(){Console.WriteLine("单例模式：双重检查锁定！");}public static Singleton_DoubleCheckedLocking GetInstance(){// 第一次检查实例是否存在，如果不存在，才进入下面的同步块  if (instance == null){lock (lockObject){// 第二次检查实例是否存在，防止多个线程都通过了第一次检查并创建实例  if (instance==null){instance = new Singleton_DoubleCheckedLocking();}}}return instance;}}
}

.NET Framework 4.0及更高版本

请注意，在.NET Framework 4.0及更高版本中，由于System.Lazy的引入，实现单例模式变得更加简单和高效。Lazy类提供了一种延迟初始化的机制，它确保对象在其Value属性被访问之前不会被实例化。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace SingletonPattern
{/// <summary>/// 4.0后高版本/// 在.NET Framework 4.0及更高版本中，由于System.Lazy<T>的引入，实现单例模式变得更加简单和高效。/// Lazy<T>类提供了一种延迟初始化的机制，它确保对象在其Value属性被访问之前不会被实例化。/// </summary>internal class Singleton_HighVersion{// 使用Lazy<T>实现单例模式  private static readonly Lazy<Singleton_HighVersion> lazy = new Lazy<Singleton_HighVersion>(() => new Singleton_HighVersion());// 私有构造函数  private Singleton_HighVersion(){Console.WriteLine("单例模式：4.0后高版本！");}// 公有静态属性，返回类的唯一实例  public static Singleton_HighVersion Instance => lazy.Value;}
}

调用结果

using System;namespace SingletonPattern
{internal class Program{static void Main(string[] args){var instance_lazy1 = Singleton_LazyNoSafety.GetInstance();var instance_lazy2 = Singleton_LazyNoSafety.GetInstance();// 比较内存地址判断是否同一个实例  Console.WriteLine(ReferenceEquals(instance_lazy1, instance_lazy2)); // 输出: True var instance_lazy3 = Singleton_LazySafety.GetInstance();var instance_lazy4 = Singleton_LazySafety.GetInstance();Console.WriteLine(ReferenceEquals(instance_lazy3, instance_lazy4)); //在类被加载时就会创建实例对象var instance_hungry1 = Singleton_Hungry.GetInstance();var instance_hungry2 = Singleton_Hungry.GetInstance();Console.WriteLine(ReferenceEquals(instance_hungry1, instance_hungry2));var instance_double1 = Singleton_DoubleCheckedLocking.GetInstance();var instance_double2 = Singleton_DoubleCheckedLocking.GetInstance();Console.WriteLine(ReferenceEquals(instance_double1, instance_double2));var instance_high1 = Singleton_HighVersion.Instance;var instance_hagh2 = Singleton_HighVersion.Instance;Console.WriteLine(ReferenceEquals(instance_high1, instance_hagh2));}}
}