Dynamische Variablen an Datentabelle binden und rekursiv verarbeiten

Question

Ich verarbeite einige Zeilen von Excel und abzufragen sie und speichern in einigen Variablen (12 var s) wie unten. dtremoverows enthält die Daten von Excel.

private System.Data.DataTable RemoveRows(System.Data.DataTable dtremoverows, bool mage) 
{ 
     System.Data.DataTable dtreturnrows = new System.Data.DataTable(); 
     int rowcount = dtremoverows.Rows.Count; 
     var RemoveRows1 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString() == "" && r["EMP_NO/Emp_Name"].ToString() == "").ToList(); 
     var RemoveRows2 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString() == "" && r["QTY"].ToString() == "").ToList(); 
     var RemoveRows3 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString().Contains("Total in Group:") || r["QTY"].ToString().Contains("Total in Group:") || r["EMP_NO/Emp_Name"].ToString().Contains("Total in Group:") || r["WO_NO"].ToString().Contains("Total in Group:") || r["ROLE_CODE"].ToString().Contains("Total in Group:") || r["CATALOG_NO"].ToString().Contains("Total in Group:")).ToList(); 
     var RemoveRows4 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString().Contains("Print Date/Time") || r["QTY"].ToString().Contains("Print Date/Time") || r["EMP_NO/Emp_Name"].ToString().Contains("Print Date/Time") || r["WO_NO"].ToString().Contains("Print Date/Time") || r["ROLE_CODE"].ToString().Contains("Print Date/Time") || r["CATALOG_NO"].ToString().Contains("Print Date/Time")).ToList(); 
     var RemoveRows5 = dtremoverows.AsEnumerable().Where(r => r["EMP_NO/Emp_Name"].ToString() == "" && r["QTY"].ToString() == "").ToList(); 
     var RemoveRows6 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString() == "0" || r["EMP_NO/Emp_Name"].ToString() == "0" || r["CATALOG_NO"].ToString() == "0").ToList(); 
     var RemoveRows7 = dtremoverows.AsEnumerable().Where(r => r["CATALOG_NO"].ToString().Contains("Total Amount") || r["QTY"].ToString().Contains("Total Resource Count")).ToList(); 
     var RemoveRows8 = dtremoverows.AsEnumerable().Where(r => r["WO_NO"].ToString() == "" || r["QTY"].ToString() == "" || r["QTY"].ToString() == "0").ToList(); 
     var RemoveRows9 = dtremoverows.AsEnumerable().Where(r => r["EMP_NO/Emp_Name"].ToString() == "<None>" && (r["QTY"].ToString() == "" || r["CATALOG_NO"].ToString() == "")).ToList(); 
     var RemoveRows10 = dtremoverows.AsEnumerable().Where(r => r["WO_NO"].ToString() == "Work Ord" && r["EMP_NO/Emp_Name"].ToString() == "Employee #/Sales Part #").ToList(); 
     var RemoveRows11 = dtremoverows.AsEnumerable().Where(r => r["QTY"].ToString() == "0" || r["QTY"].ToString() == "").ToList(); 
     var RemoveRows12 = dtremoverows.AsEnumerable().Where(r => r["CRE_DATE"].ToString() == "" && r["WO_NO"].ToString() == "" && r["EMP_NO/Emp_Name"].ToString() == "" && r["ROLE_CODE"].ToString() == "" && r["CATALOG_NO"].ToString() == "" && r["QTY"].ToString() == "" && r["PLAN_LINE_NO"].ToString() == "" && r["WORK_ORDER_COST_TYPE"].ToString() == "" && r["WORK_ORDER_ACCOUNT_TYPE"].ToString() == "" && r["ORG_CODE"].ToString() == "" && r["CMNT"].ToString() == "").ToList(); 
} 

Dann füge ich jede der Variablen als Schleife. Kann ich das als eine einzelne rekursive Schleife verwenden, weil ich denke, dass meine Codierung (unten) veraltet ist.

try 
     { 

      if (RemoveRows1.Count() != 0) 
      { 
       foreach (var row in RemoveRows1) 
       { 
        dtremoverows.Rows.Remove(row); 

       } 
      } 
     } 
     catch { } 

     try 
     { 
      if (RemoveRows2.Count() != 0) 
      { 
       foreach (var row in RemoveRows2) 
       { 
        dtremoverows.Rows.Remove(row); 
       } 
      } 
     } 
     catch { } 

......... Und so weiter .. bis RemoveRows12 und dann verschmelzen wie:

dtreturnrows.Merge(dtremoverows); 

Dies funktioniert, aber ich brauche von besserem Ansatz wirklich dieser Kodierung. Wenn Sie irgendwelche Vorschläge haben, antworten Sie bitte.

Answer 1

Schauen Sie sich das Snippet für die Bedingungen RemoveRows1, RemoveRows2 usw. genau an, um viele Variablen zu verwenden. Warum nicht die Bedingungen zusammenführen? Ich glaube, Sie haben so etwas versuchen:

var rowsToRemove = dtremoverows.AsEnumerable() 
           .Where(r => 
           (/* Condition for RemoveRows1 */) || 
           (/* Condition for RemoveRows2 */) || 
           (/* Condition for RemoveRows3 */) || 
           (/* Condition for RemoveRows4 */)); 
// And so on you can add conditions so that you will get a collection 
// of all rows that should be deleted from the table 
// then iterate through those rows and perform delete like this: 

foreach (var row in rowsToRemove) 
{ 
    dtremoverows.Rows.Remove(row); 
} 

Bitte beachten Sie: Dies ist nur ein Vorschlag keine genaue Antwort auf die Frage, aber es ist mehr als ein Kommentar und deshalb als Antwort veröffentlichen. Vergib mir, wenn es gegen die Regeln verstößt.

Wir freuen uns, Ihnen zu helfen.

Answer 2

Die Daumenrolle ist, dass Sie Rekursionen nicht verwenden sollten, weil sie nicht lesbar und nicht leicht zu verstehen sind und eine Stapelüberlauf-Ausnahme verursachen könnten, wenn sie tief in die Rekursionsschleife gerät.

Wenn Sie können Sie einfache Schleifen verwenden, um Ihre Iterationen durchzuführen.