दिलचस्प पोस्ट
स्ट्रिंग को सी में बदलने के लिए कैसे करें मैं जावास्क्रिप्ट ऑब्जेक्ट वैरिएबल में डुनेबल की गतिशील कुंजी कैसे बनाऊं? "UpdateSourceTrigger = PropertyChanged" एक विंडोज फोन 7 पाठ बॉक्स के लिए बराबर है आईफ़ोन – डेक्यूवर पुन: प्रयोज्य सेल वॉथआईडेंटिफायर उपयोग एंड्रॉइड में प्रोग्राम को एक कस्टम खाता कैसे जोड़ें? ICloud ड्राइव पर आईओएस 8 दस्तावेज़ सहेजें एंड्रॉइड कस्टम व्यू कंस्ट्रक्टर सरल जावा क्लाइंट / सर्वर प्रोग्राम यह पता लगाने के लिए कि उपयोगकर्ता इंटरनेट ब्राउज़र को बंद कर रहा है, जो कि ऑनऑनलॉग इवेंट से अलग है, क्योंकि जब उपयोगकर्ता को रिफ्रेश किया जाता है तो उसे ट्रिगर किया जाता है $ (खिड़की)। हल्का () बनाम $ (दस्तावेज़) IIS को प्रकाशित करें, पर्यावरण चर सेट करना इकाई डेटा ढांचे से ट्रिगर के बजाय तालिका में डालने में त्रुटि मैं स्ट्रिंग की सामग्री को सी # में क्लिपबोर्ड पर कैसे कॉपी करूँ? HTML से चयन विकल्प मान प्राप्त करने के लिए $ _POST का उपयोग करना जब मैं फ़ंक्शन के अंदर कोई पैरामीटर बदलता हूं, तो क्या यह कॉलर के लिए भी बदलता है?

IEnumerable <T> के लिए विदेशी मुद्रा के LINQ समकक्ष

मैं निम्नलिखित के बराबर LINQ में करना चाहता हूं, लेकिन मैं यह नहीं समझ सकता कि कैसे:

IEnumerable<Item> items = GetItems(); items.ForEach(i => i.DoStuff()); 

असली वाक्यविन्यास क्या है?

Solutions Collecting From Web of "IEnumerable <T> के लिए विदेशी मुद्रा के LINQ समकक्ष"

IEnumerable लिए कोई अतिरिक्त एक्सटेंशन नहीं है; केवल List<T> के लिए तो आप ऐसा कर सकते हैं

 items.ToList().ForEach(i => i.DoStuff()); 

वैकल्पिक रूप से, अपनी खुद की एक्स्टेंशन विधि लिखें:

 public static void ForEach<T>(this IEnumerable<T> enumeration, Action<T> action) { foreach(T item in enumeration) { action(item); } } 

फ्रेड्रिक ने ठीक प्रदान किया है, लेकिन यह इस पर विचार करने के योग्य हो सकता है कि यह क्यों शुरू करने के लिए ढांचे में नहीं है। मेरा मानना ​​है कि यह विचार है कि LINQ क्वेरी ऑपरेटरों को साइड-इफेक्ट-फ्री होना चाहिए, दुनिया को देखने का एक उचित रूप से कार्यात्मक तरीका है। स्पष्ट रूप से इसके लिए बिल्कुल विपरीत है – एक विशुद्ध रूप से दुष्प्रभाव आधारित निर्माण।

यह कहना नहीं है कि यह एक बुरी बात है – सिर्फ निर्णय के दार्शनिक कारणों के बारे में सोच रहा है।

7/17/2012 को अपडेट करें: जाहिरा तौर पर सी # 5.0 के रूप में, नीचे उल्लेखित foreach के व्यवहार को बदल दिया गया है और " नेस्टेड लैम्ब्डा अभिव्यक्ति में एक अग्रदूत चलनेवाली चर का उपयोग अब अप्रत्याशित परिणाम उत्पन्न करता है। " यह उत्तर C # ≥ 5.0

@ जॉन स्कीट और जो लोग उपन्यास खोजशब्द पसंद करते हैं

5.0 से पहले सी # में "foreach" के साथ समस्या यह है कि यह अन्य भाषाओं में "समझ के लिए" समकक्ष कैसे काम करता है, और इसके साथ मैं कैसे काम करने की अपेक्षा करता हूं (व्यक्तिगत राय केवल इसलिए कि क्योंकि अन्य लोगों ने उनका उल्लेख किया है पठनीयता के बारे में राय)। " संशोधित बंद करने के लिए पहुंच " से संबंधित सभी प्रश्नों के साथ-साथ " हानिकारक माना जाने वाला पाश चर पर समापन " के रूप में भी देखें। यह केवल "हानिकारक" है क्योंकि जिस तरह से "foreach" सी # में कार्यान्वित किया गया है।

फ्रेडरिक कल्सेथ के उत्तर में कार्यात्मक रूप से समतुल्य एक्स्टेंशन विधि का उपयोग करके निम्नलिखित उदाहरण लें।

 public static class Enumerables { public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action) { foreach (T item in @this) { action(item); } } } 

पीढ़ी अनुचित उदाहरण के लिए माफी। मैं केवल अवलोकन के लिए उपयोग कर रहा हूं क्योंकि यह ऐसा कुछ करने के लिए पूरी तरह से दूर नहीं है। जाहिर है इस नमूना बनाने के लिए बेहतर तरीके हैं, मैं केवल एक बिंदु का प्रदर्शन करने का प्रयास कर रहा हूं। विशेष रूप से देखने के लिए सदस्यता लेने वाला कोड अन्य थ्रेड में एसिंक्रोनस और संभावित रूप से निष्पादित होता है। यदि "विदेशी मुद्रा" का उपयोग करना है, तो यह बहुत अजीब और संभावित गैर-नियतात्मक परिणाम पैदा कर सकता है।

"ForEach" विस्तार विधि का उपयोग कर निम्नलिखित परीक्षण पास:

 [Test] public void ForEachExtensionWin() { //Yes, I know there is an Observable.Range. var values = Enumerable.Range(0, 10); var observable = Observable.Create<Func<int>>(source => { values.ForEach(value => source.OnNext(() => value)); source.OnCompleted(); return () => { }; }); //Simulate subscribing and evaluating Funcs var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList(); //Win Assert.That(evaluatedObservable, Is.EquivalentTo(values.ToList())); } 

निम्न त्रुटि के साथ विफल रहता है:

अपेक्षित: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9> के बराबर था: <9, 9, 9, 9, 9, 9, 9, 9, 9, 9>

 [Test] public void ForEachKeywordFail() { //Yes, I know there is an Observable.Range. var values = Enumerable.Range(0, 10); var observable = Observable.Create<Func<int>>(source => { foreach (var value in values) { //If you have resharper, notice the warning source.OnNext(() => value); } source.OnCompleted(); return () => { }; }); //Simulate subscribing and evaluating Funcs var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList(); //Fail Assert.That(evaluatedObservable, Is.EquivalentTo(values.ToList())); } 

आप FirstOrDefault() एक्सटेंशन का उपयोग कर सकते हैं, जो कि IEnumerable<T> लिए उपलब्ध है। गड़बड़ी से false लौटने से, यह प्रत्येक तत्व के लिए चलाया जाएगा, परन्तु इसकी परवाह नहीं होगी कि यह वास्तव में एक मैच नहीं मिल रहा है। यह ToList() ओवरहेड से बचना होगा।

 IEnumerable<Item> items = GetItems(); items.FirstOrDefault(i => { i.DoStuff(); return false; }); 

मैंने फ्रेड्रिक की विधि ली और वापसी के प्रकार को संशोधित किया।

इस प्रकार, विधि अन्य LINQ तरीकों जैसे स्थगित निष्पादन का समर्थन करता है।

संपादित करें: यदि यह स्पष्ट नहीं था, तो इस पद्धति का कोई भी उपयोग टूलिस्ट () या किसी अन्य तरीके से समाप्त करने के लिए विधि को पूरी गणनायोग्य पर काम करने के लिए बाध्य होना चाहिए । अन्यथा, कार्रवाई नहीं की जाएगी!

 public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action) { foreach (T item in enumeration) { action(item); yield return item; } } 

और यह देखने में मदद करने के लिए यहां परीक्षा है:

 [Test] public void TestDefferedExecutionOfIEnumerableForEach() { IEnumerable<char> enumerable = new[] {'a', 'b', 'c'}; var sb = new StringBuilder(); enumerable .ForEach(c => sb.Append("1")) .ForEach(c => sb.Append("2")) .ToList(); Assert.That(sb.ToString(), Is.EqualTo("121212")); } 

यदि आप अंत में ToList () को निकालते हैं , तो आप देखेंगे कि परीक्षा में विफल होने के बाद StringBuilder में एक खाली स्ट्रिंग है। यह इसलिए है क्योंकि कोई भी विधि ने गणना करने के लिए ForEach को मजबूर नहीं किया है

अपने IEnumerable से बाहर अपने साइड इफेक्ट्स रखें

मैं निम्नलिखित के बराबर LINQ में करना चाहता हूं, लेकिन मैं यह नहीं समझ सकता कि कैसे:

जैसा कि अन्य लोगों ने यहां और विदेशों में बताया है, LINQ और IEnumerable तरीकों से दुष्प्रभाव मुक्त होने की उम्मीद है

क्या आप वास्तव में IEnumerable में प्रत्येक आइटम के लिए "कुछ करना" चाहते हैं? फिर foreach सबसे अच्छा विकल्प है साइड-इफेक्ट्स होने पर लोगों को आश्चर्यचकित नहीं किया जाता है।

 foreach (var i in items) i.DoStuff(); 

मुझे यकीन है आप पक्ष-प्रभाव नहीं चाहते हैं

हालांकि मेरे अनुभव पक्ष प्रभावों में आम तौर पर आवश्यक नहीं हैं ज़्यादातर नहीं, एक सरल LINQ क्वेरी है जो कि या तो जॉन स्कीट, एरिक लिपर, या मार्क ग्रेवेल द्वारा एक स्टैक ओवरफ्लो.ओ कॉम के साथ खोज की जाने की प्रतीक्षा कर रही है, जिससे आपको क्या करना है, यह समझाया जा सकता है!

कुछ उदाहरण

यदि आप वास्तव में केवल कुछ मान एकत्र कर रहे हैं तो आपको Aggregate विस्तार विधि पर विचार करना चाहिए।

 items.Aggregate(initial, (acc, x) => ComputeAccumulatedValue(acc, x)); 

शायद आप मौजूदा मानों से एक नया IEnumerable बनाना चाहते हैं।

 items.Select(x => Transform(x)); 

या हो सकता है कि आप एक नज़र-अप तालिका बनाना चाहते हैं:

 items.ToLookup(x, x => GetTheKey(x)) 

संभावनाओं की सूची (पूर्णतः अभिप्रेत नहीं है) आगे बढ़ जाती है

यदि आप IQueryable <T> को IEnumerable <टी> की बजाय उपयोग कर सकते हैं, तो चयन विधि को आप क्या करना चाहिए।

 IQueryable<Item> items = GetItems(); IQueryable<Item> modifiedItems = items.Select(i => i.DoStuff()); 

यद्यपि मार्टिन हैरिस बताते हैं, जब तक आप संग्रह का वर्णन नहीं करते, तब तक चयन () का मूल्यांकन नहीं किया जाएगा, इसलिए यदि आप कुछ दुष्परिणाम करने के लिए DoStuff () पर निर्भर हैं, तो आप कुछ तरह से बेहतर हैं

 var modifiedItems = items.Select(i => i.DoStuff()).ToList() 

LINQ की चयन विधि में वास्तव में एसक्यूएल खोज कीवर्ड के साथ कुछ भी नहीं है; यह क्या करता है एक सेट में प्रत्येक तत्व के लिए एक फ़ंक्शन लागू होता है, और उन कार्यों के परिणाम वाले एक (आलसी-मूल्यांकन!) सेट को वापस लौटाता है

माइक्रोसॉफ्ट ऑफ इंटरैक्टिव एक्स्टेंशन्स द्वारा LINQ के लिए एक प्रयोगात्मक रिलीज ( न्यूगेट पर भी, अधिक लिंक के लिए RxTeams प्रोफ़ाइल देखें)। चैनल 9 वीडियो यह अच्छी तरह बताता है

इसके डॉक्स केवल XML प्रारूप में उपलब्ध कराए जाते हैं। मैंने यह दस्तावेज सैंडकैसल में चलाया है ताकि इसे और अधिक पठनीय प्रारूप में शामिल किया जा सके। डॉक्स संग्रह को अनझिप करें और index.html देखें

कई अन्य गुड्स में, यह अपेक्षित फोरेअक कार्यान्वयन प्रदान करता है। यह आपको इस तरह कोड लिखने की अनुमति देता है:

 int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 }; numbers.ForEach(x => Console.WriteLine(x*x)); 

PLINQ के अनुसार (नेट 4.0 से उपलब्ध है), आप एक कर सकते हैं

 IEnumerable<T>.AsParallel().ForAll() 

एक IEnumerable पर समानांतर foreach लूप करने के लिए

ForEach का उद्देश्य साइड इफेक्ट्स का कारण है IEnumerable एक सेट के आलसी गणना के लिए है।

जब आप इस पर विचार करते हैं, तो यह वैचारिक अंतर काफी दिखाई देता है।

SomeEnumerable.ForEach(item=>DataStore.Synchronize(item));

यह तब तक निष्पादित नहीं होता जब तक कि आप "गिनती" या "toList ()" या उस पर कुछ न करें। यह स्पष्ट रूप से व्यक्त नहीं किया गया है।

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

यदि आप गणक रोल के रूप में कार्य करना चाहते हैं तो आपको प्रत्येक आइटम का उत्पादन करना चाहिए।

 public static class EnumerableExtensions { public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action) { foreach (var item in enumeration) { action(item); yield return item; } } } 

जैसा कि कई उत्तर पहले ही बताते हैं, आप आसानी से इस तरह के एक विस्तार विधियां स्वयं जोड़ सकते हैं हालांकि, अगर आप ऐसा नहीं करना चाहते हैं, हालांकि मुझे बीसीएल में ऐसा कुछ भी नहीं पता है, फिर भी System नेमस्पेस में एक विकल्प है, यदि आपके पास पहले से ही रिएक्टिव एक्सटेंशन का संदर्भ है (और यदि आप डॉन ' टी, आपको होना चाहिए):

 using System.Reactive.Linq; items.ToObservable().Subscribe(i => i.DoStuff()); 

यद्यपि विधि नाम थोड़े भिन्न होते हैं, अंत परिणाम बिल्कुल वही है जिसे आप ढूंढ रहे हैं।

बहुत से लोगों ने इसका उल्लेख किया है, लेकिन मुझे इसे लिखना पड़ा। यह सबसे स्पष्ट / सबसे पठनीय नहीं है?

 IEnumerable<Item> items = GetItems(); foreach (var item in items) item.DoStuff(); 

लघु और सरल (सेंट)

अब हमारे पास विकल्प है …

  ParallelOptions parallelOptions = new ParallelOptions(); parallelOptions.MaxDegreeOfParallelism = 4; #if DEBUG parallelOptions.MaxDegreeOfParallelism = 1; #endif Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID)); 

बेशक, यह एक पूरी तरह से नए धागे की बूंद खोल सकता है।

ps (फोंट के बारे में क्षमा करें, सिस्टम का निर्णय क्या है)

जॉन स्कीट द्वारा प्रेरित, मैंने निम्नलिखित के साथ उनका समाधान बढ़ाया है:

एक्सटेंशन विधि:

 public static void Execute<TSource, TKey>(this IEnumerable<TSource> source, Action<TKey> applyBehavior, Func<TSource, TKey> keySelector) { foreach (var item in source) { var target = keySelector(item); applyBehavior(target); } } 

ग्राहक:

 var jobs = new List<Job>() { new Job { Id = "XAML Developer" }, new Job { Id = "Assassin" }, new Job { Id = "Narco Trafficker" } }; jobs.Execute(ApplyFilter, j => j.Id); 

। । ।

  public void ApplyFilter(string filterId) { Debug.WriteLine(filterId); } 

मैं इस संबंध से पूरी तरह असहमत हूं कि लिंक एक्सटेंशन के तरीकों को साइड-इफेक्ट मुक्त (न केवल इसलिए कि वे नहीं हैं, कोई भी प्रतिनिधि साइड इफेक्ट कर सकता है)।

निम्नलिखित को धयान मे रखते हुए:

  public class Element {} public Enum ProcessType { This = 0, That = 1, SomethingElse = 2 } public class Class1 { private Dictionary<ProcessType, Action<Element>> actions = new Dictionary<ProcessType,Action<Element>>(); public Class1() { actions.Add( ProcessType.This, DoThis ); actions.Add( ProcessType.That, DoThat ); actions.Add( ProcessType.SomethingElse, DoSomethingElse ); } // Element actions: // This example defines 3 distict actions // that can be applied to individual elements, // But for the sake of the argument, make // no assumption about how many distict // actions there may, and that there could // possibly be many more. public void DoThis( Element element ) { // Do something to element } public void DoThat( Element element ) { // Do something to element } public void DoSomethingElse( Element element ) { // Do something to element } public void Apply( ProcessType processType, IEnumerable<Element> elements ) { Action<Element> action = null; if( ! actions.TryGetValue( processType, out action ) ) throw new ArgumentException("processType"); foreach( element in elements ) action(element); } } 

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

यदि आप इस तरह से कर रहे हैं क्योंकि आपको अपने पुनरावृत्ति में सूचकांक की आवश्यकता है, तो आप हमेशा जहां का निर्माण कर सकते हैं:

 linqObject.Where((obj, index) => { DoWork(obj, index); return true; }).ToArray(); //MUST CALL ToArray() or ToList() or something to execute the lazy query, or the loop won't actually execute 

इसका अतिरिक्त लाभ है कि मूल सरणी को "अपरिवर्तित" (सूची द्वारा संदर्भित वस्तुओं समान हैं, हालांकि वे एक ही डेटा नहीं हो सकते हैं), जो कि अक्सर LINQ जैसे कार्यात्मक / श्रृंखला प्रोग्रामिंग विधियों में अपेक्षित होता है।

यह "कार्यात्मक दृष्टिकोण" अमूर्त बड़ा समय लीक करता है भाषा के स्तर पर कुछ भी साइड इफेक्ट्स को रोकता है। जब तक आप कंटेनर में प्रत्येक तत्व के लिए अपने लम्ब्डा / प्रतिनिधि को कॉल कर सकते हैं – आप "फॉर ईका" व्यवहार प्राप्त करेंगे।

उदाहरण के लिए, एक तरह से srcDictionary को destDictionary में विलीन करने का एक तरीका (यदि कुंजी पहले से मौजूद है – ओवरराइट)

यह एक हैक है, और किसी भी उत्पादन कोड में उपयोग नहीं किया जाना चाहिए।

 var b = srcDictionary.Select( x=> { destDictionary[x.Key] = x.Value; return true; } ).Count(); 

VB.NET के लिए आपको उपयोग करना चाहिए:

 listVariable.ForEach(Sub(i) i.Property = "Value") 

के लिए हर भी जंजीर किया जा सकता है, बस कार्रवाई के बाद pileline वापस डाल दिया। धारदार रहें


 Employees.ForEach(e=>e.Act_A) .ForEach(e=>e.Act_B) .ForEach(e=>e.Act_C); Orders //just for demo .ForEach(o=> o.EmailBuyer() ) .ForEach(o=> o.ProcessBilling() ) .ForEach(o=> o.ProcessShipping()); //conditional Employees .ForEach(e=> { if(e.Salary<1000) e.Raise(0.10);}) .ForEach(e=> { if(e.Age >70 ) e.Retire();}); 

 public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enu, Action<T> action) { foreach (T item in enu) action(item); return enu; // make action Chainable/Fluent } 

कोड के ऊपर 2 संपादित करें काम कर रहा है, लेकिन एक बेहतर संस्करण इस का उपयोग कर रहा है ।

नीचे संपादित करें एक गलत उदाहरण था, ताइमर ने बताया। बहुत धन्यवाद

 Employees.ForEach(e=>e.Salary = e.Salary * 2) .Where (e=> e.Salary > 10000) .Average(e=> e.Salary); 

मैं सोच रहा हूं कि अभी तक प्रतिनिधियों के काम का उपयोग क्यों नहीं किया है? मेरे कोडिंग में मैं इसे एक सूची के पुनरावृत्त पर निष्पादित करने के लिए एक सबरूटीन का प्रतिनिधित्व करने का एक अधिक स्पष्ट और संक्षिप्त तरीका खोजता हूं।

नोट: अनुभव से, मैं हमेशा तीलिस्ट () का उपयोग करने के लिए सुझाव देता हूं कि इंडेक्सिंग के साथ किसी भी मुद्दे से बचने के लिए यदि आपकी मूल सूची में बदलाव होता है, तो नीचे दिए गए उदाहरण देखें:

  public class MyObject { public string MyString; public int MyInt; } List<MyObject> list = new List<MyObject> { new MyObject { MyString = "Test1", MyInt = 1970 }, new MyObject { MyString = "Test2", MyInt = 2010 }, new MyObject { MyString = "Test3", MyInt = 2011 }, new MyObject { MyString = "Test4", MyInt = 1767 } }; // simple filter, but notice the Remove() will work with ToList(), remove ToList() // and the statement will fail on execution list.ToList().ForEach( delegate(MyObject item) { if (item.MyInt > 1999) list.Remove(item); } ); 

अभी तक एक और उदाहरण के लिए

 public static IList<AddressEntry> MapToDomain(IList<AddressModel> addresses) { var workingAddresses = new List<AddressEntry>(); addresses.Select(a => a).ToList().ForEach(a => workingAddresses.Add(AddressModelMapper.MapToDomain(a))); return workingAddresses; }