Récursive get ID

Question

haloa!

i ont un List<Channel> où Channel est une classe personnalisée biensur:

public class Channel 
{ 
    public long ID { get; set; } 
    public long parentID { get; set; } 
} 

strcuture peut être quelque chose comme:

ID = 1, parentID = 0 
    ID = 64, parentID = 1 
     ID = 28, parentID = 64 
     ID = 36, parentID = 64 
ID = 5, parentID = 0 

et ainsi de suite.

ce que je voudrais faire est d'obtenir tous les enfants ID de d'un canal spécifique:

function List<long> getChildrenIDS (long ID) 
{ 
    // WHAT GOES HERE? 
} 

Answer 1

Pour tous les enfants:

public IEnumerable<long> GetChildren(List<Channel> list, long id) 
{ 
    foreach(Channel c in list) 
    if(c.parentID == id) 
     yield return c.ID; 
} 

construire ce que le retour d'un IEnumerable<long> plutôt que de retourner un code qu'appeler alors List<long> qui a besoin d'un List<long> peut utiliser new List<long>(GetChildren(list, id)) ou GetChildren(list, id).ToList(), tout en appelant le code qui n'a pas besoin cela peut obtenir de meilleures performances en mémoire et en temps de premier résultat en ne construisant pas une liste dont il n'a pas réellement besoin, comme dans foreach(long childID in GetChildren(list, id)).

Pour obtenir tous les descendants (enfants, petits-enfants, arrière-petits-enfants, etc.), qui est le seul cas que nous pourrions faire usage de récursion (selon le titre de votre question) utilisez:

En supposant qu'il ne peut y avoir des doublons (même petits-enfants à travers de multiples routes):

private IEnumerable<long> GetDescendants(List<Channel> list, long id) 
{ 
    foreach(long child in GetChildren(list, id)) 
    { 
    yield return child; 
    foreach(long grandchild in GetDescendants(list, child)) 
     yield return grandchild; 
    } 
} 

S'il peut y avoir des doublons vous pourriez alors appliquer .Distinct() à ce qui précède, ou rendez-vous pour:

private IEnumerable<long> GetDescHelper(List<Channel> list, long id, HashSet<long> already) 
{ 
    foreach(long child in GetChildren(list, id)) 
    if(already.Add(child)) 
    { 
     yield return child; 
     foreach(long desc in GetDescHelper(list, child, already)) 
     yield return desc; 
    } 
} 
public IEnumerable<long> GetDescendants(List<Channel> list, long id) 
{ 
    return GetDescHelper(list, id, new HashSet<long>()); 
} 

Cela dit, je préférerais probablement modéliser cela en faisant en sorte que les classes de canaux maintiennent un List<Channel> d'enfants.

Answer 2

Ayant

List<Channel> list = new List<Channel>(); 
List<long> ret = new List<long>(); 

dans votre classe, vous pouvez faire:

Pas de récursion (donc seulement des enfants)

private List<long> GetChildrenIds(long parentId) 
{ 
    list.ForEach(p => { if (p.parentID == parentId) ret.Add(p.ID); }); 
    return ret; 
} 

ou avec récursion (enfants des enfants aussi)

private List<long> GetChildrenIds(long parentId) 
{ 
    list.ForEach(p => { if (p.parentID == parentId) { 
          ret.Add(p.ID); 
          GetChildrenIds(p.ID); 
         } 
         }); 
    return ret; 
} 

Answer 3

Je ne sais pas si la réponse Marcos produit vraiment le résultat souhaité, mais j'écrire cela dans un plus mode LINQish:

private IEnumerable<long> GetChildrenIds(IEnumerable<Channel> channels, long parentId) 
{ 
    if(channels == null) 
     throw new ArgumentNullException("channels"); 

    var childs = channels.Where(c => c.ParentId == parentId) 
         .Select(c => c.Id); 

    return childs; 
} 

Si vous également besoin des profonds imbriqués vous pourriez peut-être utiliser cette fonction:

private IEnumerable<long> GetAllChildrenIds(IEnumerable<Channel> channels, long parentId) 
{ 
    var childs = GetChildrenIds(channels, parentId); 
    var alldescendants = childs.SelectMany(id => GetAllChildrenIds(channels, id)); 

    return childs.Concat(alldescendants); 
} 

Mais sachez qu'il ne vérifie pas la redondance cyclique et pourrait se retrouver dans une exception StackOverflow!