Porównaj tablice lub inne metody

Question

Jestem całkiem nowy w C#. Szukałem prostej metody sprawdzenia, czy wszystkie wartości w tablicy, które są pomiędzy lub równe dolnym i górnym limitom, są różne dla każdego elementu w tablicy. Przeprowadzam również wiele ocen dla każdego zestawu danych. Jest to obecna metoda, której używam i działa to dobrze, ale szukam metody bardziej efektywnej. Wydaje się, że metoda pediatrii wydaje się być zgodna z tym, czego potrzebuję, ale nie jestem pewien, jak to osiągnąć.

Istnieje również kilka mniejszych pytań na końcu, które prowadzą od tego.

Używane przeze mnie tablice mają zwykle około 20 elementów, a nie 5, jak tutaj.

Nazwy kolumn zostały zmienione w celu ochrony niewinnych ...

int x; 
bool failed; 
double [] myArray = new double [5]; 

for(int a = 0;a<= Convert.ToInt32(temp.Compute("Max(Col1)",string.Empty));a++) 
{ 
    failed = false; 

    IEnumerable<DataRow>rows = temp.AsEnumerable() 
            .Where(r=>r.Field<int>("Col1") == a 
            && r.Field<int>("Col2") > 0 
            && r.Field<int>("Col2") < 2000 
            && r.Field<decimal>("Col3") > 0 
            && r.Field<decimal>("Col3") < 1000 
            ); 

    myArray[0] = rows.AsEnumerable().ToList().Count; 
    myArray[1] = rows.AsEnumerable().Sum(row => row.Field<int>("Col4")); 
    myArray[2] = rows.AsEnumerable().Average(row => row.Field<int>("Col4")); 
    myArray[3] = rows.AsEnumerable().Max(row => row.Field<int>("Col5")); 
    myArray[4] = rows.AsEnumerable().Min(row => row.Field<int>("Col5")); 

    //CHECK 1 //////////////////////////////////////// 
    double [] lowerLimit1 = {0,10,0,50000,2}; 
    double[] upperLimit1 = {6000,20,0.75,80000,2}; 
    for(int d = 0;d< myArray.Length;d++) 
    { 
     if(myArray[d] >= lowerLimit1[d] && myArray[d] <= upperLimit1[d]) 
     { 
      x++; 
     }; 
    }; 
    if(x > myArray.Length) 
    { 
     failed = true; 
     dt = rows.CopyToDataTable<DataRow>(); 
    }; 
    //CHECK 2 //////////////////////////////////////// 
    if(! failed) 
    { 
     x = 0; 
     double [] lowerLimit2 = {6000,50,0,30000,2}; 
     double[] upperLimit2 = {6000,10,0.75,50000,2}; 
     for(int d = 0;d< myArray.Length;d++) 
     { 
      if(myArray[d] >= lowerLimit2[d] && myArray[d] <= upperLimit2[d]) 
      { 
       x++; 
      }; 
     }; 
     if(x > myArray.Length) 
     { 
      failed = true; 
      dt = rows.CopyToDataTable<DataRow>(); 
     }; 
    }; 
    //CHECK 3 //////////////////////////////////////// 
    if(! failed) 
    { 
     x = 0; 
     double [] lowerLimit3 = {4000,15,0,50000,2}; 
     double[] upperLimit3 = {5000,20,0.75,80000}; 
     for(int d = 0;d< myArray.Length;d++) 
     { 
      if(myArray[d] >= lowerLimit3[d] && myArray[d] <= upperLimit3[d]) 
      { 
       x++; 
      }; 
     }; 
     if(x > myArray.Length) 
     { 
      failed = true; 
      dt = rows.CopyToDataTable<DataRow>(); 
     }; 
    }; 

}; //END LOOP 
if(failed) 
{ 
    // Do stuff and things 
}; 

jest również istnieje metoda, aby wykonać następujące czynności bez odtworzenie obiektu DataRow? Daje to błąd o nieoczekiwanym symbolu "Gdzie".

myArray[4] = rows.AsEnumerable().Min(row => row.Field<int>("Col1") Where row.Field<int>("Col3") == 10); 

Próbuję osiągnąć następujące, ale za pomocą tabeli danych jest wolniejszy, dlatego używam powyższej metody.

myArray[4] = Convert.ToInt32(temp.Compute("Min(Col1)","Col3 = 10")); 

I wreszcie, czy istnieje sposób, aby zaludnić tablicę bez pętli, starałem array.Dispose() i tablica = null ale one nie działają. np.

double [] lowerLimit = {4000,15,0,50000,2}; 
double[] upperLimit = {5000,20,0.75,80000}; 

// Ponownie wypełnij tablicę, która oczywiście nie działa.

lowerLimit = {6000,50,0,30000,2}; 
upperLimit = {7000,60,0.75,50000,2}; 

która jest znacznie porządniej od dołu lub z wykorzystaniem wielu tablic jak w powyższym kodzie, a stosowane są zwykle 20+ elementów w tej tablicy.

lowerLimit[0] = 6000, upperLimit[0] = 7000; 
lowerLimit[1] = 50, upperLimit[1] = 60; 
lowerLimit[2] = 0, upperLimit[2] = 0.75; 
lowerLimit[3] = 30000, upperLimit[3] = 50000; 
lowerLimit[4] = 2, upperLimit[4] = 2; 

Answer 1

Kontrola wartości może być przeprowadzone przez zastosowanie kombinacji All i funkcji, a funkcja Enumerable.Range.

Spowoduje to powrót do wartości true, jeśli wszystkie wartości znajdują się w zakresie, oraz do skrótu z wartością false, gdy jeden znajdzie się poza zasięgiem.

Jeśli często go używasz, utwórz funkcję pomocniczą.

public static class MyHelperClass { 

    public static bool Between(this double value, double min, double max) { 
     return min <= value && value <= max; 
    } 
} 

Następnie można zrobić

Enumerable.Range(0,myArray.Length) 
      .All(x => myArray[x].Between(lowerLimit[x], upperLimit[x]); 

zamiennikiem:

rows.AsEnumerable().Min(row => row.Field<int>("Col1") Where row.Field<int>("Col3") == 10); 

umieścić where przed min

rows.AsEnumerable().Where(row => row.Field<int>("Col3") == 10) 
        .Min(row => row.Field<int>("Col1")); 

Wystarczy przypisać nową tablicę,

lowerLimit = new double[] {6000,50,0,30000,2}; 
upperLimit = new double[] {7000,60,0.75,50000,2}; 

W niektórych przypadkach może być skrócony do zaledwie new[] zamiast new double[] ale tylko wtedy, gdy kompilator jest absolutnie pozytywny co Cię oznaczać.