C＃Linq分层列表属性集

Question

I have the following class:

public class Products
{
    public int ID { get; set; }
    public int KeyID { get; set; }    
    public int KeyLevel { get; set; }    
    public string COMBasis { get; set; }            
}

Here ID is the primary key and KeyID contains the parent ID of the item. KeyLevel contains the level of the node in the hierarchical tree. I have to set the COMBasis property for all the children if the parent's property is changed. How can I get the children?

Following is what I am already doing but I am stuck in the after KeyLevel part:

foreach (Products prod in ProductList.Where(x => x.KeyID == prd.ID))
{
    while(prod.KeyLevel!=6)
    prod.COMStandard = prd.COMStandard;    
}

Answer 1

So you just need to put that in a recursive function. Something like this:

void ApplyCOMBasis(List<Products> productList, int pId, string comStandard)
{
    foreach (Products prod in productList.Where(x => x.KeyID == pId))
    {
        prod.COMStandard = comStandard;
        ApplyCOMBasis(productList, prod, comStandard);
    }
}

Which you can then call like this (based on your current code):

ApplyCOMBasis(ProductList, prd.ID, prd.COMBasis);

Answer 2

In general case , if you have to work a lot with such a graph, I suggest implementing a BFS ( Breadth First Search ) algorithm:

public static IEnumerable<T> BreadthFirst<T>(this IEnumerable<T> source,
                                             Func<T, IEnumerable<T>> children) {
  if (Object.ReferenceEquals(null, source))
    throw new ArgumentNullException(nameof(source));
  else if (Object.ReferenceEquals(null, children))
    throw new ArgumentNullException(nameof(children));

  HashSet<T> proceeded = new HashSet<T>();

  Queue<IEnumerable<T>> queue = new Queue<IEnumerable<T>>();

  queue.Enqueue(source);

  while (queue.Count > 0) {
    IEnumerable<T> src = queue.Dequeue();

    if (Object.ReferenceEquals(null, src))
      continue;

    foreach (var item in src) 
      if (proceeded.Add(item)) {
        yield return item;

        queue.Enqueue(children(item));
      }
  }
}

Having BFS implemented, all you have to do is to specify initial nodes and a rule how to obtain children for a given node:

var products = ProductList 
  .Where(prd => prd.ID == ...) // initial nodes
  .BreadthFirst(parent => ProductList.Where(item => item.ID == parent.KeyID));

foreach (Products prod in products) {  
  ...
} 

Answer 3

Assumping you just have a flat List<Products> and you need to search it as a hierarchy, you'll need a recursive call.

void UpdateChildren(List<Products> list,  int keyId, string value)
{
   // find the items with this KeyID
   var children = list.Where(i => i.KeyId = keyId)
   foreach(var p in children)
   {
       p.COMBasis = value;
       UpdateChildren(list, p.ID, value);
   }
} 

So when you need to update the parent you start like this

var item = list.Single(x => x.ID = id); // assume you know the id of the parent
item.COMBasis = newCOMBasis;
UpdateChildren(item, item.ID, newCOMBasis);