设计模式（一）单例模式，实例

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

namespace 设计模式
{
    class Program
    {
        static void Main(string[] args)
        {

            Singleton instance = new Singleton();
            Singleton instance2 = new Singleton();
            Singleton instance3 = new Singleton();

            Console.WriteLine(instance.Age);
            Console.WriteLine(instance2.Age);
            Console.WriteLine(instance3.Age);
            Console.Read();
        }
    }

    public sealed class Singleton
    {
        public Singleton()
        {

        }
        //#region 设计模式第一到第三种方案。
        ///// <summary>
        ///// 在不加线程锁时，可能由于并发，产生多个实例，违背返回单个实例原则。及失去了单利模式的意义。
        ///// 在加了线程锁以后，倒是每个实例的引用Instance时，都进行线程锁判断导致，性男女下降。
        ///// 所以引入，在外城在加判断，如果为空的时候才进入线程锁处理，这样只有在空的情况下才进入线程处理，
        ///// 所以，在空的情况下并发，只有首次实例的时候才会引起，所以提高效率。在锁的内部在进行实例是否存在验证，加双重判断
        ///// 以保证实例运行
        ///// </summary>
        //static Singleton instance = null;
        //static readonly Object lockBao = new object();//第二种，第三种方案使用，为线程锁
        //public Singleton Instance
        //{
        //    get
        //    {
        //        if (instance==null)
        //        {
        //            lock (lockBao)//
        //            {
        //                if (instance == null)
        //                {
        //                    instance = new Singleton();
        //                }
        //            }
        //        }
        //        return instance;
        //    }
        //}
        //#endregion

        //#region 比较常用的方式
        ///// <summary>
        ///// 第四种方式：类声明为sealed 目的是为防止，之类派生导致实例增加。
        ///// 变量标记为 readonly，这意味着只能在静态初始化期间（此处显示的示例）或在类构造函数中分配变量。
        ///// 仍然不能实现延迟初始。
        ///// </summary>
        /////
        //static Singleton()
        //{

        //}
        //static readonly Singleton Instacne = new Singleton();
        //public Singleton Instance
        //{
        //    get
        //    {
        //        return Instacne;
        //    }
        //}

        //#endregion

        public  int Age
        {
            get
            {
                return 11;
            }
        }
        #region
        /// <summary>
        /// 可以实现延迟初始，是比较好的一种方案，简单明了。
        ///  初始化比较耗时，而且每次程序运行不一定都要访问它。
        /// </summary>
        public Singleton Instance
        {
            get
            {

                return Nested.instance;
            }
        }

 
        #endregion
    }

    class Nested
    {

        static Nested()
        {

        }
        internal static readonly Singleton instance = new Singleton();
    }
}