एक लिनक/लैम्ब्डा अभिव्यक्ति के साथ परिणाम को कुशलतापूर्वक सीमित करने के लिए कैसे करें?

Question

मैं उपयोगकर्ता को IANA - Protocol Registry से प्रोटोकॉल चुनना आसान बनाने के लिए एक सेवा बनाने की प्रक्रिया में हूं।

जैसा कि आप कल्पना कर सकते हैं कि http शब्द के लिए रजिस्ट्री को खोजना बहुत सारी हिट खींचता है। चूंकि amt-soap-http उपयोगकर्ता द्वारा सीधे http की तुलना में बहुत कम बार-बार चुना जा रहा है, मैंने फैसला किया कि http से शुरू होने वाली सभी चीज़ों को खींचना एक अच्छा विचार होगा और फिर शेष परिणामों के साथ इसे संयोजित करें।

var records = this._ianaRegistryService.GetAllLike(term).ToList(); 
var results = records.Where(r => r.Name.StartsWith(term)) 
        .OrderBy(r => r.Name) 
        .Concat(records.Where(r => !r.Name.StartsWith(term)) 
            .OrderBy(r => r.Name)) 
        .Take(MaxResultSize); 

दुर्भाग्य से, मुझे लगता है कि मैं आवश्यकता से अपने परिणाम के माध्यम से अधिक बार पुनरावृत्ति कर रहा हूँ:

नीचे लैम्ब्डा अभिव्यक्ति है कि विचार प्रक्रिया का परिणाम है। समय से पहले अनुकूलन विचारों को लैम्ब्डा अभिव्यक्तियों का एक संयोजन है जो ऊपर की तुलना में अधिक कुशल होगा?

Answer 1

यह एक दो कदम आदेश के रूप में और अधिक कुशल हो सकता है:

var results = records.OrderBy(r => r.Name.StartsWith(term) ? 1 : 2) 
        .ThenBy(r => r.Name) 
        .Take(MaxResultSize); 

Answer 2

टिप्पणी का प्रयोग समझाने के लिए मुझे क्या करना कठिन हो रही है कोशिश कर रहा हूँ। तो मैं यह एक और जवाब पोस्ट करूंगा। मान लीजिए कि मैं संख्यात्मक क्रम में पहले या अजीब होने के बाद पहले यादृच्छिक पूर्णांक की एक सूची को सॉर्ट करना चाहता हूं (StartsWith को mod 2 के साथ अनुकरण)।

यहां परीक्षण केस है: action2 अन्य उत्तर के समान है।

यदि आप यह कोड चलाते हैं तो आप देखेंगे कि मेरा सुझाव (action1) दो गुना तेज है।

void Test() 
{ 
    Random rnd = new Random(); 
    List<int> records = new List<int>(); 
    for(int i=0;i<2000000;i++) 
    { 
     records.Add(rnd.Next()); 
    } 

    Action action1 =() => 
    { 
     var res1 = records.GroupBy(r => r % 2) 
        .OrderBy(x => x.Key) 
        .Select(x => x.OrderBy(y => y)) 
        .SelectMany(x => x) 
        .ToList(); 
    }; 

    Action action2 =() => 
    { 
     var res2 = records.OrderBy(x => x % 2).ThenBy(x => x).ToList(); 
    }; 


    //Avoid counting JIT 
    action1(); 
    action2(); 


    var sw = Stopwatch.StartNew(); 
    action1(); 
    long t1 = sw.ElapsedMilliseconds; 

    sw.Restart(); 
    action2(); 
    long t2 = sw.ElapsedMilliseconds; 

    Console.WriteLine(t1 + " " + t2); 
}