简单工厂模式....续！！！！！

简单工厂模式根据提供的数据或者参数返回几个可能的类中的一个实例，说通俗点有点像面向对象编程中的多态性，一个基类，有多个派生类，在另外的调用程序中，根据参数来决定返回这个基类的哪个具体的派生类，返回值为基类类型，因为基类的引用可以指向派生类对象，而且这些所有的派生类都包含有基类的函数，也就是说派生类中有相同的函数，但是函数的实现可能不同。

在简单工厂模式中，通常其返回的所有的类都有一个共同的基类和一些共同的方法，不过每一个类都完成不同的功能，并针对不同的数据类型做了不同的优化。简单工厂模式实际上并不是23个常用设计模式之一，但是也算是设计模式的简单入门，对以后的学习有比较大的帮助。

简单的理解，简单工厂模式更多的使用了面向对象编程中的多态性，基类的引用可以指向派生类，并且调用派生的方法，即多态性。

假定X是一个基类，XY和XZ都是派生于X的派生类，XFactory类中根据提供给它的参数来决定返回XY或者 类的哪一个，返回的是哪个类的实例对于编程者来说并不是那么重要，因为这些类有着相同的方法，编程者需要做的就是通过基类引用直接调用方法，不用去关心到底返回的是哪个派生类，因为这些类有相同的方法，只是实现不同而已。如何决定返回哪一个派生类，取决于工厂的设计，该方法可以是非常复杂的函数，也可以是简单的函数。

 假设我们有一个类，用来存放名字，其中包含名字的姓和名分别存放。这个类的基本代码如下：

using System;  
02.  
03.namespace NameFactory  
04.{  
05.    /// <summary>  
06.    /// Summary description for Namer.  
07.    /// </summary>  
08.    //Base class for getting split names  
09.    public class Namer  {  
10.        //parts stored here  
11.        protected string frName, lName;  
12.          
13.        //return first name  
14.        public string getFrname(){  
15.            return frName;  
16.        }  
17.        //return last name  
18.        public string getLname() {  
19.            return lName;  
20.        }  
21.    }  
22.}  

在这个类中可以分别返回名和姓。protected string frName, lName;两个受保护的变量可以被派生类继承。

现在我们派生两个非常简单的派生类，并在派生类中把姓名分割成两个部分。如果是姓在前，名在后，中间用空格分开，责是FirstFirst类，如果是姓在后，名在前，中间用“，”分开，则是LastFirst类。两个类的设计分别为：

using System;  
02.  
03.namespace NameFactory  
04.{  
05.    /// <summary>  
06.    /// Summary description for FirstFirst.  
07.    /// </summary>  
08.    public class FirstFirst : Namer  
09.    {  
10.        public FirstFirst(string name)  
11.        {  
12.            int i = name.IndexOf (" ");  
13.            if(i > 0) {  
14.                frName = name.Substring (0, i).Trim ();  
15.                lName = name.Substring (i + 1).Trim ();  
16.            }  
17.            else {  
18.                lName = name;  
19.                frName = "";  
20.            }  
21.        }  
22.    }  
23.}  

using System;  
02.  
03.namespace NameFactory  
04.{  
05.    /// <summary>  
06.    /// Summary description for LastFirst.  
07.    /// </summary>  
08.    public class LastFirst : Namer  
09.    {  
10.        public LastFirst(string name)       {  
11.            int i = name.IndexOf (",");  
12.            if(i > 0) {  
13.                lName = name.Substring (0, i);  
14.                frName = name.Substring (i + 1).Trim ();  
15.            }  
16.            else {  
17.                lName = name;  
18.                frName = "";  
19.            }  
20.        }  
21.    }  
22.}  

两个派生类中构造函数根据是不是有“，”来将名字中的姓和名分割开来，分别保存的对应的变量中。

然后我们就可以构建简单的工厂了，只需要检测逗号的存在，然后返回两个类中的一个就可以了。

using System;  
02.  
03.namespace NameFactory  
04.{  
05.    /// <summary>  
06.    /// Summary description for NameFactory.  
07.    /// </summary>  
08.    public class NameFactory    {  
09.        public NameFactory() {}  
10.  
11.        public Namer getName(string name) {  
12.            int i = name.IndexOf (",");  
13.            if(i > 0)  
14.                return new LastFirst (name);  
15.            else  
16.                return new FirstFirst (name);  
17.        }  
18.    }  
19.}  

这个工厂类的使用，添加一个按钮，按钮事件中调用NameFactory的getName方法，就可以返回一个Namer的引用，至于Namer到底指向哪个派生类，我们不用去关心。

private void btCompute_Click(object sender, System.EventArgs e) {  
02.            Namer nm = nameFact.getName (txName.Text );  
03.            txFirst.Text = nm.getFrname ();  
04.            txLast.Text = nm.getLname ();  
05.        } 

这就是简单工厂模式的基本原理，创建一个抽象，然后该抽象决定要返回的可能的几个类是哪些，接着简单工厂返回其中之一，然后就可以在无需知道真正使用的哪个子类的情况下调用返回的类实例的方法，这一做法把数据依赖问题与类的使用方法隔离开来。

简单工厂返回有着相同方法的类实例，他们有可能是不同的派生类的实例，或者有可能实际上是互不相关的类，只是共有相同的接口而已。无论是哪种方式，这些类实例的方法都是相同的，可以互换使用。