LinkedList与lt；T>；和LinkedListNode<；T>；在C#中实现？

首先，让我们定义一个节点：

LinkedListNode<int> node = new LinkedListNode<int>(43);

此时，属性

节点.List

将发生更改，以包含对

链接列表的引用。类似地，如果将其他节点添加到
链接列表
，则将更新
下一个
和
上一个
属性，以反映链接列表的结构，即使这些属性不公开公共
集
访问器

这种行为是如何实现的

我知道如何使用
内部
，但有更好的方法吗？例如，假设我有一个包含许多类型的程序集，而不仅仅是
LinkedList
和
LinkedListNode
。通过为节点属性
列表
、
上一个
和
下一个
创建设置器，我将这些设置器公开给整个程序集，这是不需要的

这种行为是如何实现的

不看源代码，我猜这些属性的setter或backing字段被标记为
internal
，因此可以从
LinkedList
访问，因为它们都位于同一个程序集中

但是有更好的办法吗

不是真的。让我详细说明一下。还有其他选择

您可以使
LinkedListNode
成为
LinkedList
中定义的内部类。这是一个选择，但对打电话的人来说是个负担

您可以将
LinkedList
和
LinkedListNode
切割到它们自己的程序集中。这显然是用户的负担，可能很快会导致维护失败

我认为这两个都不是更好的解决方案

这种行为是如何实现的

不看源代码，我猜这些属性的setter或backing字段被标记为
internal
，因此可以从
LinkedList
访问，因为它们都位于同一个程序集中

但是有更好的办法吗

不是真的。让我详细说明一下。还有其他选择

您可以使
LinkedListNode
成为
LinkedList
中定义的内部类。这是一个选择，但对打电话的人来说是个负担

您可以将
LinkedList
和
LinkedListNode
切割到它们自己的程序集中。这显然是用户的负担，可能很快会导致维护失败

我认为这两种方法都不是更好的解决方案。
我通过ILSpy检查过，只读属性由
内部
字段支持

internal LinkedListNode<T> next;

public LinkedListNode<T> Next {
    get {
        if (this.next != null && this.next != this.list.head) {
            return this.next;
        }
        return null;
    }
}

下一步是内部LinkedListNode；
公共LinkedListNode下一步{
得到{
if（this.next！=null&&this.next！=this.list.head）{
把这个还给我，下一个；
}
返回null；
}
}

至于如何做得不同，以及讨论您是否想要查看及其答案。
我与ILSpy进行了检查，只读属性由
内部
字段支持

internal LinkedListNode<T> next;

public LinkedListNode<T> Next {
    get {
        if (this.next != null && this.next != this.list.head) {
            return this.next;
        }
        return null;
    }
}

下一步是内部LinkedListNode；
公共LinkedListNode下一步{
得到{
if（this.next！=null&&this.next！=this.list.head）{
把这个还给我，下一个；
}
返回null；
}
}

至于如何做的不同，以及讨论你是否想看，以及它的答案。
杰森是正确的。我查看了源代码，
LinkedListNode
有内部支持字段

一种方法是使用嵌套类。我不知道这是否是一种“更好”的方式，但它确实避免了内部设置器/字段。我省略了一些实现，因此您可以看到结构的概要：

public class Node<T>
{
  private List list;
  private Node<T> prev, next;

  public List List { get { return list; } }
  // other accessors.

  public abstract class List
  {
    Node<T> head;

    internal List() { }

    public AddFirst(Node<T> node)
    {
        // node adding logic.
        node.list = this;       
    }

    // implementation elided for brevity
  }

}

public class MyLinkedList<T> : Node<T>.List { }

公共类节点
{
私人名单；
私有节点prev，next；
公共列表{get{return List；}}
//其他访问者。
公共抽象类列表
{
节点头；
内部列表（）{}
公共AddFirst（节点）
{
//节点添加逻辑。
node.list=this；
}
//为简洁起见省略了实现
}
}
公共类MyLinkedList:Node.List{}

现在，您可以声明一个
MyLinkedList
并向其中添加节点，但是
节点上没有内部访问器
Jason是正确的。我查看了源代码，
LinkedListNode
有内部支持字段

一种方法是使用嵌套类。我不知道这是否是一种“更好”的方式，但它确实避免了内部设置器/字段。我省略了一些实现，因此您可以看到结构的概要：

public class Node<T>
{
  private List list;
  private Node<T> prev, next;

  public List List { get { return list; } }
  // other accessors.

  public abstract class List
  {
    Node<T> head;

    internal List() { }

    public AddFirst(Node<T> node)
    {
        // node adding logic.
        node.list = this;       
    }

    // implementation elided for brevity
  }

}

public class MyLinkedList<T> : Node<T>.List { }

公共类节点
{
私人名单；
私有节点prev，next；
公共列表{get{return List；}}
//其他访问者。
公共抽象类列表
{
节点头；
内部列表（）{}
公共AddFirst（节点）
{
//节点添加逻辑。
node.list=this；
}
//为简洁起见省略了实现
}
}
公共类MyLinkedList:Node.List{}

现在，您可以声明一个
MyLinkedList
并向其中添加节点，但是
Node
上没有内部访问器，一些实现使Node类成为链接列表的内部类；这是解决问题的另一种方法。嗯，这会增加其他问题。我不认为这是一种更好的方式。通常，链表中的节点是用户根本不需要知道的实现细节，这通常是此类实现的设计方式。我个人认为这样更好。节点没有任何理由是公共的。@Servy:哦，你的意思是作为
private
内部类。是的，这一点我完全同意，我一直很困惑，
LinkedListNote
是
public
。我的答案是在
LinkedListNode
公开的情况下，因为问题是关于
LinkedListNode
的属性是如何使用的机制