मैं समानांतर से वापसी मूल्य कैसे एकत्र करूं? ForEach?

Question

मैं समानांतर में एक धीमी webservice कॉल कर रहा हूँ। हालात तब तक महान थे जब तक मुझे एहसास हुआ कि मुझे सेवा से कुछ जानकारी वापस लेने की जरूरत है। लेकिन मुझे नहीं लगता कि मूल्यों को वापस कहां प्राप्त करें। मैं डेटाबेस में नहीं लिख सकता, HttpContext.Current समानांतर का उपयोग करने वाली विधि के अंदर शून्य दिखाई देता है। फोरेच

नीचे एक नमूना प्रोग्राम है (आपके दिमाग में, कृपया स्ट्रिंग कॉन्सटेनेशन की बजाय धीमी वेब सेवा की कल्पना करें)

using System; 
using System.Threading.Tasks; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     WordMaker m = new WordMaker(); 
     m.MakeIt(); 
    } 
    public class WordMaker 
    { 
     public void MakeIt() 
     { 
      string[] words = { "ack", "ook" }; 
      ParallelLoopResult result = Parallel.ForEach(words, word => AddB(word)); 
      Console.WriteLine("Where did my results go?"); 
      Console.ReadKey(); 
     } 
     public string AddB(string word) 
     { 
      return "b" + word; 
     } 
    } 

} 

Answer 1

आपने इसे यहां छोड़ दिया है।

ParallelLoopResult result = Parallel.ForEach(words, word => AddB(word)); 

आप शायद कुछ की तरह चाहते हैं,

ParallelLoopResult result = Parallel.ForEach(words, word => 
{ 
    string result = AddB(word); 
    // do something with result 
}); 

आप इस के अंत में संग्रह के कुछ प्रकार चाहते हैं, System.Collections.Concurrent के तहत संग्रह में से एक का उपयोग कर, ConcurrentBag

var resultCollection = new ConcurrentBag<string>(); 
ParallelLoopResult result = Parallel.ForEach(words, word => 
{ 
    resultCollectin.Add(AddB(word)); 
}); 

// Do something with result 

Answer 2

पर विचार

परिणाम एकत्र करने के लिए ConcurrentBag का उपयोग न करें क्योंकि यह बेहद धीमा है। इसके बजाए स्थानीय लॉक का उपयोग करें।

var resultCollection = new List<string>(); 
object localLockObject = new object(); 

Parallel.ForEach<string, List<string>>(
     words, 
    () => { return new List<string>(); }, 
     (word, state, localList) => 
     { 
     localList.Add(AddB(word)); 
     return localList; 
     }, 
     (finalResult) => { lock (localLockObject) resultCollection.AddRange(finalResult); } 
); 

// Do something with resultCollection here 

Answer 3

कैसे कुछ इस तरह के बारे में:

public class WordContainer 
{ 
    public WordContainer(string word) 
    { 
     Word = word; 
    } 

    public string Word { get; private set; } 
    public string Result { get; set; } 
} 

public class WordMaker 
{ 
    public void MakeIt() 
    { 
     string[] words = { "ack", "ook" }; 
     List<WordContainer> containers = words.Select(w => new WordContainer(w)).ToList(); 

     Parallel.ForEach(containers, AddB); 

     //containers.ForEach(c => Console.WriteLine(c.Result)); 
     foreach (var container in containers) 
     { 
      Console.WriteLine(container.Result); 
     } 

     Console.ReadKey(); 
    } 

    public void AddB(WordContainer container) 
    { 
     container.Result = "b" + container.Word; 
    } 
} 

मेरा मानना ​​है कि जब तक आप एक दूसरे के (के साथ बातचीत करने की जरूरत है परिणाम ताला या समवर्ती वस्तुओं आवश्यक नहीं है जैसे आप एक राशि की गणना कर रहे थे या संयोजन सभी शब्द)। इस मामले में फॉरएच आपकी मूल सूची को अच्छी तरह से तोड़ देता है और प्रत्येक थ्रेड को अपने स्वयं के ऑब्जेक्ट को हाथ से रखता है कि यह अन्य धागे के साथ हस्तक्षेप करने के बारे में चिंता किए बिना सभी चीजों को कुशल बना सकता है।

Answer 4

AsParallelIEnumerable की विस्तार विधि का उपयोग करने पर विचार कर सकते हैं, यह आपके लिए समेकन का ख्याल रखेगा और परिणाम एकत्र करेगा।

words.AsParallel().Select(AddB).ToArray()

तुल्यकालन (जैसे ताले या समवर्ती संग्रह है कि ताले का उपयोग करें) आमतौर पर समवर्ती एल्गोरिदम के टोंटी हैं। जितना संभव हो सके सिंक्रनाइज़ेशन से बचने के लिए सबसे अच्छा है। मुझे लगता है कि AsParallel एक सिंगल थ्रेड पर उत्पादित सभी वस्तुओं को एक स्थानीय गैर-समवर्ती संग्रह में डालने और फिर अंत में इन्हें संयोजन करने जैसे कुछ स्मार्ट का उपयोग करता है।

Answer 5

यह सुरक्षित, तेज, और सरल लगता है:

public string[] MakeIt() { 
     string[] words = { "ack", "ook" }; 
     string[] results = new string[words.Length]; 
     ParallelLoopResult result = 
      Parallel.For(0, words.Length, i => results[i] = AddB(words[i])); 
     return results; 
    }