23设计模式 创建型
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
//内存复制---浅克隆 内存克隆开辟新的空间指向栈中同一个地方 ，栈中的并没有改变
//解决了单例对象覆盖问题，通过内存拷贝
//单例的话会相互覆盖 新的覆盖旧的
//1 一般情况下，我们构造函数也不折腾。。。
//2 new习惯了，习惯也是一种力量，
//3 原型模式也有个常驻内存的东西
//4 IOC不能玩，构造函数的初始化也失效了
//5克隆其实就是绕开内存
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;
}
{
SingletonPrototype singleton1 = SingletonPrototype.CreateInstance();
SingletonPrototype singleton2 = SingletonPrototype.CreateInstance();
singleton1.Id = 123;
singleton1.Name = "金辰";
singleton2.Id = 234;
singleton2.Name = "大浪";
//代码这样写，会不会有什么问题，或者出现什么意料之外的事儿？
//覆盖--因为单例，是同一个对象，操作就互相覆盖了，以后面的为准
//单例可以避免重复初始化对象(构造函数浪费时间)---但是对象覆盖了---
//有没有办法兼得？
}
// 深克隆
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反射
