Comment convertir un objet récursif en Collection en C#?

Question

J'ai un objet récursif, une liste chaînée vraiment:

public class LinkedList 
{ 
    public string UniqueKey { get; set; } 
    public LinkedList LinkedList { get; set; } 
} 

LinkedList aura un graphe d'objet qui finira par se terminer par LinkedList.LinkedList == null.

Je voudrais prendre tous les objets dans le graphique et les mettre dans une collection LinkedList afin que je puisse itérer sur eux. Comment est-ce que je fais cela en C#? Je me sens comme si il y a une façon très simple de faire cela en utilisant le rendement ou Linq vaudou?

Answer 1

Quelque chose comme ça devrait fonctionner. Si vous avez le contrôle sur la classe, vous pouvez le faire directement à IEnumerable.

public class LinkedListEnumerable : IEnumerable<string> 
{ 
    LinkedList list; 
    public LinkedListEnumerable(LinkedList l) 
    { 
     this.list = l; 
    } 

    public IEnumerator<string> GetEnumerator() 
    { 
     LinkedList l = list; 
     while(l != null) 
     { 
      yield return l.UniqueKey; 
      l = l.Next; 
     } 
    } 
} 

Ensuite, vous pouvez parcourir plus de LinkedListEnumerable avec une boucle for-each.

Answer 2

Est-ce ce que vous cherchez?

public class LinkedList 
{ 
    public string UniqueKey { get; set; } 
    public LinkedList LinkedList { get; set; } 

    public IEnumerable<LinkedList> GetAllNodes() 
    { 
     if (LinkedList != null) 
     { 
      yield return LinkedList; 
      foreach (var node in LinkedList.GetAllNodes()) 
       yield return node; 
     } 
    } 
} 

Answer 3

Il n'y a pas de méthodes de LINQ belles dans la bibliothèque .NET standard pour permettre une élégante voodoo LINQ, mais vous pouvez utiliser Generate méthode de MoreLINQ projet et écrire ceci:

Enumerable 
    .Generate(list, l => l.LinkedList) 
    .TakeWhile(l => l != null).Select(l => l.UniqueKey); 

Il utilise Generate à créer une liste "infinie" de tous les éléments - elle n'est pas réellement infinie, car elle est générée paresseusement et nous arrêtons de l'utiliser dès que nous trouvons la valeur null à la fin (en utilisant TakeWhile). Ensuite, nous utilisons Select pour renvoyer une séquence de valeurs (au lieu de nœuds de liste liés).

Il s'agit essentiellement d'un bon moyen déclaratif d'exprimer la solution de boucle while affichée par Matthew (et il devrait avoir des performances à peu près similaires).

EDIT La méthode Generate ressemble à ceci:

IEnumerable<T> Generate(T current, Func<T, T> generator) { 
    while(true) { 
    yield return current; 
    current = generator(current); 
    } 
}