Dlaczego nie mogę odziedziczyć obiektu LinkedListNode <T>?

Question

W .NET 3.5 używam klasy LinkedList, ale mam następujący problem. Chcę, aby elementy tej listy były znane z poprzednich i następnych pozycji na liście. Innymi słowy, chcę, aby metoda w elementach była w stanie to zrobić. Dalej, to.Poprzednia. czy to możliwe? Poniżej znajduje się przykład tego, co chciałbym zrobić.

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

Dzięki!

Answer 1

Zgodnie z MSDN, klasa LinkedListNode nie może być dziedziczona.

Michael Zwraca uwagę, że this blog post from Eric Lippert rozmów o tym, dlaczego wielu klas w ramach są uszczelnione

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

Najpierw LinkedListNode jest sealed więc nie może być dziedziczona.

drugie LinkedListNode nie zawiera właściwości Previous i Next, które odnoszą się do poprzednich i następnych węzłów LinkedList że dany przypadek LinkedListNode pochodzi.

Wreszcie używać AddLast poprawnie, należy wykonać następujące czynności:

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

Używasz to źle.

Metoda .AddLast(T) zwraca połączony węzeł listy. To wskazuje na Twój dzień i ma funkcje poprzedzające i następne, których szukasz.

Answer 5

LinkedListNode jest klasą zamkniętą, więc nie może zostać odziedziczona. Jesteśmy tak rozpieszczani przez IEnumerable, że tracimy z oczu faktyczne struktury danych, których używamy. To wciąż powiązana lista, więc można traktować go jak jednego:

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

    // do stuff here... 

    node = node.Next(); 
} 

Answer 6

Dlaczego nie wystarczy użyć węzły bezpośrednio zacząć ...

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

jedyny sposób, myślę zrobić generic T świadomy swojego rodzeństwa jest zaimplementowanie własnej struktury danych.

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