分层收集的通用接口

Question

我想创建一个严格遵循以下结构的层次结构：

(1) INodeBase - 包含一个 Children 属性，该属性是其自身的集合 (INodeBase)

(2) INodeFolder - 派生自 INodeBase。

(3) NodeFolder - 实现 INodeFolder。 Children 属性的实现应该允许它包含 INodeFolder 类型和 INodeItem 类型的项目。

(4) INodeItem - 派生自 INodeBase。

(5) NodeItem - 实现 INodeItem。 Children 属性的实现应该允许它包含 NodeResult 类型的项目。

(6) INodeResult - 派生自 INodeBase。

(7) NodeResult - 实现 INodeResult - 我不需要/想要此类中的子属性，但是，如果可以正确构建整体层次结构，我愿意在类中挂起一个空集合。

本质上，我想要节点的一种基本类型 - 并且假设应该是一个节点可以包含其他节点。我认为泛型是可行的方法 - 但是 - 问题是，如果我查询整个分层集合，或者更确切地说，如果我对其进行过滤，当我递归地遍历每个孩子的子集合（即展平我的集合），我想知道什么是什么 - 即，如果我在文件夹的 Children 集合中，我想知道何时点击FolderNode，何时点击 ItemNode，然后何时递归遍历文件夹的 Children 属性一个 ItemNode，我想知道我只是在处理 NodeResult 类型。

那么，针对上述情况的最佳方法是什么？

克里斯

Answer 1

我认为下面的代码都遵循您想要的规则，特别是所有实现 INodeBase 的节点，以及 NodeResult 没有 Children 的好处> 收藏。

以下是所需的接口：

public interface INodeBase
{
}

public interface INodeContainer : INodeBase
{
}

public interface INodeContainer<C> : INodeContainer
    where C : INodeBase
{
    IList<C> Children { get; }
}

public interface INodeFolder : INodeContainer<INodeContainer>
{
}

public interface INodeItem : INodeContainer<INodeResult>
{
}

public interface INodeResult : INodeBase
{
}

我添加了几个 INodeContainer 接口 - 一个是非通用的，另一个是 INodeContainer。另一个通用的。

以下是类定义：

public abstract class NodeBase : INodeBase
{
}

public abstract class NodeBase : INodeBase
{
}

public abstract class NodeContainer : NodeBase, INodeContainer
{
}

public abstract class NodeContainer<C> : NodeContainer, INodeContainer<C>
    where C : INodeBase
{
    public NodeContainer() { this.Children = new List<C>(); }
    public IList<C> Children { get; private set; }
}

public class NodeFolder : NodeContainer<INodeContainer>, INodeFolder
{
}

public class NodeItem : NodeContainer<INodeResult>, INodeItem
{
}

public class NodeResult : INodeResult
{
}

现在您可以使用如下代码：

var nf = new NodeFolder();
nf.Children.Add(new NodeFolder()); // Add `INodeFolder`
var ni = new NodeItem();
nf.Children.Add(ni);  // or add `INodeFolder`, but nothing else.
var nr = new NodeResult();
ni.Children.Add(nr); // Only add `INodeResult`.
// nr does not have "Children" collection.

如果您愿意，您可以将 INodeContainer 限制在具体类型而不是接口上。这取决于您是想通过接口还是通过具体类来引用对象。

让我知道这是否适合您。

Answer 2

不过，这不是主要答案，为什么不直接使用类和对象而不是接口来设计对象层次结构。稍后您可以将其转变为界面层次结构。

enum NodeTypes { Unknown, Folder, File };

public abstract class CNodeBase {

    protected List<CNodeBase> FItems;

    public List<CNodeBase> Items();

    public virtual NodeTypes NodeType() {
        return NodeTypes.Unknown;
    }
}

public class CNodeFolder: CNodeBase {

// ...

    public override NodeTypes NodeType() {
        return NodeTypes.Folder;
    }

}

public class CNodeFile: CNodeBase {

// ...

    public override NodeTypes NodeType() {
        return NodeTypes.File;
    }

}

public class CDemo {

    void main () {
        // root node is ALWAYS A folder
        CNodeFolder RootNode = new CNodeFolder("\\");

        CNodeBase AnyNode = null;

        AnyNode = new CNodeFolder("c:");
        RootNode.Add(AnyNode);

        AnyNode = new CNodeFolder("d:");
        RootNode.Add(AnyNode);

        AnyNode = new CNodeFile("readme.txt");
        RootNode.Add(AnyNode);  
    }
}

超类（抽象的或具体的）的工作方式与接口非常相似，但具有的优点是您可以从中实例化对象，请参阅代码的工作原理。

在我看来，你正在尝试做一些非常概念化的事情。也许如果你退一步，去学习可以实例化的类，你可能会对你的想法有一个更实际的看法。

界面是一个非常好的功能，但一开始很难理解。有时候，“退一步，进五步”也是个好主意。

Answer 3

为什么需要让文件夹和项目实现相同的接口？

在我看来，像这样的更简单的结构会更好......

public class Folder
{
    public List<Folder> Folders { get; }
    public List<Item> Items { get; }
}

public class Item
{
    public List<Result> Results { get; }
}

public class Result
{

}