दिलचस्प पोस्ट
कॉफी स्क्रिप्ट मॉड्यूल के लिए पैटर्न एएसपी-क्लासिक के साथ फाइल कैसे अपलोड करें अप्रबंधित कोड के लिए सी ++ / सीएलआई पास (प्रबंधित) प्रतिनिधि स्ट्रिंग आउटपुट: सी # में प्रारूप या कॉन्सैट? आप पायथन में दो चर के लॉजिकल एक्सओर कैसे प्राप्त करते हैं? स्कला: सार प्रकार बनाम जेनरिक पायथन जोरदार टाइप किया गया है? NHibernate AliasToBean ट्रांसफॉर्मर एसोसिएशन क्या वेबसाईट्स पी 2 पी (ब्राउज़र से ब्राउज़र) संचार की अनुमति देते हैं? LINQ तरीकों की रन-टाइम जटिलता (बिग-ओ) पर क्या गारंटी है? क्या जवाक को "अनचेक या असुरक्षित संचालन का उपयोग" चेतावनी जारी करने का कारण बनता है पता करें कि फ़ाइल बैच फ़ाइल में 4 घंटे से अधिक पुरानी है एक दांतेदार पथ चौरसाई आर में एक अन्य समारोह के भीतर ggplot () का उपयोग करें अपने ऐप के मैनिफेस्ट में Google Play सेवाएं संस्करण जोड़ना?

एक IEnumerable में एक तत्व का सूचक कैसे प्राप्त करें?

मैंने यह लिखा:

public static class EnumerableExtensions { public static int IndexOf<T>(this IEnumerable<T> obj, T value) { return obj .Select((a, i) => (a.Equals(value)) ? i : -1) .Max(); } public static int IndexOf<T>(this IEnumerable<T> obj, T value , IEqualityComparer<T> comparer) { return obj .Select((a, i) => (comparer.Equals(a, value)) ? i : -1) .Max(); } } 

लेकिन मुझे नहीं पता कि यह पहले से मौजूद है, है ना?

वेब के समाधान से एकत्रित समाधान "एक IEnumerable में एक तत्व का सूचक कैसे प्राप्त करें?"

IEnumerable के रूप में चीजें बाहर निकलने का पूरा मुद्दा यह है कि आप सामग्री पर आलसी रीजोल कर सकते हैं जैसे, कोई सूचकांक वास्तव में एक अवधारणा नहीं है। आप वास्तव में क्या कर रहे हैं एक IEnumerable के लिए बहुत सारी समझ नहीं है यदि आपको कुछ ऐसी चीज है जो सूचकांक द्वारा एक्सेस का समर्थन करती है, तो इसे एक वास्तविक सूची या संग्रह में रखें।

मैं ज्ञान से सवाल करता हूं, लेकिन शायद:

 source.TakeWhile(x => x != value).Count(); 

( EqualityComparer<T>.Default का उपयोग करें != अनुकरण करने के लिए EqualityComparer<T>.Default != यदि आवश्यक हो) – लेकिन आपको -1 लौटने के लिए देखने की आवश्यकता है यदि नहीं मिला … तो शायद यह सिर्फ लंबा रास्ता

 public static int IndexOf<T>(this IEnumerable<T> source, T value) { int index = 0; var comparer = EqualityComparer<T>.Default; // or pass in as a parameter foreach (T item in source) { if (comparer.Equals(item, value)) return index; index++; } return -1; } 

मैं इसे इस तरह लागू करेगा:

 public static class EnumerableExtensions { public static int IndexOf<T>(this IEnumerable<T> obj, T value) { return obj.IndexOf(value, null); } public static int IndexOf<T>(this IEnumerable<T> obj, T value, IEqualityComparer<T> comparer) { comparer = comparer ?? EqualityComparer<T>.Default; var found = obj .Select((a, i) => new { a, i }) .FirstOrDefault(x => comparer.Equals(xa, value)); return found == null ? -1 : found.i; } } 

जिस तरह से मैं वर्तमान में ऐसा कर रहा हूं वह पहले से ही सुझाए गए लोगों की तुलना में थोड़ा कम है और जहाँ तक मैं बता सकता हूं वांछित परिणाम देता है:

  var index = haystack.ToList().IndexOf(needle); 

यह थोड़ा clunky है, लेकिन यह काम करता है और काफी संक्षिप्त है।

मुझे लगता है कि सबसे अच्छा विकल्प इस तरह लागू करना है:

 public static int IndexOf<T>(this IEnumerable<T> enumerable, T element, IEqualityComparer<T> comparer = null) { int i = 0; comparer = comparer ?? EqualityComparer<T>.Default; foreach (var currentElement in enumerable) { if (comparer.Equals(currentElement, element)) { return i; } i++; } return -1; } 

यह गुमनाम वस्तु भी नहीं बनाएगा

खेल में थोड़ा देर हो चुकी है, मुझे पता है … लेकिन यह मैंने हाल ही में किया था। यह आपकी तुलना में थोड़ा अलग है, लेकिन प्रोग्रामर को यह निर्धारित करने की अनुमति देता है कि समानता आपरेशन को क्या करना चाहिए (निश्चय)। विभिन्न प्रकारों से निपटने में मुझे कौन सा बहुत उपयोगी लगता है, क्योंकि इसके बाद मैं ऑब्जेक्ट प्रकार की परवाह किए बिना ऐसा करने का एक सामान्य तरीका और <T> समानता ऑपरेटर में बनाया गया है

इसमें बहुत कम स्मृति पदचिह्न भी है, और बहुत, बहुत तेज़ / कुशल … यदि आप उस बारे में ध्यान रखते हैं

इससे भी बदतर है, आप बस अपने एक्सटेंशन की सूची में इसे जोड़ देंगे

वैसे भी … यह यहाँ है

  public static int IndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate) { int retval = -1; var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { retval += 1; if (predicate(enumerator.Current)) { IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) disposable.Dispose(); return retval; } } IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) disposable.Dispose(); return -1; } 

उम्मीद है कि यह किसी को मदद करता है

कुछ साल बाद, लेकिन यह Linq का उपयोग करता है -1 लौटाता है, यदि नहीं मिला, अतिरिक्त ऑब्जेक्ट नहीं बनाए, और जब शॉर्ट-सर्किट पाया जाए [पूरे आईएनइन्मेरेबल पर पुनरावृत्त होने के विपरीत]:

 public static int IndexOf<T>(this IEnumerable<T> list, T item) { return list.Select((x, index) => EqualityComparer<T>.Default.Equals(item, x) ? index : -1) .FirstOr(x => x != -1, -1); } 

जहां पहले 'है':

 public static T FirstOr<T>(this IEnumerable<T> source, T alternate) { return source.DefaultIfEmpty(alternate) .First(); } public static T FirstOr<T>(this IEnumerable<T> source, Func<T, bool> predicate, T alternate) { return source.Where(predicate) .FirstOr(alternate); } 

स्थिति को पकड़ने का सर्वोत्तम तरीका FindIndex द्वारा है यह फ़ंक्शन केवल List<> लिए उपलब्ध है

उदाहरण

 int id = listMyObject.FindIndex(x => x.Id == 15); 

यदि आपके पास गणक या सरणी इस तरह से उपयोग करते हैं

 int id = myEnumerator.ToList().FindIndex(x => x.Id == 15); 

या

  int id = myArray.ToList().FindIndex(x => x.Id == 15); 

तथ्य के बाद इंडेक्स को खोजने के लिए एक विकल्प, लिंक्स समूह बाय () विधि का उपयोग करने के लिए कुछ हद तक समान रूप से लपेट करना है।

 public static class IndexedEnumerable { public static IndexedEnumerable<T> ToIndexed<T>(this IEnumerable<T> items) { return IndexedEnumerable<T>.Create(items); } } public class IndexedEnumerable<T> : IEnumerable<IndexedEnumerable<T>.IndexedItem> { private readonly IEnumerable<IndexedItem> _items; public IndexedEnumerable(IEnumerable<IndexedItem> items) { _items = items; } public class IndexedItem { public IndexedItem(int index, T value) { Index = index; Value = value; } public T Value { get; private set; } public int Index { get; private set; } } public static IndexedEnumerable<T> Create(IEnumerable<T> items) { return new IndexedEnumerable<T>(items.Select((item, index) => new IndexedItem(index, item))); } public IEnumerator<IndexedItem> GetEnumerator() { return _items.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } } 

जो का उपयोग मामला देता है:

 var items = new[] {1, 2, 3}; var indexedItems = items.ToIndexed(); foreach (var item in indexedItems) { Console.WriteLine("items[{0}] = {1}", item.Index, item.Value); }