अन्य LINQ संग्रह

Question

से परिणाम प्राप्त करने के लिए LINQ का उपयोग करना मेरे पास एक LINQ कथन है जो संग्रह से शीर्ष एन रिकॉर्ड आईडी खींचता है और फिर एक और क्वेरी जो उन सभी रिकॉर्ड्स को खींचती है जिनके पास आईडी हैं। यह बहुत ही भद्दा और अक्षम महसूस करता है और अगर वहाँ एक और अधिक संक्षिप्त, LINQy रास्ता

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

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

FYI एक ही परिणाम प्राप्त करने के लिए हो सकता है मैं सोच रहा था - वहाँ एक ही आईडी है, जो के साथ कई रिकॉर्ड किया जाएगा क्यों है अलग() और क्यों मैं पहली जगह में एक साधारण टेक() का उपयोग नहीं कर सकता।

धन्यवाद!

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

और फिर एक सामान्य comparer, जो आप देखेंगे काफी सामान्य है बनाएँ।

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 बयान:। वर रिकॉर्ड = cache.Select (आरईसी => rec.Id) .Distinct() (एन) ले लो;

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

hth

Answer 3

एक ही बात तुमने किया था, लेकिन ((एक पंक्ति में और साथ जुड़ें) के बजाय शामिल है):

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

Answer 4

एक ही रास्ता है कि मैं यह कर के बारे में सोच सकते हैं एसक्यूएल में एक सबक्वायरी के साथ होगा, तो शायद दो LINQ प्रश्न भी होंगे ...
यह "महसूस करता है" अक्षम है ... है ना? शायद आप किसी ऐसे चीज के बारे में चिंता कर रहे हैं जो चिंता करने योग्य नहीं है। आप इसे शामिल करके एक पंक्ति में बना सकते हैं, लेकिन क्या यह स्पष्ट/बेहतर/अधिक कुशल है एक अलग सवाल है।

संपादित करें: 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 neatest लग रहा है। मैं उस के साथ जाऊंगा।

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

संपादित करें - मैं भी करना चाहते हैं इंगित करें कि एसक्यूएल में मैं प्रदर्शन की आवश्यकता के आधार पर ROW_NUMBER क्वेरी या रिकर्सिव सीटीई का उपयोग करता हूं - एक विशिष्ट + जॉइन सबसे प्रभावी विधि नहीं है। यदि आपका कैश क्रमबद्ध क्रम में है (या यदि आप इसे क्रमबद्ध क्रम में बदल सकते हैं) तो ऊपर दी गई विधि स्मृति और निष्पादन समय दोनों के मामले में सबसे सस्ती होगी।