设计模式：面向对象语言开发过程中，遇到的种种场景和问题，提出了解决方案和思路，沉淀下来就变成了设计模式。具体的招数，解决具体问题的具体招数。
设计模式分类：
- 创建型设计模式：关注对象的创建
- 结构型设计模式：关注类与类之间的关系
- 行为型设计模式：关注对象与行为的分离
没有什么设计模式是完美无缺的，一个设计模式就是解决一类问题的，通常设计模式在解决一类问题的同时，还会带来别的问题，设计者要做的就是扬长避短，充分发挥其长处。
单例模式
在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性、以及良好的效率。
代码实现：
单线程中的单例模式：
/// <summary>
/// 单线程单例实例
/// </summary>
class SingleThreadd_Singleton
{
//全局唯一静态
private static SingleThreadd_Singleton _Singleton = null;
private SingleThreadd_Singleton()
{
Console.WriteLine("{0}被构造一次", this.GetType().Name);
}
/// <summary>
/// 公开的静态方法提供对象实例
/// </summary>
/// <returns></returns>
public static SingleThreadd_Singleton CreateInstance()
{
if (_Singleton == null)
{
_Singleton = new SingleThreadd_Singleton();
}
return _Singleton;
}
}
实例的创建：
执行结果：
实例被创建了一次，两次返回的实例为同一个实例。
多线程中的单例模式：
/// <summary>
/// 多线程单例实例
/// </summary>
class MultiThread_Singleton
{
//全局唯一静态 volatile存进线程安全,让线程按照顺序执行
private static volatile MultiThread_Singleton _Singleton = null;
private static readonly object Singleton_Lock = new object();
private MultiThread_Singleton()
{
Console.WriteLine("{0}被构造一次", this.GetType().Name);
}
/// <summary>
/// 公开的静态方法提供对象实例
/// </summary>
/// <returns></returns>
public static MultiThread_Singleton CreateInstance()
{
if (_Singleton == null)
{
lock (Singleton_Lock)//保证任意时刻只有一个线程进入lock范围
{
Console.WriteLine("lock进入一次");
if (_Singleton == null)
{
_Singleton = new MultiThread_Singleton();
}
}
}
return _Singleton;
}
}
实例的创建：
执行结果：
实例也是只被构造了一次。
单例模式可以避免重复创建对象，但是可会常驻内存，占用内存资源。
原型模式
换个方式创建对象，不走构造函数，而是内存拷贝。
代码实现：
/// <summary>
/// 原型模式实例
/// </summary>
class Prototype
{
public int Age { get; set; }
public string Name { get; set; }
private Prototype()
{
Console.WriteLine("{0}被构造一次", this.GetType().Name);
}
//初始化一个Student对象
private static Prototype _Prototype = new Prototype
{
Age = 20,
Name = "张三"
};
public static Prototype GetInstance()
{
Prototype prototype = (Prototype)_Prototype.MemberwiseClone();
Console.WriteLine("原型对象和拷贝后的对象是否为同一对象: " + object.ReferenceEquals(_Prototype, prototype));
return prototype;
}
}
实例的创建：
执行结果：
返回的对象实例是由原型对象拷贝后生成的，原型对象和拷贝后的对象虽然值相同，但属于两个不同的对象。
工厂方法模式
在软件系统中，由于需求的变化，“对象的具体实现”经常面临着剧烈的变化，但它却有比较稳定的接口。
为了应为这样的变化，提供一种封装机制来隔离出“这个易变对象的变化”，从而保持系统中“其他依赖对象”不随需求的变化而变化。
代码实现：
App.config添加配置项：
<appSettings>
<add key="No1" value="HongQiCarFactory"/>
<add key="No2" value="BMWCarFactory"/>
</appSettings>
CarFactory类：
public abstract class CarFactory
{
public abstract Car CarCreate();
}
Car类：
public abstract class Car
{
public abstract void StartUp();
public abstract void Run();
public abstract void Stop();
}
HongQiCarFactory类：
public class HongQiCarFactory : CarFactory
{
public override Car CarCreate()
{
return new HongQiCar();
}
}
BMWCarFactory类：
public class BMWCarFactory : CarFactory
{
public override Car CarCreate()
{
return new BMWCar();
}
}
HongQiCar类：
public class HongQiCar : Car
{
public override void StartUp()
{
Console.WriteLine("Test HongQiCar start-up speed!");
}
public override void Run()
{
Console.WriteLine("The HongQiCar run is very quickly!");
}
public override void Stop()
{
Console.WriteLine("The slow stop time is 3 second ");
}
}
BMWCar类：
public class BMWCar : Car
{
public override void StartUp()
{
Console.WriteLine("The BMWCar start-up speed is very quickly");
}
public override void Run()
{
Console.WriteLine("The BMWCar run is quitely fast and safe!!!");
}
public override void Stop()
{
Console.WriteLine("The slow stop time is 2 second");
}
}
Program类：
Console.WriteLine("Please Enter Factory Method No:");
Console.WriteLine("******************************");
Console.WriteLine("no Factory Method");
Console.WriteLine("1 HongQiCarFactory");
Console.WriteLine("2 BMWCarFactory");
Console.WriteLine("******************************");
int no = Int32.Parse(Console.ReadLine().ToString());
string factoryType = ConfigurationManager.AppSettings["No" + no];
//CarFactory factory = new HongQiCarFactory();
CarFactory factory = (CarFactory)Assembly.Load("FactoryMehtod").CreateInstance("FactoryMehtod." + factoryType);
Car car = factory.CarCreate();
car.StartUp();
car.Run();
car.Stop();
执行结果：
工厂方法模式要点：
主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。
通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展的策略，较好地解决了这种紧耦合关系。
工厂方法模式解决“单个对象”的需求变化，抽象工厂模式解决“系列对象”的需求变化，建造者模式解决“对象部分”的需求变化。
参考链接：
https://www.cnblogs.com/abcdwxc/archive/2007/10/30/942834.html