C#单例模式

保证程序运行时只有一个实例，考点：静态构造函数、私有构造函数、锁、线程安全、延时创建对象、readonly/const区别

单例的优点：
1.保证了所有的对象访问的都是同一个实例
2.由于类是由自己类控制实例化的，所以有相应的伸缩性

单例的缺点：
1.额外的系统开销，因为每次使用类的实例的时候，都要检查实例是否存在，可以通过静态实例该解决。
2.无法销毁对象，单例模式的特性决定了只有他自己才能销毁对象实例，但是一般情况下我们都没做这个事情。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingletonPatterns
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    #region 单例模式版本---1
    /// <summary>
    /// 该版本主要存在的问题（线程安全问题）当2个请求同时访问时可能会出现2个实例尽管不会异常
    /// 不能保证运行过程中只有一个实例
    /// </summary>
    public sealed class Singleton1
    {
        private static Singleton1 _instance;
        private Singleton1() { }

        public static Singleton1 Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new Singleton1();
                return _instance;
            }
        }
    }
    #endregion

    #region 单例模式版本---2
    /// <summary>
    /// 使用在静态私有字段上通过new的形式，来保证在该类第一次被调用的时候创建实例，是不错的方式
    /// 但有一点需要注意的是，C#其实并不保证实例创建的时机，因为C#规范只是在IL里标记该静态字段是BeforeFieldInit
    /// 也就是说静态字段可能在第一次被使用的时候创建，也可能你没使用了，它也帮你创建了，也就是周期更早
    /// 我们不能确定到底是什么创建的实例。
    /// </summary>
    public sealed class Singleton2
    {
        private static readonly Singleton2 _instance = new Singleton2();

        /// <summary>
        /// 私有构造函数，确保用户在外部不能实例化新的实例
        /// </summary>
        private Singleton2() { }

        public static Singleton2 Instance
        {
            get
            {
                return _instance;
            }
        }
    }
    #endregion

    #region 单例模式版本---3
    /// <summary>
    /// 使用volatile来修饰，是个不错的注意，确保instance在被访问之前被赋值实例，一般情况都是用这种方式来实现单例。
    /// </summary>
    public sealed class Singleton3
    {
        private static volatile Singleton3 _instance = null;

        /// <summary>
        /// Lock对象 线程安全使用
        /// </summary>
        public static object syncObject = new object();

        private Singleton3() { }

        public static Singleton3 Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (syncObject)
                    {
                        if (_instance == null)
                            _instance = new Singleton3();
                    }
                }
                return _instance;
            }
        }
    }
    #endregion

    #region 单例模式版本---4
    /// <summary>
    /// 这种方式，其实是很不错的，因为他确实保证了是个延迟初始化的单例（通过加静态构造函数）
    /// 但是该静态构造函数里没有东西哦，所以能有时候会引起误解，尤其是在code review或者代码优化的时候
    /// 不熟悉的人可能直接帮你删除了这段代码，那就又回到了版本2了哦，所以还是需要注意的
    /// 不过如果你在这个时机正好有代码需要执行的话，那也不错。
    /// </summary>
    public class Singleton4
    {
        /// <summary>
        /// 因为下面声明了静态构造函数，所以在第一次访问该类之前，new Singleton()语句不会执行
        /// </summary>
        private static readonly Singleton4 _instance = new Singleton4();

        public static Singleton4 Instance
        {
            get { return _instance; }
        }

        private Singleton4() { }

        /// <summary>
        /// 声明静态构造函数就是为了删除IL里的BeforeFieldInit标记,以去静态自动在使用之前被初始化
        /// </summary>
        static Singleton4() { }
    }
    #endregion

    #region 单例模式版本---5

    #endregion

    #region 单例模式版本---6

    #endregion


}