具体使用案例如下：
using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace ConsoleTest { /// <summary> /// 测试单例 /// </summary> static class TestSingleton { /// <summary> /// 测试单例 /// </summary> public static void Test() { AA.Instance.Print(); } } #region 单例相关 /// <summary> /// 单线程 /// </summary> public class SingleTon { /// <summary> /// 私有变量，延迟加载 /// </summary> private static SingleTon instance = null; /// <summary> /// 私有构造函数，方式初始化 /// </summary> private SingleTon() { } /// <summary> /// 公开实例，单例供外部使用 /// </summary> public static SingleTon Instance { get { if (instance == null) { instance = new SingleTon(); } return instance; } } } /// <summary> /// 多线程 /// </summary> public class SingleTon1 { /// <summary> /// 私有变量,提前初始化 /// </summary> private static SingleTon1 instance = new SingleTon1(); /// <summary> /// 私有构造函数，方式初始化 /// </summary> private SingleTon1() { } /// <summary> /// 公开实例，单例供外部使用 /// </summary> public static SingleTon1 Instance => instance; } /// <summary> /// 多线程 /// </summary> public class SingleTon2 { /// <summary> /// 私有变量,提前初始化 /// </summary> private static SingleTon2 instance = null; /// <summary> /// 锁 /// </summary> private static readonly object objectlock = new object(); /// <summary> /// 私有构造函数，方式初始化 /// </summary> private SingleTon2() { } /// <summary> /// 公开实例，单例供外部使用 /// </summary> public static SingleTon2 Instance { get { if (instance == null) { lock (objectlock) { if (instance == null) { instance = new SingleTon2(); } } } return instance; } } } /// <summary> /// 多线程,并发字典 /// </summary> public class SingleTon3 { /// <summary> /// 并发字典 /// </summary> private static readonly ConcurrentDictionary<int, SingleTon3> valuePairs = new ConcurrentDictionary<int, SingleTon3>(); /// <summary> /// 私有构造函数，方式初始化 /// </summary> private SingleTon3() { } /// <summary> /// 公开实例，单例供外部使用 /// </summary> //public static SingleTon3 Instance => valuePairs.GetOrAdd(1, new SingleTon3()); public static SingleTon3 Instance => valuePairs.GetOrAdd(1, k => new SingleTon3()); } /// <summary> /// 多线程,并发字典 /// </summary> public class SingleTon4 { /// <summary> /// 并发字典 /// </summary> //private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>(); private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>(() => new SingleTon4()); /// <summary> /// 私有构造函数，方式初始化 /// </summary> private SingleTon4() { } /// <summary> /// 公开实例，单例供外部使用 /// </summary> public static SingleTon4 Instance => singleTon.Value; } /// <summary> /// 多线程,原子操作 /// </summary> public class SingleTon5 { private int count; public int AddCount() { return Interlocked.Increment(ref count); } } /// <summary> /// 多线程,同步操作 /// </summary> public class SingleTon6 { private volatile int count; public int AddCount() { return count++; } } #endregion #region 单例的优化,有一点要注意，所有的单例其实都可以通过反射来创建的，但是枚举是自带单例的，无法通过反射来创建枚举实例的 /// <summary> /// 单例优化以后的测试 /// </summary> public class AA : SingletonStrict<AA> //public class AA:SingletonBase<AA>//SingletonStrict { public int MyProperty { get; set; } public string Name { get; set; } //继承SingletonStrict<AA>。不需要公开的构造器 private AA()//继承类必须添加该私有的构造器，否则仍然可以AA aa= new AA(),这种方式就违背了单例的原则和设计初衷 { } //继承SingletonBase<AA>。必须要公开的构造器 //public AA()//继承类必须添加该私有的构造器，否则仍然可以AA aa= new AA(),这种方式就违背了单例的原则和设计初衷 //{ //} public void Print() { Console.WriteLine("静态内部类的线程安全的懒汉式单例"); } } /// <summary> ///单例优化3 /// </summary> /// <typeparam name="T"></typeparam> public abstract class SingletonStrict2<T> where T : class //如果有new ()的话，则泛型T的类型必须具有公开的构造器 { public static T GetSingleton() { //第一，二，三种方式 //return Nested.Instance; //第四种方式 //return lazyT.Value; //第五种方式 return valuePairs.GetOrAdd(1, k => Activator.CreateInstance<T>()); //最好的是在T的具体类型中，添加私有的构造器 //return valuePairs.GetOrAdd(1, k => new T() //约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器 } public static T Instance { //第一，二，三种方式 //get { return lazyT.Value; } //第四种方式 //get { return lazyT.Value; } //第五种方式 get { return valuePairs.GetOrAdd(1, k => Activator.CreateInstance<T>()); }//最好的是在T的具体类型中，添加私有的构造器 //get { return valuePairs.GetOrAdd(1, k => new T()); }//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器 } #region 第五种方式 private static readonly ConcurrentDictionary<int, T> valuePairs = null; static SingletonStrict2() { valuePairs = new ConcurrentDictionary<int, T>(); //lazyT = new Lazy<T>(() => new T());//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器 //lazyT = new Lazy<T>(() => Activator.CreateInstance<T>());//最好的是在T的具体类型中，添加私有的构造器 } #endregion #region 第四种方式 //private static readonly Lazy<T> lazyT; //static SingletonStrict2() //{ // lazyT = new Lazy<T>(); // //lazyT = new Lazy<T>(() => new T());//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器 // //lazyT = new Lazy<T>(() => Activator.CreateInstance<T>());//最好的是在T的具体类型中，添加私有的构造器 //} #endregion #region 第二种方式 /// <summary> /// 静态内部类 /// </summary> //private static class Nested //{ // internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 //} #endregion #region 第三种方式 //private class Nested //{ // internal static readonly T Instance = null; // static Nested() // { // Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // //Instance = new T();//泛型T的类型必须具有公开的构造器 // //internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // //internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 // } //} #endregion #region 第一种方式 /// <summary> /// 普通内部类 /// </summary> //private class Nested //{ // static Nested(){}//重点在这里 // internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 //} #endregion } /// <summary> ///单例优化1 /// </summary> /// <typeparam name="T"></typeparam> public abstract class SingletonStrict<T> where T : class //如果有new ()的话，则泛型T的类型必须具有公开的构造器 { public static T GetSingleton() { return Nested.Instance; } public static T Instance { get { return Nested.Instance; } } //第二种方式 /// <summary> /// 静态内部类 /// </summary> //private static class Nested //{ // internal static readonly T Instance = new T(); // internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 //} private class Nested { internal static readonly T Instance = null; static Nested() { Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 //Instance = new T();//泛型T的类型必须具有公开的构造器 //internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 //internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 } } //第二种方式 /// <summary> /// 普通内部类 /// </summary> //private class Nested //{ // static Nested(){}//重点在这里 // internal static readonly T Instance = new T(); //} } /// <summary> /// 单例优化2 ///静态内部类 ///这种方式采用了类装载的机制来保证初始化实例时只有一个线程 ///静态内部类方式在外部类被加载时并不会立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成外部类的实例化。 ///类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的 ///优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高 /// </summary> public abstract class SingletonBase<T> where T : class, new()//如果有new ()的话，则泛型T的类型必须具有公开的构造器 { public static T GetSingleton() { return Nested.Instance; } public static T Instance { get { return Nested.Instance; } } //第二种方式 /// <summary> /// 静态内部类 /// </summary> //private static class Nested //{ // internal static readonly T Instance = new T(); // internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 //} //第三种方式 private class Nested { internal static readonly T Instance = null; static Nested() { Instance = Activator.CreateInstance<T>(); //Instance = new T();//泛型T的类型必须具有公开的构造器 //Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 //Instance = new T();//泛型T的类型必须具有公开的构造器 } } //第二种方式 /// <summary> /// 普通内部类 /// </summary> //private class Nested //{ // static Nested(){}//重点在这里 // internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器 // internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器 //} } //静态内部类 //静态内部类也是作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象 //在外部类加载时，静态内部类不会被立即加载，而是在外部类中被使用时才会加载，这符合懒加载的策略。 //当我们在外部类中调用静态内部类时，会被加载，并且只会被加载一次，在加载时线程是安全的，保障了线程的安全性。 /// <summary> ///外部类 /// </summary> public class StaticInner { private StaticInner() { } /// <summary> /// 静态内部类 /// </summary> private static class Singleton { internal static StaticInner INSTANCE = new StaticInner(); } public static StaticInner GetSingleton() { return Singleton.INSTANCE; } public void Print() { Console.WriteLine("静态内部类的线程安全的懒汉式单例"); } } //静态内部类 //这种方式采用了类装载的机制来保证初始化实例时只有一个线程 //静态内部类方式在外部类被加载时并不会立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成外部类的实例化。 //类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的 //优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高 #endregion }
