Utilizzo di LINQ per ottenere i risultati da un'altra raccolta LINQ

Question

Ho un'istruzione LINQ che estrae gli ID record N più importanti da una raccolta e quindi un'altra query che recupera tutti i record che contengono tali ID. Ci si sente molto goffo e inefficiente e mi chiedevo se ci potrebbe essere un, LINQy modo più succinto per ottenere gli stessi risultati

var records = cache.Select(rec => rec.Id).Distinct().Take(n); 

var results = cache.Where(rec => records.Contains(rec.Id)); 

CRONACA - non ci sarà più record con lo stesso ID, che è il motivo per cui v'è la Distinto() e perché non posso usare un semplice Take() in primo luogo.

Grazie!

Answer 1

Che ne dici di qualcosa di simile?

var results = cache.GroupBy(rec => rec.Id, rec => rec) 
        .Take(n) 
        .SelectMany(rec => rec); 

Answer 2

Sì, purtroppo LINQ non supporta nativamente il fatto di consentire all'utente di scegliere un membro per ottenere record distinti. Quindi ti consiglio di creare il tuo metodo di estensione per questo:

/// <summary> 
    /// Returns a list with the ability to specify key(s) to compare uniqueness on 
    /// </summary> 
    /// <typeparam name="T">Source type</typeparam> 
    /// <param name="source">Source</param> 
    /// <param name="keyPredicate">Predicate with key(s) to perform comparison on</param> 
    /// <returns></returns> 
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source, 
              Func<T, object> keyPredicate) 
    { 
     return source.Distinct(new GenericComparer<T>(keyPredicate)); 
    } 

E quindi creare un comparatore generico, che noterai è abbastanza generico.

public class GenericComparer<T> : IEqualityComparer<T> 
    { 
     private Func<T, object> _uniqueCheckerMethod; 

     public GenericComparer(Func<T, object> keyPredicate) 
     { 
      _uniqueCheckerMethod = keyPredicate; 
     } 

     #region IEqualityComparer<T> Members 

     bool IEqualityComparer<T>.Equals(T x, T y) 
     { 
      return _uniqueCheckerMethod(x).Equals(_uniqueCheckerMethod(y)); 
     } 

     int IEqualityComparer<T>.GetHashCode(T obj) 
     { 
      return _uniqueCheckerMethod(obj).GetHashCode(); 
     } 

     #endregion 
    } 

Ora basta catena fino vostra dichiarazione LINQ:. record var = cache.Select (rec => rec.Id) .Distinct() Prendere (n);

var results = cache.Distinct(rec => rec.Id).Take(n)); 

hth

Answer 3

La stessa cosa che hai fatto, ma in una linea e con Join() al posto di Contiene():

var results = cache 
    .Select(rec => rec.Id) 
    .Distinct() 
    .Take(n) 
    .ToList() 
    .Join(cache, rec => rec, record => record.Id, (rec, record) => record); 

Answer 4

L'unico modo che posso pensare di fare questo in SQL sarebbe con una sottoquery, quindi probabilmente ci saranno anche due query LINQ ...
"Sembra" inefficiente ... vero? Forse ti stai preoccupando di qualcosa di cui non vale la pena preoccuparsi. È possibile farlo in una riga facendo un join, ma se ciò è più chiaro/migliore/più efficiente è una domanda diversa.

Edit: Il metodo di estensione risposta da Aaronaught può essere fatto funzionare in questo modo:

public static IEnumerable<T> TakeByDistinctKey<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keyFunc, int numKeys) { 
    if(keyFunc == null) { 
     throw new ArgumentNullException("keyFunc"); 
    } 

    List<TKey> keys = new List<TKey>(); 
    foreach(T item in source) { 
     TKey key = keyFunc(item); 
     if(keys.Contains(key)) { 
      // one if the first n keys, yield 
      yield return item; 
     } else if(keys.Count < numKeys) { 
      // new key, but still one of the first n seen, yield 
      keys.Add(key); 
      yield return item; 
     } 
     // have enough distinct keys, just keep going to return all of the items with those keys 
    } 
} 

Tuttavia, il GroupBy/SelectMany sembra il più grazioso. Vorrei andare con quello.

Answer 5

Non c'è modo "Linqy" built-in (si potrebbe gruppo, ma sarebbe piuttosto inefficiente), ma questo non significa che non si può fare il proprio modo:

public static IEnumerable<T> TakeDistinctByKey<T, TKey>(
    this IEnumerable<T> source, 
    Func<T, TKey> keyFunc, 
    int count) 
{ 
    if (keyFunc == null) 
     throw new ArgumentNullException("keyFunc"); 
    if (count <= 0) 
     yield break; 

    int currentCount = 0; 
    TKey lastKey = default(TKey); 
    bool isFirst = true; 
    foreach (T item in source) 
    { 
     yield return item; 
     TKey key = keyFunc(item); 
     if (!isFirst && (key != lastKey)) 
      currentCount++; 
     if (currentCount > count) 
      yield break; 
     isFirst = false; 
     lastKey = key; 
    } 
} 

Poi è possibile richiamare con questo:

var items = cache.TakeDistinctByKey(rec => rec.Id, 20); 

Se si dispone di chiavi composte o qualcosa di simile si potrebbe facilmente estendere il metodo di cui sopra per prendere un IEqualityComparer<TKey> come argomento.

Si noti inoltre che ciò dipende dal fatto che gli elementi si trovano nell'ordine ordinato per chiave.Se non lo sono, si potrebbe o cambia l'algoritmo di cui sopra per usare un HashSet<TKey> invece di un confronto conteggio e ultimo elemento dritto, o invocare con questo, invece:

var items = cache.OrderBy(rec => rec.Id).TakeDistinctByKey(rec => rec.Id, 20); 

Edit - Mi piacerebbe anche Fai notare che in SQL avrei usato una query ROW_NUMBER o una CTE ricorsiva, a seconda dei requisiti di prestazione: un + join è diverso da il metodo più efficiente. Se la cache è in ordine ordinato (o se è possibile modificarla in ordine ordinato), il metodo sopra riportato sarà di gran lunga il più economico in termini di tempo di memoria e di esecuzione.