标签：
解决问题：创建对象，将创建对象的任务交给另一个对象完成。
组成：
优点：客服了简单工厂违背开放封闭原则的缺点。
优点：让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被
具体工厂的实现分离，不会出现在客户端代码中。
缺点：如果新增一个业务产品，就需要修改原有各工厂子类，添加生产新产品的方法，同时还需要新增每个
工厂生产的具体业务产品类，才可以完全实现。
优点：客户不需要知道具体创建对象，隐藏了类的实例是如何被创建的。
简单工厂：
UML图：
伪代码实现：
public class 工厂 { public static 产品 Factory(string 产品名称) { Product result=null; switch(产品名称) { case"产品1": result=new 产品1(); break; case"产品2": result=new 产品2(); break; } return result; } } 客户端： 产品 =工厂.Factory("产品1");
工厂方法：
UML图：
伪代码实现：
public interface IFactory { Product Factory(); } public class FactoryProduct1 : IFactory { public Product Factory() { return new Product1(); } } //客户端 IFactory factory=new FactoryProduct1(); Product product=factory.Factory();
抽象工厂：
在工厂方法(只能生产一种业务产品)的基础上扩展而来，能生产多种业务产品，如下图的用户和部门；
但是一旦我们需要增加一个新的业务产品，比如项目Project，则至少需要增加3个类，IProject、SqlserverProject、AccessProject，还需要修改IFactory、SqlserverFactory、AccessFactory，才能完全实现。
可使用简单工厂来改进抽象工厂，更进一步，通过反射+抽象工厂、反射+配置文件来进行改进。
UML图：
伪代码：
//客户端 IFactory fac=new SqlserverFactory();//new AcessFactory(); IUser iu=fac.CreatUser(): iu.insert(); IDepartment id=fac.CreateDepartment(); id.insert();
建造者模式：
理解：指挥者指挥某某做事。比如常见举例饭店经理指挥收银员点餐、工作人员出餐就是这个思想。
UML图：
伪代码实现：
/// 事情 public class Thing { public void print(string Name) { } } // 工作者接口 public interface IWorker { void doThing(); } //具体工作者1 public class Worker1 : IWorker { public void doThing() { // TODO: implement } } //具体工作者2 public class Worker2 : IWorker { public void doThing() { // TODO: implement } } /// 指挥者 public class Director { public Director(IWorker worker) { iWorker=worker; } public void command() { iworker.doThing(); } public IWorker iWorker; } //客户端 Director director=new Director(new Worker1()); director.command();
原型模式：
通俗的讲：就是为了复制一个对象，避免每次new类生成对象后需要重复设置相同的属性，复制后只需对个别需要个性化的属性设置个性化的值就可以了；避免每new一次，执行一次构造函数，如果构造函数的执行时间很长，多次执行导致系统低效，在初始化信息不发生变化的情况下，克隆既隐藏了对象创建的细节，又能对性能大大的提高。
重点：需要注意深复制与浅复制两种的区别。
UML图：
伪代码实现：
//浅复制 class Program { static void Main(string[] args) { ShallowCopy sc1 = new ShallowCopy(); ShallowCopy sc2 = (ShallowCopy)sc1.Clone(); sc1.v[0] = 9; sc1.Display();//输出：9，2，3 sc2.Display();//输出：9，2，3 Console.Read(); } } class ShallowCopy : ICloneable { public int[] v = { 1, 2, 3 }; public Object Clone() { return this.MemberwiseClone();//浅复制 } public void Display() { foreach (int i in v) Console.Write(i + ", "); Console.WriteLine(); } }
//深复制 class Program { static void Main(string[] args) { DeepCopy dc1 = new DeepCopy(); DeepCopy dc2 = (DeepCopy)dc1.Clone(); dc1.v[0] = 9; dc1.Display(); dc2.Display(); Console.Read(); } } class DeepCopy : ICloneable { public int[] v = { 1, 2, 3 }; // 默认构造函数 public DeepCopy() { } // 供Clone方法调用的私有构造函数 private DeepCopy(int[] v) { this.v = (int[])v.Clone(); } public Object Clone() { // 构造一个新的DeepCopy对象，构造参数为 // 原有对象中使用的 v return new DeepCopy(this.v); } public void Display() { foreach (int i in v) Console.Write(i + ", "); Console.WriteLine(); } }
单例模式：
使用场景：
一个网站的服务端程序，需要考虑怎样才能承载大量用户，在做web程序的时候有各种负载均衡的方案，其基本思想就是有一个统一的入口，然后由它来分配用户到各个服务器上去。需要考虑的问题是，即使在多线程的并发状态下，用户只能通过一个唯一的入口来分配，由此引入单例模式来实现这个唯一的入口。
不要滥用Singleton模式，只有非一个实例不可的情况下才考虑引入Singleton。否则，程序的可扩展性可能会受到限制。
UML图：
伪代码实现,“懒汉式单例类”（被第一次引用时才会自己实例化）:
class Singleton { private static Singleton instance; private static readonly object syncRoot = new object();//程序运行时创建一个静态只读的进程辅助对象 private Singleton()//构造方法改成private，堵死外界通过new来创建此类实例的可能 { } public static Singleton GetInstance() { if (instance == null)//先判断实例是否存在，不存在再加锁处理，双重锁定 { lock (syncRoot) { if (instance == null) { instance = new Singleton(); } } } return instance; } }
C#提供了一种“静态初始化”方法，这种方法不需要开发人员显示的编写线程安全的代码，即可解决多线程环境下它是不安全的问题，称为“饿汉式单例类”（自己被加载时就实例化）。
public sealed class Singleton//sealed阻止派生发生，而派生可能会增加实例 { private static readonly Singleton instance = new Singleton();//在第一次引用类的任何成员时创建实例，公共语言运行库负责处理变量初始化 private Singleton() { } public static Singleton GetInstance() { return instance; } }
标签：
原文地址：http://www.cnblogs.com/sunjl/p/4600759.html
