Question

我已经实现了如下的复合模式

public interface IComponent
{
   string Name { get; }
}

public interface IComposite : IComponent
{
    void AddRange(IEnumerable<IComponent> components);
}
public interface ILeaf : IComponent
{
    string Content { get; }
    string Parent { get; }
}

public class Composite : IComposite
{
    // return an iterator?
    private readonly List<IComponent> _children = new List<IComponent>();

    public Composite(string name)
    {
        Name = name;
    }

    public string Name { get; }

    public void AddRange(IEnumerable<IComponent> components)
    {
        _children.AddRange(components);
    }
}

public class Leaf : ILeaf
{
    public string Name { get; }
    public string Content { get; }
    public string Parent { get; }

    public Leaf(string name, string content, string parent)
    {
        Name = name;
        Content = content;
        Parent = parent;
    }
}

我已经从xml文件中填充了复合，如下所示

var collection = XElement.Load(@"C:\somexml.xml");
   var composite = CreateComposite(collection);

，其中

public IComponent CreateComposite(XElement element)
    {
        if (!element.HasElements)
            return new Leaf(element.Name.LocalName, element.Value, element.Parent.Name.LocalName);

        var composite = new Composite(element.Name.LocalName);
        composite.AddRange(element.Elements().Select(CreateComposite));
        return composite;
    }

这会按预期填充我的复合材料 - 太棒了！但是，我现在喜欢我的复合通过IEnumerable的实现返回一个迭代器。所以我尝试了这个

public class Composite : IComposite, IEnumerable<IComponent>
{
    // return an iterator?
    private readonly List<IComponent> _children = new List<IComponent>();

    public Composite(string name)
    {
        Name = name;
    }

    public string Name { get; }

    public void AddRange(IEnumerable<IComponent> components)
    {
        _children.AddRange(components);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<IComponent> GetEnumerator()
    {
        foreach (var child in _children)
        {
            yield return child;
        }
    }
}

但是这只会遍历最高级别的组件，即不会返回嵌套在_children中的任何组件。如何更新它以递归遍历所有组件？

Answer 1

您可以使用Linq以递归方式实现遍历，如下所示。

public IEnumerable<IComponent> GetSuccessors()
{
    return _children
           .Concat(_children.SelectMany(iChild => iChild.GetSuccessors());
}

如果需要depht-first traversal，您可以使用以下实现。

public IEnumerable<IComponent> GetSuccessors()
{
    return _children
           .SelectMany(iChild => new IComponent[]{iChild}.Concat(iChild.GetSuccessors()));
}

或者，如果您需要使用初始语法，则可以使用以下内容。

public IEnumerator<IComponent> GetEnumerator()
{
    var Successors
        = _children
          .SelectMany(iChild => new IComponent[]{iChild}.Concat(iChild.GetSuccessors()));
    foreach (var iSuccessor in Successors)
    {
        yield return iSuccessor;
    }
}

Answer 2

你可以像这样递归迭代（它将以深度优先的方式进行迭代）：

public interface IComposite : IComponent, IEnumerable<IComponent>
{
    void AddRange(IEnumerable<IComponent> components);
}

public IEnumerator<IComponent> GetEnumerator()
{
    foreach (var child in _children)
    {
        yield return child;
        var composite = child as IComposite;
        if (composite != null) {
            foreach (var sub in composite) {
                yield return sub;
            }
        }
     }
}

如果您想避免转换为IComposite - 您需要重新设计界面并让Composite保留另一个IComposite的列表而不是组件。然后，ILeft也将变为IComposite，并带有虚拟实现。

为复合模式的叶节点实现IEnumerable

2 个答案: