¿Por qué no puedo heredar LinkedListNode <T>?

Question

En .NET 3.5, estoy usando la clase LinkedList pero estoy teniendo el siguiente problema. Quiero que los elementos de esa lista conozcan los elementos anteriores y siguientes de la lista. En otras palabras, quiero que el método en los elementos sea capaz de hacer esto. Luego, esto.Anterior. es posible? A continuación se muestra un ejemplo de lo que me gustaría hacer.

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 = ... 

¡Gracias!

Answer 1

De acuerdo con MSDN, la clase LinkedListNode no se puede heredar.

Michael señala que los this blog post from Eric Lippert habla de por qué muchas clases en el marco se sellan

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

En primer lugar, es LinkedListNodesealed por lo que no se puede heredar.

En segundo lugar, LinkedListNode contiene propiedades Previous y Next que se refieren a los nodos anteriores y siguientes en la LinkedList que una instancia dada de LinkedListNode vino de.

Por último, utilizar AddLast correctamente, debe hacer lo siguiente:

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

se está usando mal.

El método .AddLast(T) devuelve un nodo de lista vinculada. Esto apunta a su día y tiene las funciones previas y siguientes que está buscando.

Answer 5

LinkedListNode es una clase sellada por lo que no se puede heredar. IEnumerable nos arruina tanto que perdemos de vista las estructuras de datos reales que estamos utilizando. Es todavía una lista enlazada, por lo que se puede tratar como una:

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

    // do stuff here... 

    node = node.Next(); 
} 

Answer 6

Por qué no utilizar los nodos directamente, para empezar ...

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

La única manera que puedo pensar para hacer una genérico T consciente de sus hermanos es implementar su propia estructura de datos.

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; } 
    } 
}