Come limitare in modo efficiente e quindi concatenare un risultato con un'espressione linq/lambda?

Question

Sono in procinto di creare un servizio per semplificare la selezione di un protocollo da parte di un utente da IANA - Protocol Registry.

Come si potrebbe immaginare la ricerca nel registro per il termine http richiama un sacco di colpi. Dal momento che amt-soap-http verrà selezionato da un utente molto meno frequentemente rispetto al diretto http ho deciso che sarebbe una buona idea estrarre tutto ciò che inizia con http e quindi concatenarlo con i risultati rimanenti.

L'espressione lambda sotto è il risultato di tale processo di pensiero:

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

Purtroppo, mi sento come sto scorrendo i miei risultati più volte del necessario. Considerazioni sull'ottimizzazione prematura a parte c'è una combinazione di espressioni lambda che sarebbe più efficiente di quanto sopra?

Answer 1

Potrebbe essere più efficace come un ordinamento in due fasi:

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

Answer 2

Utilizzando commento per spiegare quello che sto cercando di fare è sempre difficile. Quindi posterò questa altra risposta. Supponiamo di voler ordinare una lista di interi casuali prima in base al suo essere pari o dispari poi in ordine numerico (simulando StartsWith con mod 2).

Ecco il caso di test: azione2 è la stessa di un'altra risposta.

Se si esegue questo codice, si vedrà che il mio suggerimento (action1) è due volte più veloce.

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