设计模式
故事模式：
http://myqiao.cnblogs.com/category/33478.html?Show=All
设计模式仅仅是用来描述在软件设计中解决特定问题的一种可重复的方法
1、单件模式Singleton Pattern:要求一个类有且仅有一个实例，并且提供了一个全局的访问点a、静态初始化－构造单件模式
public sealed class Singleton
{
static readonly Singleton instance=new Singleton();
static Singleton(){}//这里决定不能用new来创建多个实例
Singleton(){}
public static Singleton Instance
{
get
{
return instance;
}
}
}
b、使构造函数不为public即可
http://terrylee.cnblogs.com/archive/2005/12/09/293509.html
2、抽象工厂模式（Abstract Factory）
目的：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的地方，应对“多系列对象创建”的需求变化
实现：创建一个配置文件，在类中读取，通过反射动态产生类
应用：游戏开发中的多风格系列场景，比如道路，房屋，管道等。支持多种观感标准的用户界面工具箱
工厂方法模式与抽象工厂模式，两个模式比较相似，把任何一个独立出来，好像都不太好，所以把它们放到一起来理解会更好。不管是工厂方法还是抽象工厂，都有三个要素，那就是Client，Factory，Product。
首先看一下工厂方法模式：
定义一个创建对象的接口，然后把对象的创建放到子类中进行。也就是说，我们要定义一个IFactory（可以是类，抽象类，也可以是接口），然后有一些具体的Factory继承自它，如AFactory，BFactory等。然后Product的创建就放到AFactory或BFactory来实现。注意这里，一个Factory只生产一种Product，这一点很重要。一个现实的例子就是，假如我们（Client）要配一台电脑（主机PC+显示器Screen），我们就要去不同的厂家（IFactory）去购买。过程为：
Client à Factory à Product à Client。我们用代码表示如下：
9 public class Product
10 {
11 //...
12 }
13 public class PC : Product
14 {
15 //...
16 }
17 public class Screen : Product
18 {
19 //...
20 }
21 public interface IFactory
22 {
23 Product CreateProduct();
24 }
25 public class PCFactory : IFactory
26 {
27 public Product CreateProduct()
28 {
29 return new PC();
30 }
31 }
32 public class ScreenFactory : IFactory
33 {
34 public Product CreateProduct()
35 {
36 return new Screen();
37 }
38 }
40 public class Client
41 {
42 public void BuySome()
43 {
44 List<IFactory> factories = new List<IFactory>();
45 factories.Add(new PCFactory());
46 factories.Add(new ScreenFactory());
47
48 foreach (IFactory factory in factories)
49 {
50 factory.CreateProduct();
51 //...
52 }
53 }
54 }
抽象工厂模式：
上面我们曾提到，工厂方法模式是一个Factory只产生一种Product，而对抽象工厂模式来说，就是一个工厂生产多种Product。也就是说这个时候Product已经不是一种了，而是多种。一句话，就是由一个工厂（Factory）生产不同的产品（Product）来满足Client的需求。
代码如下：
9 public class PCProduct
10 {
11 //...
12 }
13 public class ScreenProduct
14 {
15
16 }
17 public class APC : PCProduct
18 {
19 //...
20 }
21 public class BPC : PCProduct
22 {
23 //...
24 }
25 public class AScreen : ScreenProduct
26 {
27 //...
28 }
29 public class BScreen : ScreenProduct
30 {
31 //...
32 }
33 public interface IFactory
34 {
35 PCProduct CreatePCProduct();
36 ScreenProduct CreateScreenProduct();
37
38 }
39 public class AFactory : IFactory
40 {
41 public PCProduct CreatePCProduct()
42 {
43 return new APC();
44 }
45
46 public ScreenProduct CreateScreenProduct()
47 {
48 return new AScreen();
49 }
50 }
51 public class BFactory : IFactory
52 {
53 public PCProduct CreatePCProduct()
54 {
55 return new BPC();
56 }
57
58 public ScreenProduct CreateScreenProduct()
59 {
60 return new BScreen();
61 }
62 }
63
64 public class Client
65 {
66 public void BuySome()
67 {
68 List<IFactory> factories = new List<IFactory>();
69 factories.Add(new AFactory());
70 factories.Add(new BFactory());
71
72 foreach (IFactory factory in factories)
73 {
74 factory.CreatePCProduct();
75 factory.CreateScreenProduct();
76 //...
77 }
78 }
79 }
从上面代码，我们可以看出，从工厂方法到抽象工厂，他的变化，就在于Product由一种变成了多种，而Factory由生产一种产品变成了多种，虽然看似很小的变化，但产生的意义是很大的。
对比工厂方法，抽象工厂的意义" 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类"，我们发现，抽象工厂的对象加了形容词"一系列相关或相互依赖"。
