有没有办法访问'超级'类的字段（不继承）

Question

标题可能会产生误导，因为我在搜索甚至创建一个正确的问题时遇到了一些麻烦，所以让我给出一个我正在努力解决的真正问题：

我有一个Graph课程。由于图形需要节点和边缘，因此我创建了另外两个类Node（顶点）和Edge。我的结构看起来像这样：

class Graph
{
    List<Node> nodes;
    List<Edge> edges;

    public Graph( ... ) { /* populate lists */ }
}

class Node { ... }
class Edge { ... }

我为Node课写了一些方法，其中一个对我来说特别有问题。签名：

public List<Node> GetNeighbours(List<Edge> edges) { ... }

非常标准。给出一个图表，我问一个节点：你有多少邻居？我需要边缘列表来解决它。

如何重构此代码，以便我可以在内部使用Graph属性/字段，而不是每次都传递边缘列表？这样的事情是可能的：

public List<Node> GetNeighbours()
{
    // ...
    foreach(edge in *BASE*.edges) { ... }
}

我知道我不能使用base关键字，因为我不想在这里继承（为什么节点必须从图继承？！）并且嵌套类似乎也不能帮助我（无法访问“父级”字段）。

这段代码现在正在运行，但我觉得它不优雅，我想体验一个合适的解决方案。

Answer 1

将引用传递给Graph构造函数中的父类。

类似的东西：

class Graph
{
    private ParentType parent;

    public void Graph(ref ParentType parent)
    {
        this.parent = parent;
    }
}

然后，在GetNeighbours方法中（假设ParentType具有Edges集合属性）：

public List<Node> GetNeighbours()
{
    // ...
    foreach(var edge in parent.Edges) { ... }
}

Answer 2

从你想要做的事情的描述：

  

给定一个图表，我问一个节点：你有多少邻居？

您确定这应该是Node的方法吗？由于Graph包含Nodes和Edges，因此在Graph中这种方法可能会更好。

public List<Node> GetNeighbours(Node node)
{
    if(!nodes.Contains(node)
    {
        return new List<Node>(); //No neighbors. Return an empty list.
    }
    // Find and return the neighbors. This method is in Graph so it
    // has access to all of Graph's internals.
}

我的理由是，从某种意义上说，Graph是父级，而且包含Nodes，Node不需要了解Graph。它的目的（单一责任）是完整的，没有引用Graph。

Answer 3

我会在Graph.AddNodes()上使用Graph.AddEdges()或Graph这样的方法，这样就可以确保所有Nodes（和/或{{1} }}具有它需要的引用。我正在考虑这样的问题，具体取决于Edges和Node的模型。

Edge

Answer 4

这是另一种方法。您可以使每个边知道每端的节点，而不是传递父引用。并让每个节点都知道连接到它们的边缘。

这方面的一个巨大优势是您不需要枚举可能的大量节点/边缘来找到您需要的东西。你已经拥有了你需要的东西，所以速度要快得多。

以下是我描述的方法的快速示例以及一些测试：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GraphModelTest
{
    class Program
    {
        static void Main(string[] args)
        {
            TestA();
            TestB();
            TestC();
        }

        private static void TestC()
        {
            //A <-> B
            //|     |
            //D <-> C
            Node a = new Node("a");
            Node b = new Node("b");
            Node c = new Node("c");
            Node d = new Node("d");
            Edge ab = a.ConnectTo(b);
            Edge bc = b.ConnectTo(c);
            Edge cd = c.ConnectTo(d);
            Edge da = d.ConnectTo(a);
            Graph g = new Graph();
            g.Nodes.Add(a);
            g.Nodes.Add(b);
            g.Nodes.Add(c);
            g.Nodes.Add(d);
            g.Edges.Add(ab);
            g.Edges.Add(bc);
            g.Edges.Add(cd);
            g.Edges.Add(da);
            Console.WriteLine(g.ToString());

            Console.WriteLine("Neighbours of B");
            foreach (Node n in b.GetNeighbours())
            {
                Console.WriteLine(n.ToString());
            }
            Console.WriteLine("Neighbours of D");
            foreach (Node n in d.GetNeighbours())
            {
                Console.WriteLine(n.ToString());
            }
        }

        private static void TestB()
        {
            //A <-> B <-> C
            Node a = new Node("a");
            Node b = new Node("b");
            Edge ab = a.ConnectTo(b);
            Node c = new Node("c");
            Edge bc = b.ConnectTo(c);
            Graph g = new Graph();
            g.Nodes.Add(a);
            g.Nodes.Add(b);
            g.Nodes.Add(c);
            g.Edges.Add(ab);
            g.Edges.Add(bc);
            Console.WriteLine(g.ToString());

            Console.WriteLine("Neighbours of B");
            foreach (Node n in b.GetNeighbours())
            {
                Console.WriteLine(n.ToString());
            }
        }

        private static void TestA()
        {
            //A <-> B
            Node a = new Node("a");
            Node b = new Node("b");
            Edge ab = a.ConnectTo(b);
            Graph g = new Graph();
            g.Nodes.Add(a);
            g.Nodes.Add(b);
            g.Edges.Add(ab);
            Console.WriteLine(g.ToString());
        }
    }

    class Edge
    {
        public Edge(string name, Node a, Node b)
        {
            Name = name;
            A = a;
            B = b;
        }

        public Node A { get; private set; }
        public Node B { get; private set; }
        public string Name { get; private set; }

        public override string ToString() => $"{Name}";
    }

    class Node
    {
        public Node(string name)
        {
            Name = name;
            connectedEdges = new List<Edge>();
        }

        public string Name { get; private set; }

        private ICollection<Edge> connectedEdges;
        public IEnumerable<Edge> ConnectedEdges
        {
            get
            {
                return connectedEdges.AsEnumerable();
            }
        }

        public void AddConnectedEdge(Edge e)
        {
            connectedEdges.Add(e);
        }

        public Edge ConnectTo(Node n)
        {
            //Create the edge with references to nodes
            Edge e = new Edge($"{Name} <-> {n.Name}", this, n);
            //Add edge reference to this node
            AddConnectedEdge(e);
            //Add edge reference to the other node
            n.AddConnectedEdge(e);
            return e;
        }

        public IEnumerable<Node> GetNeighbours()
        {
            foreach (Edge e in ConnectedEdges)
            {
                //Have to figure which one is not this node
                Node node = e.A != this ? e.A : e.B;
                yield return node;
            }
        }

        public override string ToString() => $"{Name}";
    }

    class Graph
    {
        public Graph()
        {
            Nodes = new List<Node>();
            Edges = new List<Edge>();
        }

        public ICollection<Node> Nodes { get; set; }
        public ICollection<Edge> Edges { get; set; }

        public override string ToString()
        {
            StringBuilder str = new StringBuilder();

            str.AppendLine("Graph:");
            str.AppendLine("Nodes:");
            foreach (Node n in Nodes)
            {
                str.AppendLine(n.ToString());
            }
            str.AppendLine("Edges:");
            foreach (Edge e in Edges)
            {
                str.AppendLine(e.ToString());
            }

            return str.ToString();
        }
    }
}