C#设计模式之9——组合模式

一般情况下，组件可以是单独的一个对象，也可以是对象的组合，组合模式就是为了迎合这两种情况进行设计。组合可以被用来构建部分-整体层次结构，或者是构造树形的数据表示方式。组合是对象的集合，而其中的任何一个对象又可能是一个组合，或者是一个简单的对象。

在树形结构中，访问组合中所有的对象要求有一个简单的单一访问接口，但同时要求能够区分开节点和叶子。在构造组合的时候，我们需要决定哪个节点是元素哪个是叶子。在这里我们可以通过子节点个数进行判断是不是叶子节点。

 

比如构造一个公司的人事管理系统，经理下面有部门经理，部门经理下面有小组负责人，小组负责人下面有员工这样一个树形结构。在程序里我们需要显示每个人的成本，对于普通员工，一个人的成本就是他的工资，而对于部门经理，他的成本就是他的工资加上手下所有人的工资。

 

我们需要定义两种类：雇员类和老板类，雇员类是叶子节点，老板类下面可以包含子节点。

用户界面如图：

一个类共同的接口：

using System;
using System.Collections ;
namespace Composite
{
	/// <summary>
	/// Summary description for AbstractEmployee.
	/// </summary>
	public interface AbstractEmployee  	{
		float getSalary();					//get current salary
		string getName();					//get name
		bool isLeaf();						//true if leaf
		void add(string nm, float salary);	//add subordinate
		void add(AbstractEmployee emp);		//add subordinate
		IEnumerator getSubordinates();		//get subordinates
		AbstractEmployee getChild();		//get child
		float getSalaries();				//get salaries of all 
	}
}

 

雇员类的定义：

using System;
using System.Collections ;
namespace Composite
{
	/// <summary>
	/// Summary description for Employee.
	/// </summary>
	public class Employee :AbstractEmployee 	{
		protected float salary;
		protected string name;
		protected ArrayList subordinates;
		//------
		public Employee(string nm, float salry) 		{
			subordinates = new ArrayList();
			name = nm;
			salary = salry;
		}
		//------
		public float getSalary() {
			return salary;
		}
		//------
		public string getName() {
			return name;
		}
		//------
		public bool isLeaf() {
			return subordinates.Count == 0;
		}
		//------
		public virtual void add(string nm, float salary) {
			  throw new Exception("No subordinates in base employee class");
		}
		//------
		public virtual void add(AbstractEmployee emp) {
			throw new Exception("No subordinates in base employee class");
		}
		//------
		public IEnumerator getSubordinates() {
			return subordinates.GetEnumerator ();
		}
		public virtual AbstractEmployee getChild() {
			return null;
		}
		//------		
		public float getSalaries() {
			float sum;
			AbstractEmployee esub;
			//get the salaries of the boss and subordinates
			sum = getSalary();
			IEnumerator enumSub = subordinates.GetEnumerator() ;
			while (enumSub.MoveNext())  {
				esub = (AbstractEmployee)enumSub.Current;
				sum += esub.getSalaries();
			}
			return sum;
		}
	}
}

 

这里通过IEnumerator对这个节点的子节点进行遍历。

getSalaries() 函数是一个递归的调用，可以计算自身工资和所有子节点工资的总和。

Boss类的定义如下：

using System;
using System.Collections ;
namespace Composite
{
	/// <summary>
	/// Summary description for Boss.
	/// </summary>
	public class Boss:Employee
	{
		public Boss(string name, float salary):base(name,salary) 	{
		}
		//------
		public Boss(AbstractEmployee emp):base(emp.getName() , emp.getSalary()) 	{
		}
		//------
		public override void add(string nm, float salary) {
			AbstractEmployee emp = new Employee(nm,salary);
			subordinates.Add (emp);
		}
		//------
		public override void add(AbstractEmployee emp){
			subordinates.Add(emp);
		}
		//------
		public override AbstractEmployee getChild() {
			bool found;
			AbstractEmployee tEmp = null;
			IEnumerator esub ;
        
        if (getName().Equals (getName())) 
            return this;
        else {
            found = false;
            esub = subordinates.GetEnumerator ();
            while (! found && esub.MoveNext()) {
				tEmp = (AbstractEmployee)esub.Current; 
				found = (tEmp.getName().Equals(name));
                if (! found) {
                    if (! tEmp.isLeaf()) {
                        tEmp = tEmp.getChild();
						found = (tEmp.getName().Equals(name));
					 }      
				}                             
			}
			if (found) 
			   return tEmp;
			  else                
			   return new Employee("New person", 0);
            }
		}
	}
}

Boss类继承了Employee类，因为Boss类本身也是雇员。

 

在主程序中就可以构建雇员的树形结构了：

private void buildEmployeeList() {
			prez = new Boss("CEO", 200000);
			marketVP = new Boss("Marketing VP", 100000);
			prez.add(marketVP);
			salesMgr = new Boss("Sales Mgr", 50000);
			advMgr = new Boss("Advt Mgr", 50000);
			marketVP.add(salesMgr);
			marketVP.add(advMgr);
			prodVP = new Boss("Production VP", 100000);
			prez.add(prodVP);
			advMgr.add("Secy", 20000);

			//add salesmen reporting to sales manager
			for (int i = 1; i<=5; i++){
				salesMgr.add("Sales" + i.ToString(), rand_sal(30000));
			}

			prodMgr = new Boss("Prod Mgr", 40000);
			shipMgr = new Boss("Ship Mgr", 35000);
			prodVP.add(prodMgr);
			prodVP.add(shipMgr);

			for (int i = 1; i<=3; i++){
				shipMgr.add("Ship" + i.ToString(), rand_sal(25000));
			}
			for (int i = 1; i<=4; i++){
				prodMgr.add("Manuf" + i.ToString(), rand_sal(20000));
			}
		}
		//-----
		private void buildTree() {
			EmpNode nod;

			nod = new EmpNode(prez);
			rootNode = nod;
			EmpTree.Nodes.Add(nod);
			addNodes(nod, prez);
		}

 

using System;
using System.Windows.Forms;
namespace Composite
{
	/// <summary>
	/// Summary description for EmpNode.
	/// </summary>
	public class EmpNode:TreeNode 	{
		private AbstractEmployee emp;
		public EmpNode(AbstractEmployee aemp ):base(aemp.getName ()) {
			emp = aemp;	
		}
		//-----
		public AbstractEmployee getEmployee() {
			return emp;
		}
	}
}

这样就完成一个组合模式的对对象的封装。

然后还需要下面一些时间函数：

private void EmpTree_AfterSelect(object sender, TreeViewEventArgs e) {
			EmpNode node;
			node = (EmpNode)EmpTree.SelectedNode;
			getNodeSum(node);
		}

 

private void getNodeSum(EmpNode node) {
			AbstractEmployee emp;
			float sum;

        emp = node.getEmployee();
        sum = emp.getSalaries();
        lbSalary.Text = sum.ToString ();

在这个例子的基础上，我们还可以添加树形结构的双向链表，从而可以进行从叶子节点向上遍历，方便的查找父类信息。

这样对Employee类的改动如下：

using System;
using System.Collections ;
namespace Composite
{
	/// <summary>
	/// Summary description for Employee.
	/// </summary>
	public class Employee :AbstractEmployee 	{
		protected float salary;
		protected string name;
		protected AbstractEmployee parent;
		protected ArrayList subordinates;
		//------
		public Employee(AbstractEmployee parnt, string nm, float salry) 		{
			subordinates = new ArrayList();
			name = nm;
			salary = salry;
			parent = parnt;
		}
		//------
		public AbstractEmployee getBoss() {
			return parent;
		}
		//------
		public float getSalary() {
			return salary;
		}
		//------
		public string getName() {
			return name;
		}
		//------
		public bool isLeaf() {
			return subordinates.Count == 0;
		}
		//------
		public virtual void add(string nm, float salary) {
			  throw new Exception("No subordinates in base employee class");
		}
		//------
		public virtual void add(AbstractEmployee emp) {
			throw new Exception("No subordinates in base employee class");
		}
		//------
		public IEnumerator getSubordinates() {
			return subordinates.GetEnumerator ();
		}
		public virtual AbstractEmployee getChild() {
			return null;
		}
		//------		
		public float getSalaries() {
			float sum;
			AbstractEmployee esub;
			//get the salaries of the boss and subordinates
			sum = getSalary();
			IEnumerator enumSub = subordinates.GetEnumerator() ;
			while (enumSub.MoveNext())  {
				esub = (AbstractEmployee)enumSub.Current;
				sum += esub.getSalaries();
			}
			return sum;
		}
	}
}

 

这个类中添加了一个指向父类的引用。

这样就可以向上遍历，找到上级领导信息：

private void btShowBoss_Click(object sender, System.EventArgs e) {
			EmpNode node;
			node = (EmpNode)EmpTree.SelectedNode;
			AbstractEmployee emp = node.getEmployee ();
			string bosses = "";
			while(emp != null) {
                bosses += emp.getName () +"\n";
				emp = emp.getBoss();
			}
			MessageBox.Show (null, bosses,"Reporting chain");
	}

组合模式允许定义简单对象和更加复杂的组件对象的类层次结构，这样这些对象就能够以相同的方式呈献给客户端程序。基于这一简易性，客户端就可以更加价单，因为节点和叶子可以被以同样的方式处理。

组合模式还可以让你很容易的添加新类型的组件到集合中，只要这些组件支持相类似的编程接口就可以了。