C#简单工厂模式和单列设计模式潜要解析

　　　　简单工厂设计模式，又叫做静态工厂方法（Static Factory Method）模式，就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。

　　简单工厂模式是工厂模式家族中最简单实用的模式。简单工厂设计模式是针对于创建类的对象的。

　　　　一般，简单工厂涉及到三个 角色/类：

　　　　　　一、工厂类：工厂类是简单工厂的核心，通过工厂类可以分别出的客户需求，在调用其子类。

　　　　　　二、抽象产品类：这个类是由工厂方法模式所创建的对象的父类，一般由接口和抽象类实现。

　　　　　　三、具体产品类：工厂方法模式所创建的任何对象都是这个角色的实例，由具体类实现。

　　下面我们用简单工厂设计一个订餐器：如图

首先，定义一个Pizza类，该类为抽象类，用于保存客户点击获取到的pizza类型，代码如下：

1 namespace Day08_0100.简单工厂
2 {
3    public abstract class Pizza
4     {
5        public  abstract string  Info();
6     }
7 }

　　　　其次，在定义两个string类，分别装pizza的种类，并用return返回值，代码如下：

 1 namespace Day08_0100.简单工厂
 2 {
 3    public class PGPizza:Pizza
 4     {
 5         public override string Info()
 6         {
 7             return "提示代码1";
 8         }
 9     }
10 }

 1 namespace Day08_0100.简单工厂
 2 {
 3    public class CheesePizza:Pizza
 4     {
 5         public override string Info()
 6         {
 7             return "提示代码2";
 8         }
 9     }
10 }

　　之后，是最为关键的，就是创建工厂类(PizzaFactory),该类包含一个静态的方法，该方法的返回值类型必须是抽象类；

　　工厂类根据传入的参数决定创建出哪一种产品类的实例。

　　示例代码：

 1 namespace Day08_0100.简单工厂
 2 {
 3    public class PizzaFactory
 4     {
 5        public static Pizza getInstance(string type)
 6        {
 7            Pizza pizza=null;
 8            switch (type)
 9            {
10                case "提示代码1":
11                    pizza = new PGPizza();
12                    break;
13                case "提示代码2":
14                    pizza = new CheesePizza();
15                    break;
16            }
17            return pizza;
18        }
19     }
20 }

　　最后是在窗体中调用，在Button控件click事件下写如下代码：

 1 private void btnOK_Click(object sender, EventArgs e)
 2         {
 3             //01.获取到用户选择的是哪种类型的Pizza
 4             if (rboPG.Checked)   //需要订购培根比萨
 5             {
 6               Pizza pizza=  PizzaFactory.getInstance(rboPG.Text);
 7                 string word=pizza.Info();
 8                 MessageBox.Show(word);
 9                 //Animal animal=new Dog();
10             }
11         }

　　如此，用简单工厂订购pizza已经完成。

　　单列设计模式

　单列模式：顾名思义就是一个对象只能初始化一次；

　　作用：减少开辟内存空间，节约内存开销

下面我来给大家说一个例子吧：

 1 class Program
 2     {
 3
 4         static void Main(string[] args)
 5         {
 6             A a1 = A();
 7             A a2 = A();
 8             Console.WriteLine(a1 == a2); //输出false
 9         }
10     }

　　因为A对象在内存堆中开辟了a1和a2两个内存空间 所以他们的内存地址不可能相同。

　　那么，怎样才能开辟一个空间，而不是两个或者多个呢？那就需要使用到单列设计模式了 下面是A类的定义：

 1  public class A
 2     {
 3         private static A a =null; //静态变量在类加载的时初始化，并且只初始化一次
 4     //构造方法私有化在外不能new对象
 5         private A()
 6         {
 7         }
 8         public static A getsingleInstance()
 9         {
10             if (a == null)
11             {
12                 a = new A();
13             }
14             return  a;
15         }
16     }

　　在运行下列代码：

 1 class Program
 2     {
 3
 4         static void Main(string[] args)
 5         {
 6             A a1 = A.getsingleInstance(); //同一个内存地址
 7             A a2 = A.getsingleInstance();
 8             A a3 = A.getsingleInstance();
 9             Console.WriteLine(a1 == a2);//True
10             Console.WriteLine(a2 == a3);//True
11
12         }
13     }

　　将构造方法设为私有方法，不能New。