在DotNet中使用Composite模式

using System;
using System.Collections;


namespace Composite.CompositeEquipment
{
    /**//// <summary>
    /// 部件Component：那就是要在接口内部定义一个用于访问和管理Composite组合体的对象
    /// 适用范围：（树形结构图）
    /// 将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，
    /// 使得客户端对单个对象和组合对象的使用具有一致性
    /// 组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，
    /// Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行
    ///        1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，
    ///          用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
    ///        2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码
    /// </summary>
    public abstract class Equipment
    {
        /**//// <summary>
        /// 名称
        /// </summary>
        private string name;
        

        /**//// <summary>
        /// 取得实际价格
        /// </summary>
        /// <returns></returns>
        public abstract double netPrice() ;


        /**//// <summary>
        /// 取得折扣价格
        /// </summary>
        /// <returns></returns>
        public abstract double discountPrice();

        
        /**//// <summary>
        /// 增加部件方法
        /// </summary>
        /// <param name="equipment">部件</param>
        /// <returns></returns>
        public   bool add(Equipment equipment) 
        {
            return false;
        }

        
        /**//// <summary>
        /// 删除部件方法
        /// </summary>
        /// <param name="equipment">部件</param>
        /// <returns></returns>
        public bool remove(Equipment equipment) 
        {
            return false;
        }

        
        public System.Collections.ArrayList   iter() 
        {
            return null;
        }
        

        public Equipment(string name) 
        {
            this.name = name;
        }

        
    }
    
    
    /**//// <summary>
    /// 单独元素( Primitive)。
    /// </summary>
    public class Cabinet:Composite.CompositeEquipment.CompositeEquipment
    {
        public Cabinet(string name ): base(name)
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
    
　　 public new  double netPrice() { return 1.0+ base.netPrice(); }
　　 public new double discountPrice() { return .5+base.discountPrice(); }
    }
    
    /**//// <summary>
    /// 单独元素( Primitive)
    /// </summary>
    public class Chassis :Composite.CompositeEquipment.CompositeEquipment
    {


        public Chassis(string name ) : base(name)
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }


　　    public override double netPrice() { return 1.0+base.netPrice(); }
　　    public override double discountPrice() { return .5 + base.discountPrice(); }


    }
    
    
        /**//// <summary>
    /// 部分－整体
    ///1.单独元素( Primitive)
    ///2.一个部件也是一个组合体，就是说这个部件下面还有'儿子'，
    ///这是树形结构中通常的情况，应该比较容易理解
    /// </summary>
    public class CompositeEquipment :Equipment
    {


        private int i;
        private System.Collections.ArrayList equipment = new System.Collections.ArrayList();


        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name"></param>
        public CompositeEquipment(string name) : base(name) 
        {
        }
        

        /**//// <summary>
        /// 新增部件
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public    bool add(Equipment e) 
        {
            this.equipment.Add(e);
            return true;
        }

        /**//// <summary>
        /// 取得实际价格
        /// </summary>
        /// <returns></returns>
        public override double netPrice()  
        {

            double price =0;

            for (int index =0 ; index <this.equipment.Count; index++) 
            {
                price += ((Equipment)this.equipment[index]).netPrice();
            }
            return price;
        }


        /**//// <summary>
        /// 取得折扣价格
        /// </summary>
        /// <returns></returns>
        public  override double discountPrice()  
        {

            double price =0;

            for (int index =0 ; index <this.equipment.Count; index++) 
            {
                price += ((Equipment)this.equipment[index]).netPrice();
            }
            return price;
        }

        public bool hasNext() { return i<equipment.Count ; }


            public Object next()
　　        {
　　　　        if(hasNext())
　　　　　　        return equipment[i++];
　　　　        else 
　　 　　 　        throw new Exception("error");
　　        }

    }
    
        /**//// <summary>
    /// 单独元素( Primitive)
    /// </summary>
    public class Disk :Equipment 
    {
        
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name">名称</param>
        public Disk(string name) :base(name)
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }



        /**//// <summary>
        /// 定义了disk实价为1
        /// </summary>
        /// <returns></returns>
        public override double netPrice()
        {
            return 1.0;
        }


        /**//// <summary>
        /// 定义了disk折扣价格是0.5 对折
        /// </summary>
        /// <returns></returns>
        public override double discountPrice()
        {
            return 0.5;
        }

        
    }
    
    /**//// <summary>
    ///为测试代码
    /// 将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，
    /// 使得客户端对单个对象和组合对象的使用具有一致性
    /// </summary>
    class CompositeTest
    {
        /**//// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            //
            // TODO: 在此处添加代码以启动应用程序
            //

            Cabinet cabinet=new Cabinet("Tower");

            Chassis chassis=new Chassis("PC Chassis");
            //将PC Chassis装到Tower中 (将盘盒装到箱子里)
            cabinet.add(chassis);
            //将一个10GB的硬盘装到 PC Chassis (将硬盘装到盘盒里)
            chassis.add(new Disk("10 GB"));

            //调用 netPrice()方法;
            Console.WriteLine ("netPrice="+cabinet.netPrice());
            Console.WriteLine ("discountPrice="+cabinet.discountPrice());
            Console.ReadLine();

        }
    }
}

Composite:将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.
               想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。