解耦模式

Question

在研究了主要的模式设计之后，我似乎无法下定决心在一个大层次系统中最好地将类解耦，特别是考虑到如何避免在整个过程中向每个对象注入父属性。

其中一些房地是：

1. 一个孩子可能会把我从父母中移走，再加到另一个父母身上。
2. 在层次结构的某个地方，我需要访问X类型的父级。
3. 如前所述，我希望避免向其子节点注入父级(通过属性或构造函数)。
4. 我有1..1和1.N个基数。
5. 从根到离叶最远的层次是相当大的。

如果这是一个小项目，我会同意这个(伪代码)：

public abstract class BaseObject()
{
    public BaseObject Parent { get; set; }
}

public class RootObject() : BaseObject
{
    public int Id { get; }
    public ParentObject[] Parent { get; set; }
}

public class ParentObject() : BaseObject
{
    public int Id { get; }
    public ChildObject[] Parent { get; set; }
}

public class ChildObject() : BaseObject
{
    public int Id { get; }

    public void DoSomething()
    {
        //...navigate through Parent to get RootObject (or any other type in between that I might need)...
    }
}

有人能给我指出正确的方向吗？

Answer 1

所有这些要求都提醒我图形数据结构

• 一个孩子可能会把我从父母中移走，再加到另一个父母身上。
• 在层次结构的某个地方，我需要访问X类型的父级。
• 如前所述，我希望避免向其子节点注入父级(通过属性或构造函数)。
• 我有1..1和1.N个基数。
• 从根到离叶最远的层次是相当大的。

最简单的存储将是List<Node> 其中，每个节点都包含指向其前身和后继节点的链接。

class Example
{
    public List<Node> InitGraph()
    {
        var nodes = new Dictionary<string, Node>();

        nodes.Add("Head", new Node("Head"));
        nodes.Add("T1", new Node("T1"));
        nodes.Add("T2", new Node("T2"));
        // While that works, a method is nicer:
        nodes.Add("C1");

        // These two lines should really be factored out to a single method call
        nodes["Head"].Successors.Add(nodes["T1"]);
        nodes["T1"].Predecessors.Add(nodes["Head"]);
        nodes["Head"].Successors.Add(nodes["T2"]);
        nodes["T2"].Predecessors.Add(nodes["Head"]);

        // Yes. Much nicer
        nodes.Connect("Head", "C1");
        nodes.Connect("T1", "C1");
        nodes.Connect("T2", "C1");

        var nodelist = new List<Node>(nodes.Values);
        return nodelist;
    }
}

和NodeHelper类：

public static class NodeHelper
{        
    public static void Add(this Dictionary<string, Node> dict, string nodename)
    {
        dict.Add(nodename, new Node(nodename));
    }
    public static void Connect(this Dictionary<string, Node> dict, string from, string to)
    {
        dict[ from ].Successors.Add(dict[ to ]);
        dict[ to ].Predecessors.Add(dict[ from ]);
    }
}

和Node类：

public class Node
{
    public string Name { get; set; }
    public int Coolness { get; set; }
    public List<Node> Predecessors { get; set; }
    public List<Node> Successors { get; set; }
    public Node()
    {
        Coolness = 1;
    }

    public Node(string name) : this()
    {
        this.Name = name;
    }
}