23设计模式 创建型

1 单例    SinglePattern  整个程序只有一个实力  保证程序中只有一个实例被创建 

　　 （线程池，数据库连接池 ，配置文件对象，Ioc容器实例 等程序中只需要一个实例的过程，单例是常驻内存）

2 工厂方法 　　Method Factory

3 抽象工厂　　Abstrac Factory

4 建造者　　Builder       是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，创建者模式隐藏了复杂对象的创建过程。

5 原型 　　Protype

6 简单工厂 　　simple Factory

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　单例   SinglePattern

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

懒汉式 　 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()         {          <strong>   if (_Singleton == null)</strong>//为了提升性能，对象初始化之后能够并发             {                 lock (Singleton_Lock)//保证任意时刻只有一个线程可以进入                 {                     if (_Singleton == null)//里面的也不能去掉，因为在最开始并发时需要控制的，仅仅用于第一次初始化时的并发判断，防止重复初始化                     {                         _Singleton = new Singleton();                     }                 }             }             return _Singleton;         }

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

饿汉式　　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;         }

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

饿汉式 　 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()<br>　　　　　　{　　　//　调用 Donoting() 的静态方法  <br>　　//  会先初始化静态字段->静态构造函数-> 这样迫不及待的调用叫饿汉　　　　　　}

?

1 2	//类里面各个元素的初始化顺序 //静态字段1--静态构造函数2--普通属性---构造函数3--普通字段

?

1 2 3 4 5

Program program = new Program();     //    //开辟内存空间         a     //    //执行构造函数         b     //    //引用地址绑定给变量   c     //克隆就少了第二步

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                                                                  原型  SingleProtope    

//内存复制---浅克隆 内存克隆开辟新的空间指向栈中同一个地方 ，栈中的并没有改变
//解决了单例对象覆盖问题，通过内存拷贝
//单例的话会相互覆盖 新的覆盖旧的
//1 一般情况下，我们构造函数也不折腾。。。
//2 new习惯了，习惯也是一种力量，
//3 原型模式也有个常驻内存的东西
//4 IOC不能玩，构造函数的初始化也失效了
//5克隆其实就是绕开内存

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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}");         }          <strong> private static SingletonPrototype _SingletonPrototype = new SingletonPrototype();</strong>         /// <summary>         /// 原型模式         /// </summary>         /// <returns></returns>         public static SingletonPrototype CreateInstance()         {            SingletonPrototype instance = (SingletonPrototype)_SingletonPrototype.MemberwiseClone();<br>　　　　　　  return instance;<br>　　　　　}  {                 SingletonPrototype singleton1 = SingletonPrototype.CreateInstance();                 SingletonPrototype singleton2 = SingletonPrototype.CreateInstance();                   singleton1.Id = 123;                 singleton1.Name = "金辰";                   singleton2.Id = 234;                 singleton2.Name = "大浪";                   //代码这样写，会不会有什么问题，或者出现什么意料之外的事儿？                 //覆盖--因为单例，是同一个对象，操作就互相覆盖了，以后面的为准                   //单例可以避免重复初始化对象(构造函数浪费时间)---但是对象覆盖了---                 //有没有办法兼得？             }

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

<strong>　　　</strong>　　//　深克隆<br> 　　   public static string Serializable(object target)         {             using (MemoryStream stream = new MemoryStream())             {                 new BinaryFormatter().Serialize(stream, target);                   return Convert.ToBase64String(stream.ToArray());             }         }<br>        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反射