C#设计模式之2——工厂方法模式

上一个设计模式连接: http://blog.csdn.net/weixingstudio/article/details/7234423

这个CSDN的编辑器不是很好用，不知道为什么插入代码以后就没有了文本编辑的地方，结果后来的所有文本都以代码显示了。 

 

在简单工厂模式中，需要由某个类充当指挥者，决定集成层次中的哪一个子类被实例化。

 

工厂方法(Factory Method)模式是这一想法的一个聪明而又巧妙的扩展，在工厂方法模式中，不会由单个类来决定实例化哪一个子类，相反，父类把这一决定推迟到了每一个子类中。该模式实际上并不存在一个决策点，某个子类由另一个类直接选中，依照这一模式编写的程序定义了一个抽象类，该类创建对象，但是让每个子类自己来决定创建哪一个对象。

 

拿游泳比赛泳道排位的算法来做个比较，由于我看到资料中游泳比赛的排位描述不清，所以我们这里不研究游泳比赛具体的排位算法，只是探讨工厂方法模式的应用。

简单的知道游泳比赛排位可以分为直接排位和循环排位。

 

类的层次结构视图。

 

我们设计一个赛事类，为Event类，类的定义如下：

using System;
using System.Collections;
using CsharpPats;

namespace Seeding
{
	/// <summary>
	/// Summary description for Event.
	/// </summary>
	public abstract class Event 	{
		protected int numLanes;
		protected ArrayList swimmers;

		public Event(string filename, int lanes) {
			numLanes = lanes;
			swimmers = new ArrayList();
			//read in swimmers from file
			 csFile f = new csFile(filename);
			f.OpenForRead ();
			string s = f.readLine();
			while (s != null) {
				Swimmer sw = new Swimmer(s);
				swimmers.Add (sw);
				s = f.readLine();
			}
			f.close();
		}
		public abstract Seeding getSeeding();
		public abstract bool isPrelim();
		public abstract bool isFinal();
		public abstract bool isTimedFinal();
	}
}


 
接着我们可以派生两个赛事类，都继承了Event 类，这两个派生的名字分别为PrelimEvent和 TimedFinalEvent，这两个类的不同之处仅仅在于一个返回某种排位方式而另外一个类返回另外一种排位方式。
 
我们定义一个抽象的排位类Seeding:
using System;
using System.Collections ;
namespace Seeding
{
	/// <summary>
	/// Summary description for Seeding.
	/// </summary>
	public abstract class Seeding 	{
		protected int       numLanes;                      
		protected int[]     lanes;
		public abstract IEnumerator getSwimmers();
		public abstract int getCount();
		public abstract int getHeats();
		protected abstract void seed();
		//--------------------------------
		protected void calcLaneOrder() {
			lanes = new int[numLanes];
			int mid = numLanes / 2;
			if (odd(numLanes))
				mid = mid + 1;       //start in middle lane
			int incr = 1;
			int ln = mid;
			//create array of lanes from
			//center to outside
			for (int i=0; i< numLanes; i++) {
				lanes[i] = ln;
				ln = mid + incr;
				incr = - incr;
				if (incr > 0)
					incr=incr+1;
			}
		}
		//--------------------------------
		private bool odd(int x) {
			return(((x / 2)*2) != x);
		}
	}
}



接下来我们可以创建两个具体的排位子类：StraightSeeding和CircleSeeding。PrelimEvent将会返回CircleSeeding类的一个实例，而TimedFinalEvent类则返回StraightSeeding的一个实例。这样以来，我们就有两个层次结构，一个是Event类的，一个是Seeding类的。
在Event类的层次结构中，你会看到两个派生于Event类的类都包含一个getSeeding()方法，其中的一个返回StraightSeeding，而另外一个则返回CircleSeeding。这样，我们可以看出，这里不存在一个实际上的工厂决策点，而是由实例化哪一个Event类的决定来确定哪一个Seeding的子类会呗实例化。
简单的说，就是在Event类的子类中，不同的子类创建不同的Seeding类的子类对象，创建不同的Event类的子类，就对应着创建了不同的Seeding类的子类，而不是像简单工厂模式那样存在一个决策点来决定创建哪一个子类。
 
程序中用到了Swimmer类，这个类包含了姓名，所属俱乐部年龄排名时间记录泳道等信息。
 
在Event类的基础上，我们派生了PrelimEvent和 TimedFinalEvent两个类，Event基类中包含了判断赛事是预赛还是决赛或者计时决赛的空方法。
PrelimEvent的定义：
using System;

namespace Seeding
{
	/// <summary>
	/// Summary description for PrelimEvent.
	/// </summary>
	public class PrelimEvent:Event
	{
		public PrelimEvent(string filename, int lanes):base(filename,lanes) {
					}
		//return circle seeding
		public override Seeding getSeeding() {
			return new CircleSeeding(swimmers, numLanes);
		}
		public override bool isPrelim() {
			return true;
		}
		public override bool isFinal() {
			return false;
		}
		public override bool isTimedFinal() {
			return false;
		}
	}
}
 
请注意，PrelimEvent类中，getSeeding()方法返回的是CircleSeeding类。
TimedFinalEvent的定义：
using System;

namespace Seeding {
	/// <summary>
	///class describes an event that will be swum twice
	/// </summary>
	public class TimedFinalEvent:Event  {
	
		public TimedFinalEvent(string filename, int lanes):base(filename, lanes) {
		}
			//return StraightSeeding class
			public override Seeding getSeeding() {
				return new StraightSeeding(swimmers, numLanes);
			}
		public override bool isPrelim() {
			return false;
		}
		public override bool isFinal() {
			return false;
		}
		public override bool isTimedFinal() {
			return true;
		}
	}
}



在这个类中，，getSeeding()方法返回的是StraightSeeding类。
 
根据返回的排序类的不同，就可以在不同的赛事中做出不同的排序。
 
StraightSeeding和CircleSeeding两个子类的实现这里不给出了，我们不用关心具体的算法问题。
类的层次结构视图如图：见上。
 
 
在应用程序初始化的时候，调用了如下的代码：
private void init() {
			//create array of events
			events = new ArrayList ();
			lsEvents.Items.Add ("500 Free");
			lsEvents.Items.Add ("100 Free");
			//and read in their data
			events.Add (new TimedFinalEvent ("500free.txt", 6));
			events.Add (new PrelimEvent ("100free.txt", 6));
		}


这个过程创建了两个Event类的子类的实例，每个子类一个实例，所以在工厂方法模式中，不存在一个决策点来决定创建哪个子类，而是将这一决定推迟到每一个子类中，例如我们这里的例子中，每一个Event子类对应一个排序类的引用，先是生成多个Event类子类的实例，但是到最后应用的时候只有一个实例被选中。
事件的调用：
private void lsEvents_SelectedIndexChanged(object sender, System.EventArgs e) {
			int index = lsEvents.SelectedIndex ;
			Event ev = (Event)events[index];
			Seeding sd = ev.getSeeding();
			IEnumerator en  = sd.getSwimmers();
			lsSwimmers.Items.Clear() ;
			while(en.MoveNext ()) {
				Swimmer sw = (Swimmer)en.Current ;
				lsSwimmers.Items.Add(sw.getHeat()+" "+sw.getLane()+" "+sw.getName()+" "+sw.getTime());
			}
		}


这段代码中，通过获取列表框中的选取值来判断Event类的哪一个子类应该呗选中，然后通过这个选中子类调用这个子类对应的Seeding类的哪个子类，从而进行排序。
使用工厂方法模式还是利用了面向对象的多态性，利用一个Event类的数组来保存对所有派生类实例的引用，然后确定应该选中哪一个子类，由于多态性，利用Event类的方法即可调用这个派生类的派生方法。
使用工厂方法模式应该注意的问题：
1. 类不能预测他必须创建哪一种类型的对象。
2. 类使用他的子类来指定要创建的对象。
3. 希望只有局部知晓哪个类会被创建。