दिलचस्प पोस्ट
स्विफ्ट प्रोटोकॉल विरासत और प्रोटोकॉल अनुरूपता समस्या एएसपी.नेट कोर एमवीसी में टैग हेल्पर का चयन करें विंडोज में पायथन से एक्सेल ड्राइव करना मुद्रण जावा कलेक्शंस अच्छी तरह से (toString सुंदर आउटपुट नहीं लौटाता है) रेलवे में www यूआरएल को गैर-www अनुरोधों को पुन: निर्देशित करें मैं पी में डीआईवी कैसे डाल सकता हूं? सी # का उपयोग करके डाली गई पंक्ति का आईडी प्राप्त करें पॉपअप Window – जब बाहर क्लिक किया तो ख़ारिज करें रूबी में, 'नया' और 'आरंभ' के बीच संबंध क्या हैं? आरंभ करने के दौरान शून्य कैसे वापस आना है? चयन तत्व की सामग्री को सॉर्ट करने के लिए जावास्क्रिप्ट मैं इस preg_match केस को असंवेदनशील कैसे बना सकता हूं? कैसे ग्रहण में एक नया एवीडी बनाने के लिए? स्क्रीनशॉट की आईओएस जांच System.Data.OracleClient को ओरेकल ग्राहक सॉफ्टवेयर संस्करण 8.1.7 की आवश्यकता है एक जटिल प्रकार पोस्ट करने के लिए System.Net.HttpClient का उपयोग कैसे करें?

एक 'foreach' लूप में एक सूची को संशोधित करने का सबसे अच्छा तरीका क्या है?

C # / .NET 4.0 में एक नई विशेषता यह है कि अपवाद प्राप्त किए बिना आप अपनी गणना को अग्रगमन में बदल सकते हैं। पॉल जॅक्सन का ब्लॉग एंट्री देखें एक दिलचस्प पक्ष-संगामिति का प्रभाव: इस बदलाव पर जानकारी के लिए एन्यूमरेट करते हुए एक संग्रह से आइटम को निकालना

निम्न कार्य करने का सबसे अच्छा तरीका क्या है?

 foreach(var item in Enumerable) { foreach(var item2 in item.Enumerable) { item.Add(new item2) } } 

आम तौर पर मैं एक IList को कैश / बफर के रूप में उपयोग करता हूं, जो कि IList के अंत तक होता है, लेकिन क्या बेहतर तरीका है?

Solutions Collecting From Web of "एक 'foreach' लूप में एक सूची को संशोधित करने का सबसे अच्छा तरीका क्या है?"

विदेशी मुद्रा में इस्तेमाल किया जाने वाला संग्रह अपरिवर्तनीय है। यह डिजाइन द्वारा बहुत ज्यादा है

जैसा कि एमएसडीएन पर कहते हैं:

भविष्यवाणी के बयान का उपयोग उस जानकारी को प्राप्त करने के लिए संग्रह के माध्यम से फिर से करने के लिए किया जाता है, जिसे आप चाहते हैं, लेकिन अप्रत्याशित साइड इफेक्ट से बचने के लिए स्रोत संग्रह से आइटम जोड़ने या हटाने के लिए उपयोग नहीं किया जा सकता। यदि आपको स्रोत संग्रह से आइटम जोड़ने या निकालने की आवश्यकता है, तो लूप का उपयोग करें।

पोको द्वारा प्रदान की गई लिंक में पोस्ट इंगित करता है कि इसे नए समवर्ती संग्रह में अनुमति है।

इस मामले में एक IEnumerable विस्तार विधि का उपयोग करते हुए, गणन की एक प्रति बनाओ, और इसके बारे में बताएं। यह प्रत्येक तत्व की एक प्रति उस गणन के लिए गणना की जा सकती है।

 foreach(var item in Enumerable) { foreach(var item2 in item.Enumerable.ToList()) { item.Add(item2) } } 

जैसा कि उल्लेख किया गया है, लेकिन एक कोड नमूने के साथ:

 foreach(var item in collection.ToArray()) collection.Add(new Item...); 

निप्पीसॉरस के जवाब को स्पष्ट करने के लिए: यदि आप सूची में नए आइटम जोड़ना चाहते हैं और नए जोड़े गए आइटमों को उसी गणन के दौरान भी संसाधित करना चाहते हैं तो आप केवल फोरश लूप के बजाय पाश के लिए उपयोग कर सकते हैं, समस्या हल हो गई है 🙂

 var list = new List<YourData>(); ... populate the list ... //foreach (var entryToProcess in list) for (int i = 0; i < list.Count; i++) { var entryToProcess = list[i]; var resultOfProcessing = DoStuffToEntry(entryToProcess); if (... condition ...) list.Add(new YourData(...)); } 

रननेबल उदाहरण के लिए:

 void Main() { var list = new List<int>(); for (int i = 0; i < 10; i++) list.Add(i); //foreach (var entry in list) for (int i = 0; i < list.Count; i++) { var entry = list[i]; if (entry % 2 == 0) list.Add(entry + 1); Console.Write(entry + ", "); } Console.Write(list); } 

पिछला उदाहरण का आउटपुट:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 3, 5, 7, 9,

सूची (15 आइटम)
0
1
2
3
4
5
6
7
8
9
1
3
5
7
9

यदि आप वास्तव में इस प्रकार के व्यवहार की ज़रूरत है, तो आपको अपने डिजाइन पर पुनर्विचार करना चाहिए या सभी IList<T> सदस्यों को ओवरराइड करना चाहिए और स्रोत सूची को एकमात्र बनाना चाहिए:

 using System; using System.Collections.Generic; namespace ConsoleApplication3 { public class ModifiableList<T> : List<T> { private readonly IList<T> pendingAdditions = new List<T>(); private int activeEnumerators = 0; public ModifiableList(IEnumerable<T> collection) : base(collection) { } public ModifiableList() { } public new void Add(T t) { if(activeEnumerators == 0) base.Add(t); else pendingAdditions.Add(t); } public new IEnumerator<T> GetEnumerator() { ++activeEnumerators; foreach(T t in ((IList<T>)this)) yield return t; --activeEnumerators; AddRange(pendingAdditions); pendingAdditions.Clear(); } } class Program { static void Main(string[] args) { ModifiableList<int> ints = new ModifiableList<int>(new int[] { 2, 4, 6, 8 }); foreach(int i in ints) ints.Add(i * 2); foreach(int i in ints) Console.WriteLine(i * 2); } } } 

आप वास्तव में इस मामले में foreach () के बजाय () के लिए उपयोग करना चाहिए

संग्रह के साथ जगलिंग के लिए LINQ बहुत प्रभावी है।

आपके प्रकार और संरचना मेरे लिए स्पष्ट नहीं हैं, लेकिन मैं अपनी योग्यता के लिए अपने उदाहरण को फिट करने का प्रयास करूंगा।

आपके कोड से ऐसा प्रतीत होता है कि, प्रत्येक आइटम के लिए, आप उस आइटम को अपने 'एन्युमेरेबल' प्रॉपर्टी से जोड़ते हैं यह बहुत आसान है:

 foreach (var item in Enumerable) { item = item.AddRange(item.Enumerable)); } 

एक अधिक सामान्य उदाहरण के रूप में, मान लें कि हम एक संग्रह को पुनरावृति करना चाहते हैं और उन चीजों को हटाएं जहां एक निश्चित स्थिति सही है। LINQ का प्रयोग करते हुए, foreach से बचना:

 myCollection = myCollection.Where(item => item.ShouldBeKept); 

प्रत्येक मौजूदा आइटम के आधार पर कोई आइटम जोड़ें? कोई बात नहीं:

 myCollection = myCollection.Concat(myCollection.Select(item => new Item(item.SomeProp))); 

जब गणना की जा रही है, तो आप गणना संग्रह को बदल नहीं सकते हैं, इसलिए आपको गणना करने से पहले या बाद में अपने बदलाव करना होगा।

लूप के लिए एक अच्छा विकल्प है, लेकिन यदि आपका IEnumerable संग्रह ICollection लागू नहीं करता है, तो यह संभव नहीं है।

कोई एक:

1) कॉपी संग्रह पहले कॉपी किए गए संग्रह की गणना करें और गणना के दौरान मूल संग्रह को परिवर्तित करें। (@tvanfosson)

या

2) परिवर्तनों की एक सूची रखें और उन्हें गणना के बाद करें।

एक प्रदर्शन परिप्रेक्ष्य से सबसे अच्छा तरीका शायद एक या दो सरणियों का उपयोग करना है सूची को किसी सरणी में कॉपी करें, सरणी पर कार्य करें, और फिर सरणी से एक नई सूची बनाएं। एक सरणी तत्व तक पहुंचने से सूची वस्तु तक पहुंचने में तेज़ होता है, और List<T> और एक T[] बीच रूपांतरण एक तेज "थोक प्रतिलिपि" ऑपरेशन का उपयोग कर सकते हैं जो ओवरहेड से जुड़े व्यक्तिगत आइटम तक पहुंचने से बचा जाता है।

उदाहरण के लिए, मान लें कि आपके पास एक List<string> और सूची में प्रत्येक स्ट्रिंग की इच्छा है जो T साथ शुरू होती है एक "बू" के बाद, जबकि "यू" के साथ शुरू होने वाली प्रत्येक स्ट्रिंग पूरी तरह से गिरा दी जाती है। एक इष्टतम दृष्टिकोण शायद कुछ ऐसा होगा:

 int srcPtr,destPtr; string[] arr; srcPtr = theList.Count; arr = new string[srcPtr*2]; theList.CopyTo(arr, theList.Count); // Copy into second half of the array destPtr = 0; for (; srcPtr < arr.Length; srcPtr++) { string st = arr[srcPtr]; char ch = (st ?? "!")[0]; // Get first character of string, or "!" if empty if (ch != 'U') arr[destPtr++] = st; if (ch == 'T') arr[destPtr++] = "Boo"; } if (destPtr > arr.Length/2) // More than half of dest. array is used { theList = new List<String>(arr); // Adds extra elements if (destPtr != arr.Length) theList.RemoveRange(destPtr, arr.Length-destPtr); // Chop to proper length } else { Array.Resize(ref arr, destPtr); theList = new List<String>(arr); // Adds extra elements } 

यह मददगार होगा यदि List<T> ने एक सरणी के एक हिस्से से सूची बनाने के लिए एक विधि प्रदान की, लेकिन मैं ऐसा करने के लिए किसी भी कुशल तरीके से अनजान हूँ। फिर भी, सरणियों का संचालन बहुत तेज है नोट के तथ्य यह है कि सूची से आइटम जोड़ने और निकालने के लिए अन्य वस्तुओं के आसपास "धक्का" की आवश्यकता नहीं है; प्रत्येक आइटम को सरणी में सीधे अपने उचित स्थान पर लिखा जाता है