Reverse FIFO Menge Element?

Question

nach meinem ersten Beitrag bereits gelöst First in first out subtract quantity stock?

i eine Datenbank Detail Namen Item_detail

No(autoincrement)  Id_Item qtyLimit  qtyReal  
------------------------------------------------------- 
     1     1   30   0 
     2     1   40   0 
     3     2   50   0 
     4     2   60   10 

so für Punkt 1 Summe habe alle Menge Echt für Punkt 1 0 ist, und Menge Grenze Grenze Menge für jeden Daten im Detail Artikel

wenn ich Daten aus DataGridView1 von in_transaction

Id_Item qtyIn 
    --------------- 
     1   50   
     2   80 

haben 10

wie Menge von meiner Transaktion in meine update Item_detail hinzufügen, aber von unten nach oben das Ergebnis umkehren Ich mag dieses

No(autoincrement)  Id_Item  qtyLimit  qtyReal 
------------------------------------------------------- 
     1     1    30   10    
     2     1    40   40   
     3     2    50   30   
     4     2    60   60   

so seine Kontrolle Grenze id no 1, wenn Menge limit = Menge real bewegen wollen von unten mit dem gleichen überprüfen wieder keine ID dann mit Qty Grenze

nach, dass ich möchte, um diesen oberen Transaktionsprozess in Tisch Item_transaction

NoTrans(autoincrement) no(from item_detail)  qtyIn 
--------------------------------------------------------- 
     1      1     10 
     2      2     40 
     3      3     30 
     4      4     50 

trycode

private void calculate() 
{ 
// Transaction: Id_Item, qtyIn 
IEnumerable<in_transaction> contextItemIn = null; 
// ItemDetail: No, Id_Item, qtyLimit, qtyReal 
IEnumerable<ItemDetail> contextItemDetails = null; 

Dictionary<int, decimal> itemInQuantities = contextItemIn.ToDictionary(x => x.Id_Item, x => x.qtyIn); 

var itemDetails = contextItemDetails.OrderBy(x => x.No).ToList(); 

foreach (var item in itemDetails.AsEnumerable().Reverse()) 
{ 
    decimal inQty; 
    if (itemInQuantities.TryGetValue(item.Id_Item, out inQty)) 
    { 
     var qtyChange = inQty 
     item.qtyReal += qtyChange; 
     inQty -= qtyChange; 
     if (inQty == item.QtyLimit) 
     { 

      itemInQuantities.Remove(item.Id_Item); 
     } 
     else 
     { 
      itemInQuantities[item.Id_Item] = inQty; 
     } 
     if (qtyChange != 0) 
     { 
      transactions.Add(new ItemTransaction { /*No = autoincrement, */ 
      NoTrans = item.No, qtyIn = qtyChange }); 
     } 
    } 
} 

// itemDetails qty values are corrected 

}

so wenden Sie sich bitte

Answer 1

Was helfen, wie ich diese Arbeit zu machen, wird nur ein paar kleinere Änderungen notwendig sehen.

Also lassen Sie zunächst den Begriff Item_detail.capacity als qtyLimit - qtyReal. Die maximale Änderung für ein einzelnes Elementdetail wird durch seine capacity begrenzt, während die gewünschte Änderung von in_transaction.qtyIn gegeben wird. So können Sie Ihre Mengenänderung für ein einzelnes Element berechnen als

var qtyChange = Math.Min(inQty, item.qtyLimit - item.qtyReal); 

Ein Eintrag von in_transaction abgeschlossen ist, wenn die verbleibenden inQty0 ist, so die Bedingungen ändern,

//if (inQty == item.QtyLimit) // <- wrong 
if (inQty == 0) 
    // ... remove 

Ein kleiner Seitenwechsel zu Vereinfachen Sie den Code: Anstatt die Elemente später umzukehren, fangen Sie an, sie richtig zu sortieren.

var itemDetails = contextItemDetails.OrderByDescending(x => x.No).ToList(); 
foreach (var item in itemDetails)