प्राप्त पिछले डुप्लिकेट एक सूची में तत्व

एक तरीका यह करने के लिए उपयोग किया जाएगा सूचकांक में आइटम की मूल संग्रह के साथ-साथ GroupBy. उदाहरण के लिए,

    var lastDistinct = filterList.Select((x,index)=> new {Value=x,Index=index})
                                 .GroupBy(x=>x.Value)
                                 .Select(x=> x.Last())
                                 .OrderBy(x=>x.Index)
                                 .Select(x=>x.Value);
    var result = string.Join(",",lastDistinct);

आउटपुट

access,postpone,success

अपने इनपुट सूची में केवल स्ट्रिंग प्रकार का है, इसलिए का उपयोग कर groupBy नहीं करता है वास्तव में कुछ भी जोड़ें. अगर आप समझते हैं अपने कोड, आपकी पहली पंक्ति देता है आप विशिष्ट सूची में, आप केवल अपना अलग आइटम था क्योंकि, आप एक स्ट्रिंग है.में शामिल होने लाइन पर 2. तुम सब करने की ज़रूरत है जोड़ने के लिए एक लाइन से पहले आप में शामिल होने:

List<string> filter = filterList.Distinct().ToList();
string last = filter.LastOrDefault();
string a = string.Join(",", filter.Select(a => a).ToArray());
Console.WriteLine(a);

मुझे लगता है कि आप कर सकता है अपने कोड और अधिक संक्षिप्त है, क्योंकि आप की जरूरत है न तो .का चयन करें(एक => एक) और न ही .ToArray() में अपने कॉल करने के लिए स्ट्रिंग.में शामिल हों.

GroupBy इस्तेमाल किया जाएगा यदि आप था की एक सूची वर्ग/संरचना/रिकॉर्ड/टपल आइटम, जहाँ आप चाहते हो सकता करने के लिए समूह द्वारा एक विशेष कुंजी (या कुंजी) का उपयोग कर के बजाय अलग-अलग() पर पूरी बात. GroupBy बहुत उपयोगी है और आप सीखना चाहिए कि, और यह भी ToDictionary और ToLookup LINQ सहायक कार्यक्षमता ।

एक OrderedDictionary इस करता है । सब तुम्हें क्या करना है अपने आइटम जोड़ें, यह करने के लिए के साथ एक तर्क है की "अगर यह शब्दकोश में इसे हटा दें । जोड़ें". OrderedDictionary को बरकरार रखता है के आदेश जोड़ना तो दूर करके एक पहले जोड़ा गया एक और फिर से जोड़ने के यह करने के लिए कूदता के अंत में शब्दकोश

var d = new OrderedDictionary();
filterList.ForEach(x => { if(d.Contains(x)) d.Remove(x); d[x] = null; });

अपने d.Keys अब एक सूची के तार

access
postpone
success

OrderedDictionary में है Collections.Specialized नामस्थान

यदि आप चाबियाँ एक सीएसवी के रूप में, आप का उपयोग कर सकते हैं Cast उन्हें बारी करने के लिए से वस्तु स्ट्रिंग के लिए

var s = string.Join(",", d.Keys.Cast<string>());

तो तुम क्यों नहीं करना चाहिए वापसी की पहली घटना "स्थगित"? क्योंकि अनुक्रम में बाद में आप देखते हैं एक ही शब्द "स्थगित" फिर से. क्यों आप वापसी की पहली घटना "का उपयोग"? क्योंकि अनुक्रम में बाद में आप देख नहीं है इस शब्द अब और नहीं.

तो: वापसी, तो एक शब्द के बाकी अनुक्रम नहीं है, यह शब्द ।

यह आसान हो जाएगा में LINQ, प्रत्यावर्तन के साथ, लेकिन यह बहुत कुशल नहीं है: हर शब्द के लिए आप होगा की जाँच करने के लिए बाकी के अनुक्रम देखने के लिए अगर शब्द है में आराम करो.

यह होगा और अधिक कुशल तरीके से याद करने के लिए उच्चतम सूचकांक पर जो आप एक शब्द पाया.

के रूप में एक विस्तार विधि है । यदि आप परिचित नहीं हैं के साथ विस्तार तरीकों, देखते विस्तार तरीकों demystified.

private static IEnumerable<T> FindLastOccurences<T>(this IEnumerable<T> source)
{
    return FindLastOccurrences<T>(source, null);
}

private static IEnumerable<T> FindLastOccurences<T>(this IEnumerable<T> source,
    IEqualityComparer<T> comparer)
{
    // TODO: check source not null
    if (comparer == null) comparer = EqualityComparer<T>.Default;

    Dictionary<T, int> dictionary = new Dictionary<T, int>(comparer);

    int index = 0;
    foreach (T item in source)
    {
        // did we already see this T? = is this in the dictionary
        if (dictionary.TryGetValue(item, out int highestIndex))
        {
            // we already saw it at index highestIndex.
            dictionary[item] = index;
        }
        else
        {
            // it is not in the dictionary, we never saw this item.
            dictionary.Add(item, index);
        }
        ++index;
    }

    // return the keys after sorting by value (which contains the highest index)
    return dictionay.OrderBy(keyValuePair => keyValuePair.Value)
                    .Select(keyValuePair => keyValuePair.Key);
}
         

तो में हर आइटम के लिए स्रोत अनुक्रम के साथ, हम जाँच अगर यह शब्दकोश में है. यदि नहीं, तो हम आइटम जोड़ने के रूप में करने के लिए कुंजी शब्दकोश. मूल्य सूचकांक है ।

यदि यह पहले से ही है शब्दकोश में है, तो मूल्य सबसे अधिक था के सूचकांक जहां हमने पाया है इस मद से पहले. जाहिरा तौर पर वर्तमान सूचकांक में अधिक है, तो हम जगह में मूल्य शब्दकोश में है ।

अंत में, हम आदेश की कुंजी मूल्य जोड़े में शब्दकोश द्वारा आरोही मूल्य, और बदले केवल चाबियाँ.