Hierarchische Aktualisierung

Question

Ich habe eine Liste von Produkten (Klasse) im Speicher, jedes Produkt kann eine Liste von Unterprodukten haben (kann leer sein). Gibt es eine Möglichkeit, die Lagermenge (Eigenschaft) eines Produkts und alle Vorkommen zu aktualisieren?

So zum Beispiel, wenn ein Produkt verkauft, sondern erscheint auch als Teil eines Pakets auf ein anderes Produkt, dann werden beide Mengen von 1.

Answer 1

reduziert werden, wenn die Tiefe des Baumes nur 1 (Sub-Produkte kann nicht Teilprodukte) haben, können Sie die berühmte SelectMany die verwenden:

Projiziert jedes Element einer Sequenz in ein IEnumerable und flacht die resultierenden Sequenzen in einer einzigen Sequenz.

List<Product> products = new List<Product>(); 

var allProductsWithSubs = (from p in products.SelectMany(x => x.SubProducts).Concat(products) 
          group p by p.ProductID into grp 
          select new 
          { 
           ProductID = grp.Key, 
           Quantity = grp.Sum(x => x.Quantity) 
          }).ToList(); 

public class Product 
{ 
    public int ProductID { set; get; } 
    public double Quantity { set; get; } 
    public List<Product> SubProducts { set; get; } 
} 

Answer 2

Bundle Produkte könnten neu berechnen, um die Menge jedes Mal, wenn Menge eines Elements in das Bündel Änderungen enthalten. Das Update kann mithilfe von Ereignissen durchgeführt werden.

class Product 
{ 
    public int Quantity 
    { 
     get { return _quantity}; 
     set 
     { 
      if (_quantity != value) 
      { 
       _quantity = value; 
       OnQuantityChanged(); 
      } 
     } 
    } 

    protected virtual void OnQuantityChanged() 
    { 
     var handler = QuantityChanged; 
     if (handler != null) handler(this, EventArgs.Empty); 
    } 

    int _quantity; 

    public event EventHandler QuantityChanged; 
} 

class BundleProduct: Product 
{ 
    public class BundleItem 
    { 
     public BundleItem(Product product, int requiredQuantity) 
     { 
      this.Product = product; 
      this.RequiredQuantity = requiredQuantity; 
     } 
     public int Quanity 
     { 
      get {return Product.Quantity/RequiredQuantity; } 
     } 

     public readonly Product Product; 
     public readonly int RequiredQuantity; 
    } 

    public IReadOnlyList<BundleItem> Items 
    { 
     get {return _items; 
    } 

    public void AddItem(Product product, int requiredQuantity) 
    { 
     var item = new BundleItem(product, requiredQuantity); 
     _items.Add(item); 
     product.QuantityChanged += ItemQuantityChanged; 
     RecaclulateQuantity(); 
    } 


    void RecalculateQuantity() 
    { 

     if (_updating) return false; 

     _updating = true; 
     try 
     { 
      // The quantity of a bundle is derived from 
      // availability of items it contains 
      int available = 0; 

      if (_items.Count != 0) 
      { 
       available = _items[0].Quantity; 
       for(int i = 1; i < _items.Count; ++i) 
       { 
        available = Math.Min(available, _items[i].Quanity); 
       } 
      } 
      this.Quantity = available; 
     } 
     finally 
     { 
      _updating = false; 
     } 
    }   

    void ItemQuantityChanged(object sender, EventArgs e) 
    { 
     RecalculateQuantity(); 
    } 

    bool _updating; 
    List<Product> _items; 

}