Why I cannot inherit LinkedListNode<T>?

Question

In .NET 3.5, I am using the LinkedList class but I am having the following issue. I want the items of that list to be aware of the previous and next items in the list. In other words, I want the method in the items to be able to do this.Next, this.Previous. Is this possible? Below is an example of what I would like to do.

Day d1 = new Day();
Day d2 = new Day();
LinkedList<Day> days = new LinkedList<Day>();
days.AddLast(d1);
days.AddLast(d2);

// Here is want I would like to do
d1.Next = ...

Thanks!

Answer 1

According to the MSDN, the LinkedListNode class cannot be inherited.

Michael points out that this blog post from Eric Lippert talks about why many classes in the framework are sealed

Answer 2

Day d1 = new Day();
Day d2 = new Day();
LinkedList<Day> days = new LinkedList<Day>();
// Day's instance doesn't have Next. Its the LinkedListNode that should be used.
LinkedListNode<Day> d1Node = days.AddLast(d1); 
days.AddLast(d2);

Answer 3

First, LinkedListNode is sealed so it can not be inherited.

Secondly, LinkedListNode does contain properties Previous and Next that refer to the previous and next nodes in the LinkedList that a given instance of LinkedListNode came from.

Lastly, to use AddLast correctly, you must do the following:

Day d1 = new Day();
Day d2 = new Day();
LinkedList<Day> days = new LinkedList<Day>();
LinkedListNode<Day> node1 = days.AddLast(d1);
LinkedListNode<Day> node2 = days.AddLast(d2);

// now node1.Next refers to node containing d2
// and node2.Previous referes to node containing d1

Answer 4

You're using it wrong.

The .AddLast(T) method returns a linked list node. This points to your day and has the prev and next functions you are looking for.

Answer 5

LinkedListNode is a sealed class so it cannot be inherited. We get so spoiled by IEnumerable that we lose sight of the actual data structures we're using. It's still a linked list, so you can treat it like one:

LinkedListNode<Day> node = days.First();
while (node != null)
{
    Day day = node.Value;

    // do stuff here...

    node = node.Next();
}

Answer 6

Why not just use the nodes directly to begin with...

LinkedListNode<Day> d1 = new LinkedListNode<Day>(new Day());
LinkedListNode<Day> d2 = new LinkedListNode<Day>(new Day());
LinkedList<Day> days = new LinkedList<Day>();
days.AddLast(d1); 
days.AddLast(d2);

// Now you can read the node directly
d1.Next...

// If you need to place it somewhere other than at the end (like say you want d2 before d1,
// but d1 is already in the list) use 'AddBefore' and 'AddAfter' eg:
days.AddLast(d2);
days.AddBefore(d2, d1);

Answer 7

Eric Lippert explains why most framework classes are sealed in this blog post.

Answer 8

The only way I can think to make a generic T aware of its siblings is to implement your own data structure.

public interface ILinkedListNode
{
    ILinkedListNode Next { get; set; }
    ILinkedListNode Previous { get; set; }
}

public class LinkedList<T> where T : ILinkedListNode 
{
    /*.... methods here ...*/
}

public class Node : ILinkedListNode
{
    public Node Next { get; set; }

    public Node Previous { get; set; }

    ILinkedListNode ILinkedListNode.Next
    {
        get { return this.Next; }
        set { this.Next = (Node)value; }
    }

    ILinkedListNode ILinkedListNode.Previous
    {
        get { return this.Previous; }
        set { this.Previous = (Node)value; }
    }
}