1 單例 SinglePattern 整個程式只有一個實力 保證程式中只有一個例項被建立

　　（執行緒池，資料庫連線池 ，配置檔案物件，Ioc容器例項 等程式中只需要一個例項的過程，單例是常駐記憶體）

2 工廠方法　　Method Factory

3 抽象工廠　　Abstrac Factory

4 建造者　　Builder

5 原型 　　Protype

6 簡單工廠 　　simple Factory

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　單例 SinglePattern

懶漢式 　 private Singleton()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine($"{this.GetType().Name}被構造一次 {Thread.CurrentThread.ManagedThreadId}");
        }
        private static Singleton _Singleton = null;
        private static readonly object Singleton_Lock = new object();
        public static Singleton CreateInstance()
        {
            if (_Singleton == null)
 
//為了提升效能，物件初始化之後能夠併發
            {
                lock (Singleton_Lock)//保證任意時刻只有一個執行緒可以進入
                {
                    if (_Singleton == null)//裡面的也不能去掉，因為在最開始併發時需要控制的，僅僅用於第一次初始化時的併發判斷，防止重複初始化
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }

餓漢式　　private SingletonSecond()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine($"{this.GetType().Name}被構造一次 {Thread.CurrentThread.ManagedThreadId}");
        }
        /// <summary>
        /// 由CLR呼叫，且只調用一次，會在程式第一次使用該型別之前
        /// </summary>
        static SingletonSecond()
        {
            _SingletonSecond = new SingletonSecond();
        }
        private static SingletonSecond _SingletonSecond = null;
        public static SingletonSecond CreateInstance()
        {
            return _SingletonSecond;
        }

餓漢式 　 private SingletonThird()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine($"{this.GetType().Name}被構造一次 {Thread.CurrentThread.ManagedThreadId}");
        }
        /// <summary>
        /// 靜態欄位也是由CLR保障的，在程式第一次使用該型別之前，完成初始化，且只初始化一次
        /// 
        /// 靜態欄位          1先執行
        /// 靜態建構函式   　　2後執行
        /// 誰先執行
        /// </summary>
        private static SingletonThird _SingletonThird = new SingletonThird();
        public static SingletonThird CreateInstance()
        {
            return _SingletonThird;
        }

　　　　　public static Donoting()
　　　　　　{
　　　　　　} 
 　　//　呼叫 Donoting() 的靜態方法  
　　//  會先初始化靜態欄位->靜態建構函式-> 這樣迫不及待的呼叫叫餓漢

                //類裡面各個元素的初始化順序
                //靜態欄位1--靜態建構函式2--普通屬性---建構函式3--普通欄位

　　    　　Program program = new Program();
            //    //開闢記憶體空間         a
            //    //執行建構函式         b
            //    //引用地址繫結給變數   c
            //克隆就少了第二步

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　原型 SingleProtope

private SingletonPrototype()淺克隆
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine($"{this.GetType().Name}被構造一次 {Thread.CurrentThread.ManagedThreadId}");
        }

        private static SingletonPrototype _SingletonPrototype = new SingletonPrototype();
        /// <summary>
        /// 原型模式
        /// </summary>
        /// <returns></returns>
        public static SingletonPrototype CreateInstance()
        {
            SingletonPrototype instance = (SingletonPrototype)_SingletonPrototype.MemberwiseClone();
　　　　　//記憶體複製---淺克隆   記憶體克隆開闢新的空間指向棧中同一個地方 ，棧中的並沒有改變
            return instance;
       //解決了單例物件覆蓋問題，通過記憶體拷貝
　　　　//單例的話會相互覆蓋   新的覆蓋舊的

 SingletonThird singleton1 = SingletonThird.CreateInstance();
                SingletonThird singleton2 = SingletonThird.CreateInstance();

                singleton1.Id = 123;
                singleton1.Name = "aaaaaa";

                singleton2.Id = 234;
                singleton2.Name = "bbbbb";

　　　　　　　　//1一般情況下，我們建構函式也不折騰。。。
//2new習慣了，習慣也是一種力量，
//3原型模式也有個常駐記憶體的東西
//4IOC不能玩，建構函式的初始化也失效了
　　　　　　　//　克隆其實就是繞開記憶體

　　　　　//　深克隆
  public static string Serializable(object target)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                new BinaryFormatter().Serialize(stream, target);

                return Convert.ToBase64String(stream.ToArray());
            }
        }

        public static T Derializable<T>(string target)
        {
            byte[] targetArray = Convert.FromBase64String(target);

            using (MemoryStream stream = new MemoryStream(targetArray))
            {
                return (T)(new BinaryFormatter().Deserialize(stream));
            }
        }

        public static T DeepClone<T>(T t)
        {
            return Derializable<T>(Serializable(t));
        }

建立物件的方法

1new

2克隆

3反序列化

4反射