Relation parent-enfant récursive C#

Question

J'essaie de construire la hiérarchie à partir du fichier .csv, il se compose d'ID (emplacement fonctionnel), Description & Parent Id (SupFunctLoc) qui sont tous dans la chaîne. J'ai récupéré les données dans la liste. Code & Échantillon de données pour référence.

Functional Loc. Description SupFunctLoc. 
70003 ABC AS002 
70C2 ABC 70003 
70C2.01 ABC 70C2 
70C2.01.02 ABC 70C2.01 
70C2.01.02.10 ABC 70C2.01.02 
70C2.01.02.10-BG010 ABC 70C2.01.02.10 

Exemple de code:

static void Main(string[] args) 
    { 
     List<Input> inputList = new List<Input>(); 
     var yourData = File.ReadAllLines(locate) 
       .Skip(1) 
       .Select(x => x.Split(',')) 
       .Select(x => new Input() 
       { 
        FunctionalLocation = x[0], 
        Description = x[1], 
        SuppFunctionalLocation = x[2], 

       }); 
     //try 3 

     //try 2 

     var outputList = yourData 
      .Where(i => i.SuppFunctionalLocation!= null) // Just get the parents 
      .Select(i => new Input() 
      { 
       Description = i.Description, 
       SuppFunctionalLocation = i.SuppFunctionalLocation, 
       Children = inputList 
        .Where(x => x.FunctionalLocation.ToString() == i.SuppFunctionalLocation.ToString()) 
        .Select(x => new Input() 
        { 
         Description = x.Description, 
         SuppFunctionalLocation = x.SuppFunctionalLocation, 
         FunctionalLocation = x.FunctionalLocation, 
        }).ToList() 
       }).ToList(); 


     foreach (var output in outputList) 
     { 
      Console.WriteLine(output.Description); 
      output.Children.ForEach(c => Console.WriteLine($"\t {c.Description}")); 
     } 
} 

Classe Defination pour l'entrée

class Input 
    { 
     public string FunctionalLocation { get; set; } 
     public string Description { get; set; } 
     public string SuppFunctionalLocation { get; set; } 
     public List<Input> Children { get; set; } 
    } 

S'il vous plaît aider à ce qui peut être fait dans ce cas. Votre aide est appréciée.

Answer 1

Essayez ceci:

var source = @"Functional Loc. Description SupFunctLoc. 
70003 ABC AS002 
70C2 ABC 70003 
70C2.01 ABC 70C2 
70C2.01.02 ABC 70C2.01 
70C2.01.02.10 ABC 70C2.01.02 
70C2.01.02.10-BG010 ABC 70C2.01.02.10"; 

var lines = 
    source 
     .Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries) 
     .Select(x => x.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); 

var results = 
    lines 
     .Skip(1) 
     .Select(x => new Input() 
     { 
      FunctionalLocation = x[0], 
      Description = x[1], 
      SuppFunctionalLocation = x[2], 
     }); 

var lookup = results.ToLookup(x => x.SuppFunctionalLocation); 

Func<string, List<Input>> build = null; 
build = SuppFunctionalLocation => 
    lookup[SuppFunctionalLocation] 
     .Select(x => new Input() 
     { 
      FunctionalLocation = x.FunctionalLocation, 
      Description = x.Description, 
      SuppFunctionalLocation = x.SuppFunctionalLocation, 
      Children = build(x.FunctionalLocation), 
     }) 
     .ToList(); 

List<Input> tree = build("AS002"); 

Answer 2

La construction d'une hiérarchie à partir d'éléments avec une clé parent existante est relativement facile. Je l'ai extrait un peu de votre échantillon, mais c'est fondamentalement le même.

Les éléments à mettre en hiérarchie

public class MyItem 
{ 
    public string Id { get; set; } 
    public string Description { get; set; } 
    public string ParentId { get; set; } 
    // to be filled 
    public IList<MyItem> Children { get; set; } 
} 

Le code pour construire les listes d'enfants.

// assumption: MyItem elements have all properties set except the children collection 
ICollection<MyItem> items = GetMyItems(); 

var parentRelation = items.ToLookup(x => x.ParentId); 
foreach (var item in items) 
{ 
    item.Children = parentRelation[item.Id].ToList(); 
} 

Answer 3

Une fois que vous avez lu tous les articles dans la collection construire la relation parent avec

foreach (var parent in inputlist) 
{ 
    parent.Children = inputlist 
     .Where(child => child.SuppFunctionalLocation == parent.FunctionalLocation) 
     .ToList(); 
} 

Pour obtenir uniquement les éléments racine que vous devez chercher tous articles qui n'ont pas de parent

var outputlist = inputlist 
    .Where(child => !inputlist.Any(parent => parent.FunctionalLocation == child.SuppFunctionalLocation)) 
    .ToList();