सरणी या अन्य विधियों की तुलना करें

Question

मैं सी # के लिए बिल्कुल नया हूं। मैं यह जांचने के लिए एक सरल विधि की तलाश कर रहा हूं कि किसी सरणी में सभी मान जो निम्न और ऊपरी सीमाओं के बीच या उसके बराबर हैं, ये सरणी में प्रत्येक तत्व के लिए अलग हैं। मैं प्रत्येक डेटासेट पर कई मूल्यांकन भी चलाता हूं। यह वर्तमान विधि है जिसका मैं उपयोग करता हूं और यह ठीक काम करता है, लेकिन मैं एक और अधिक विधिवत विधि का उपयोग करना चाहता हूं। ऐसा लगता है कि मुझे जो चाहिए वह लाइनों के साथ एक पेडिकेट विधि दिखाई देगी, लेकिन मुझे यह सुनिश्चित नहीं है कि इसे कैसे कामया जाए।

अंत में कुछ छोटे प्रश्न भी हैं जो इस पर आगे बढ़ते हैं।

मेरे द्वारा उपयोग किए जाने वाले सरणी में लगभग 20 तत्व होते हैं, यहां 5 नहीं।

कॉलम नाम मासूम की रक्षा करने के लिए बदल गया है ...

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 
}; 

इसके अलावा DataRow वस्तु पुनः बनाने के बिना निम्न करने के लिए एक विधि है? यह अप्रत्याशित प्रतीक 'कहां' की त्रुटि देता है।

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

मैं निम्नलिखित प्राप्त करने के लिए कोशिश कर रहा हूँ, लेकिन एक डेटा तालिका का उपयोग कर धीमी जिसके कारण मैं ऊपर विधि का उपयोग करता है।

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

और अंत में, वहाँ एक पाश के बिना एक सरणी फिर से आबाद करने के लिए एक रास्ता है, मैं array.Dispose() की कोशिश की है और सरणी = अशक्त लेकिन वे काम नहीं करते। उदाहरण के लिए

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

// पुन: पॉप्युलेट सरणी जो स्पष्ट रूप से काम नहीं करती है।

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

जो नीचे या ऊपर कोड में के रूप में कई सरणियों का उपयोग करने से बहुत tidier है, उपयोग में के रूप में देखते हैं आम तौर पर सरणी में तत्वों 20+।

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

मूल्यों की जाँच All और समारोह और Enumerable.Range समारोह का एक संयोजन का उपयोग करके किया जा सकता है।

Enumerable.Range(0,myArray.Length) 
      .All(x => lowerLimit1[x] <= myArray[x] && myArray[x] <= upperLimit[x]); 

यदि सभी मान सीमा में हैं, तो यह सच हो जाएगा, और उस समय झूठ के साथ शॉर्टकट बाहर हो जाएगा।

यदि आप इसका उपयोग करने के लिए एक सहायक कार्य बनाते हैं।

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

से पहले min

डाल:

public static class MyHelperClass { 

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

तो फिर तुम

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

रिप्लेसमेंट के लिए क्या कर सकते हैं

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

तुम बस एक नई सरणी असाइन करते हैं,

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

कुछ मामलों में यह सिर्फ new double[] के बजाय करने के लिए new[] छोटा किया जा सकता है, लेकिन संकलक बिल्कुल सकारात्मक है केवल जब तुम क्या मतलब है।