लूप के लिए एक समय में एन लेने का कोई और तरीका है?

Question

क्या इस तरह के लूप की तुलना में एक समय में 5 वस्तुओं को लागू करने का एक और शानदार तरीका है? 5 के बजाय द्वारा

var q = Campaign_stats.OrderByDescending(c=>c.Leads).Select(c=>c.PID).Take(23); 
var count = q.Count(); 
for (int i = 0; i < (count/5)+1; i++) 
{ 
    q.Skip(i*5).Take(5).Dump(); 
} 

Answer 1

तो तुम कुशलतापूर्वक q में हर 5 वस्तुओं पर Dump() कॉल करना चाहते हैं।

आपके पास अब समाधान IEnumerable<T> को for लूप के माध्यम से फिर से पुन: सक्रिय करेगा। यह इस तरह से कुछ करने के लिए और अधिक कुशल हो सकता है: (मैं नहीं जानता कि क्या अपने प्रकार तो मैं T उपयोग कर रहा हूँ है)

const int N = 5; 
T[] ar = new T[N];    // Temporary array of N items. 
int i=0; 
foreach(var item in q) {   // Just one iterator. 
    ar[i++] = item;    // Store a reference to this item. 
    if (i == N) {    // When we have N items, 
     ar.Dump();    // dump them, 
     i = 0;     // and reset the array index. 
    } 
} 

// Dump the remaining items 
if (i > 0) { 
    ar.Take(i).Dump(); 
} 

यह केवल एक iterator उपयोग करता है। अपने चर को ध्यान में रखते हुए q नाम दिया गया है, मुझे लगता है कि "क्वेरी" के लिए छोटा है, जिसका अर्थ यह है कि यह डेटाबेस के विरुद्ध है। तो केवल एक इटरेटर का उपयोग करना बहुत फायदेमंद हो सकता है।

---

मैं इस कोड को रख सकता हूं, और इसे एक विस्तार विधि में लपेट सकता हूं। कैसे "टक्कर" के बारे में?

public static IEnumerable<IEnumerable<T>> Clump<T>(this IEnumerable<T> items, int clumpSize) { 
    T[] ar = new T[clumpSize]; 
    int i=0; 
    foreach(var item in items) { 
     ar[i++] = item; 
     if (i == clumpSize) { 
      yield return ar; 
      i = 0; 
     } 
    } 
    if (i > 0) 
     yield return ar.Take(i); 
} 

अपने कोड के संदर्भ में यह कॉलिंग:

foreach (var clump in q.Clump(5)) { 
    clump.Dump(); 
} 

Answer 2

for(int i = 0; i <= count; i+=5) 
{ 
} 

Answer 3

कोशिश बार-बार दोहराना!

for(int i = 0; i < count; i += 5) 
{ 
    //etc 
} 

Answer 4

GroupBy और पिन के साथ और अधिक LINQ जोड़ना:

q 
// add indexes 
.Zip(Enumerable.Range(0, Int32.MaxValue),(a,index)=> new {Index=index, Value=a}) 
.GroupBy(m=>m.Index /5) // divide in groups by 5 items each 
.Select(k => { 
    k.Select(v => v.Value).Dump(); // Perform operation on 5 elements 
    return k.Key; // return something to satisfy Select. 
});