Использование LINQ для получения результатов из другой коллекции LINQ

Question

У меня есть оператор LINQ, который извлекает верхние N идентификаторов записи из коллекции, а затем еще один запрос, который извлекает все записи, которые имеют эти идентификаторы. Он чувствует себя очень неуклюжим и неэффективным, и мне было интересно, если там может быть более лаконичным, LINQy способ получить те же результаты

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

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

FYI - будет несколько записей с одинаковым идентификатором, поэтому существует Distinct() и почему я не могу использовать простой Take() в первую очередь.

Спасибо!

Answer 1

Как насчет чего-то подобного?

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

Answer 2

Да, к сожалению, LINQ не поддерживает, позволяя пользователю выбрать член, чтобы получать различные записи. Поэтому я рекомендую создать свой собственный метод расширения для нее:

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

А затем создать общий компаратор, который вы заметите довольно общий характер.

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 
    } 

Теперь только приковать ваше заявление LINQ:. Var записи = cache.Select (гес => rec.Id) .distinct() Возьмем (п);

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

НТН

Answer 3

То же самое, что вы сделали, но в одной строке и с Join() вместо Содержит():

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

Answer 4

Единственный способ, которым я могу думать, делать это в SQL будет с подзапросом, поэтому, вероятно, будут также два запроса LINQ ...
Это «чувствует» неэффективность ... не так ли? Возможно, вы беспокоитесь о чем-то, о чем не стоит беспокоиться. Вы можете, вероятно, сделать это в одну строку, выполнив объединение, но вопрос о том, является ли это более ясным/лучшим/эффективным, - это другой вопрос.

Edit: Метод расширения ответ на Aaronaught можно работать так:

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

Однако GroupBy/SelectMany выглядит опрятная. Я бы пошел с этим.

Answer 5

Существует нет встроенного способа «Linqy» (вы могли бы группу, но это было бы очень неэффективно), но это не значит, что вы не можете сделать свой собственный путь:

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

Тогда вы можете вызвать его с этим:

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

Если у вас есть составные ключи или что-нибудь подобное, что вы могли бы легко распространить метод выше, чтобы принять IEqualityComparer<TKey> в качестве аргумента.

Также обратите внимание, что это зависит от того, какие элементы находятся в отсортированном порядке по ключу.Если это не так, вы можете либо изменить алгоритм выше использовать HashSet<TKey> вместо прямого счета и последний пункт сравнения, или вызвать его вместо этого:

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

Edit - Я хотел бы также укажите, что в SQL я либо использовал бы запрос ROW_NUMBER, либо рекурсивный CTE, в зависимости от требования к производительности - четкое + объединение - это , а не - самый эффективный метод. Если ваш кеш находится в отсортированном порядке (или если вы можете изменить его в отсортированном порядке), то указанный выше метод будет самым дешевым с точки зрения как памяти, так и времени выполнения.