单例的使用如下：
#region 单例的各种方式实现，本写法以类A为例，泛型可以使用T
public class A
{
#region 单线程----常规，多线程不安全
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static A linjieInstance = null;
///// <summary>
///// 公开实例，供外界使用
///// </summary>
//public static A LinjieInstance
//{
// get
// {
// if (linjieInstance == null)
// {
// linjieInstance = new A();
// }
// return linjieInstance;
// }
//}
#endregion
#region 单线程----常规，多线程不安全---饿汉模式
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static readonly A linjieInstance = new A();
///// <summary>
///// 公开实例，供外界使用
///// </summary>
//public static A LinjieInstance => linjieInstance;
////public static A LinjieInstance
////{
//// get
//// {
//// return linjieInstance;
//// }
////}
#endregion
#region 单线程----常规，多线程不安全---饥(饿)汉模式
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static readonly A linjieInstance = new A();
///// <summary>
///// 公开实例，供外界使用
///// </summary>
//public static A LinjieInstance => linjieInstance;
////public static A LinjieInstance
////{
//// get
//// {
//// return linjieInstance;
//// }
////}
#endregion
#region 单线程----常规，多线程安全---饱(懒)汉模式---并发字典
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static readonly A linjieInstance = null;
//private static readonly ConcurrentDictionary<int, A> keyValuePairs = new ConcurrentDictionary<int, A>();
///// <summary>
///// 公开实例，供外界使用
///// </summary>
////public static A LinjieInstance => keyValuePairs.GetOrAdd(0, new A());
//public static A LinjieInstance
//{
// get
// {
// return keyValuePairs.GetOrAdd(0, new A());
// }
//}
#endregion
#region 单线程----常规，多线程安全---饱(懒)汉模式---Lazy<A>
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static readonly A linjieInstance = null;
//private static readonly Lazy<A> LazyInstance = new Lazy<A>(() => new A());
////private static readonly Lazy<A> LazyInstance = new Lazy<A>(() => new A(),true);// isThreadSafe:true 表示此示例可由多个线程同时使用；false 表示此实例一次只能由一个线程使用。
///// <summary>
///// 公开实例，供外界使用
///// </summary>
////public static A LinjieInstance => LazyInstance.Value;
//public static A LinjieInstance
//{
// get
// {
// return LazyInstance.Value;
// }
//}
#endregion
#region 单线程----常规，多线程安全---原子操作累加
///// <summary>
///// 变量
///// </summary>
//private int linjieInstance;
//public int GetValue() => Interlocked.Increment(ref linjieInstance);
////public int GetValue()
////{
//// return Interlocked.Increment(ref linjieInstance);
////}
#endregion
#region 单线程----常规，多线程安全---原子操作累加
///// <summary>
///// 变量
///// </summary>
//private volatile int linjieInstance;
//public int GetValue() => ++linjieInstance;
////public int GetValue()
////{
//// return ++linjieInstance;
////}
#endregion
#region 单线程----常规，多线程不安全----加锁
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 私有变量，延迟加载
///// </summary>
//private static A linjieInstance = null;
///// <summary>
///// 锁
///// </summary>
//private static readonly object objectlock = new object();
///// <summary>
///// 公开实例，供外界使用
///// </summary>
//public static A LinjieInstance
//{
// get
// {
// if (linjieInstance == null)
// {
// lock (objectlock)
// {
// if (linjieInstance == null)
// {
// linjieInstance = new A();
// }
// }
// }
// return linjieInstance;
// }
//}
#endregion
#region 单线程----常规，多线程不安全----私有静态内部类
///// <summary>
///// 私有构造函数，防止初始化
///// </summary>
//private A()
//{
//}
///// <summary>
///// 公开实例，供外界使用
///// </summary>
//public static A LinjieInstance => Nest.linjieInstance;
////public static A LinjieInstance
////{
//// get
//// {
//// return Nest.linjieInstance;
//// }
////}
///// <summary>
///// 内部静态类
///// </summary>
//private class Nest
//{
// /// <summary>
// /// 私有变量，延迟加载
// /// </summary>
// public static readonly A linjieInstance = null;
// static Nest()
// {
// linjieInstance = new A();
// }
// ////上面的写法还可以写成
// ///// <summary>
// ///// 私有变量，延迟加载
// ///// </summary>
// //public static readonly A linjieInstance = new A();
//}
#endregion
}
#region 单例的各种方式实现，本写法以泛型T
public abstract class B<T> where T : class
{
#region 单线程----常规，多线程不安全----泛型
/// <summary>
/// 私有构造函数，防止初始化
/// </summary>
private B()
{
}
/// <summary>
/// 公开实例，供外界使用
/// </summary>
public static T LinjieInstance => Nest.linjieInstance;
//public static T LinjieInstance
//{
// get
// {
// return Nest.linjieInstance;
// }
//}
/// <summary>
/// 内部静态类
/// </summary>
private class Nest
{
/// <summary>
/// 私有变量，延迟加载
/// </summary>
internal static readonly T linjieInstance = null;
static Nest()
{
//linjieInstance = new T();//必须有公开的构造函数，同时泛型约束SingletonBase<T> where T : class, new()
//nonPublic:如果公共或非公共默认构造函数可以匹配，则为 true；如果只有公共默认构造函数可以匹配，则为 false。
linjieInstance = Activator.CreateInstance(typeof(T), true) as T;
//使用指定类型的默认构造函数来创建该类型的实例,公共或非公共默认构造函数可以匹配
//linjieInstance = Activator.CreateInstance<T>() as T;
}
}
#endregion
}
#endregion
#endregion
龙腾一族至尊龙骑