组合模式扩展，有选择的递归

1.先定义个选择接口规则

 public interface IMatchRule

    {

        bool IsMatch(Component target);

    }

 public abstract class Component

    {

        /// <summary>

        /// 保存子节点

        /// </summary>

        protected IList<Component> children;



        /// <summary>

        /// Leaf和Composite的共同特征. setter方式注入名称

        /// </summary>

        public virtual string Name

        {

            get;

            set;

        }



        /// <summary>

        /// 其实只有Composite类型才需要真正实现的功能

        /// </summary>

        /// <param name="child"></param>

        public virtual void Add(Component child) { children.Add(child); }

        public virtual void Remove(Component child) { children.Remove(child); }

        public virtual Component this[int index] { get { return children[index]; } }



        /// <summary>

        /// 演示用的补充方法：实现迭代器，并且对容器对象实现隐性递归

        /// </summary>

        /// <returns></returns>

        public virtual IEnumerable<Component> Enumerate(IMatchRule rule)

        {

            if ((rule == null) || (rule.IsMatch(this)))

                yield return this;

            if ((children != null) && (children.Count > 0))

                foreach (Component child in children)

                    foreach (Component item in child.Enumerate(rule))

                        if ((rule == null) || (rule.IsMatch(item)))

                            yield return item;

        }

        public virtual IEnumerable<Component> Enumerate() { return Enumerate(null); }

    }

    public class Leaf : Component

    {

        /// <summary>

        /// 明确声明不支持此类操作

        /// </summary>

        /// <param name="child"></param>

        public override void Add(Component child) { throw new NotSupportedException(); }

        public override void Remove(Component child) { throw new NotSupportedException(); }

        public override Component this[int index] { get { throw new NotSupportedException(); } }

    }

  public class Composite : Component

    {

        public Composite() { base.children = new List<Component>(); }

    }

在工厂类中

 public class ComponentFactory

    {

        public Component Create<T>(string name) where T : Component, new()

        {

            return new T() { Name = name };

        }



        /// <summary>

        /// 连贯性方法（Fluent Method）: 直接向某个节点下增加新的节点

        /// </summary>

        /// <typeparam name="T"></typeparam>

        /// <param name="parent"></param>

        /// <param name="name"></param>

        /// <returns></returns>

        public Component Create<T>(Component parent, string name)

            where T : Component, new()

        {

            if (parent == null) throw new ArgumentNullException("parent");

            if (!(parent is Composite)) throw new Exception("non-somposite type");

            Component instance = Create<T>(name);

            parent.Add(instance);

            return instance;

        }

    }

那么在实现中调用则

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using C = MarvellousWorks.PracticalPattern.Composite.Iterating;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace MarvellousWorks.PracticalPattern.Composite.Tests.Iterating

{

    [TestClass]

    public class CompositeFixture

    {

        #region non-linq version



        class LeafMatchRule : C.IMatchRule

        {

            public bool IsMatch(C.Component target)

            {

                if (target == null) return false;

                return target.GetType().IsAssignableFrom(typeof(C.Leaf));

            }

        }



        C.Component corporate;



        /// <summary>

        /// 建立测试公司的组织结构

        /// </summary>

        [TestInitialize]

        public void Initialize()

        {

            var factory = new C.ComponentFactory();

            corporate = factory.Create<C.Composite>("corporate");           // 1

            factory.Create<C.Leaf>(corporate, "president");                 // 2

            factory.Create<C.Leaf>(corporate, "vice president");            // 3

            var sales = factory.Create<C.Composite>(corporate, "sales");    // 4

            var market = factory.Create<C.Composite>(corporate, "market");  // 5

            factory.Create<C.Leaf>(sales, "joe");                           // 6

            factory.Create<C.Leaf>(sales, "bob");                           // 7

            factory.Create<C.Leaf>(market, "judi");                         // 8

            var branch = factory.Create<C.Composite>(corporate, "branch");  // 9

            factory.Create<C.Leaf>(branch, "manager");                      // 10

            factory.Create<C.Leaf>(branch, "peter");                        // 11

        }



        [TestMethod]

        public void Test()

        {

            Assert.AreEqual<int>(7, corporate.Enumerate(new LeafMatchRule()).Count());

            Assert.AreEqual<int>(11, corporate.Enumerate().Count());



            //  验证通过增加遍历规则可以只显示所有leaf节点

            Trace.WriteLine("List all leaves:\n------------------------\n");

            foreach (var item in corporate.Enumerate(new LeafMatchRule()))

                Trace.WriteLine(item.Name );

        }



        #endregion



    }

}