ConcurrentBag <> से एकल, विशिष्ट ऑब्जेक्ट को कैसे निकालें?

Question

.NET 4 में नए ConcurrentBag<T> के साथ, आप केवल TryTake() और TryPeek() उपलब्ध होने पर एक निश्चित, विशिष्ट ऑब्जेक्ट को कैसे हटाते हैं?

मैं TryTake() का उपयोग करने का सोच रहा हूँ और फिर बस सूची में वापस जिसके परिणामस्वरूप वस्तु जोड़ने अगर मैं नहीं इसे हटाने के लिए चाहते हैं, लेकिन मुझे लगता है कि मैं कुछ कमी हो सकती है। क्या यह सही तरीका है?

Answer 1

संक्षिप्त उत्तर: आप इसे एक आसान तरीके से नहीं कर सकते हैं।

ConcurrentBag प्रत्येक थ्रेड के लिए एक थ्रेड स्थानीय कतार रखता है और यह केवल अपनी धागा खाली होने के बाद अन्य धागे की कतारों को देखता है। यदि आप कोई आइटम हटाते हैं और उसे वापस डाल देते हैं तो आपके द्वारा निकाली जाने वाली अगली वस्तु एक ही आइटम हो सकती है। इस बात की कोई गारंटी नहीं है कि बार-बार वस्तुओं को हटाने और उन्हें वापस रखने से आप सभी वस्तुओं पर पुन: प्रयास कर सकेंगे। आप के लिए

दो विकल्प:

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

Answer 2

जैसा कि आप उल्लेख करते हैं, TryTake() एकमात्र विकल्प है। यह MSDN पर भी उदाहरण है। परावर्तक या तो ब्याज की कोई अन्य छुपी आंतरिक विधियां नहीं दिखाता है।

Answer 3

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

आप एक सेट चाहते हैं। आप ConcurrentDictionary के साथ एक अनुकरण कर सकते हैं। या एक हैशसेट है कि आप अपने आप को ताला से बचाते हैं।

Answer 4

तरीके के बारे में:

bag.Where(x => x == item).Take(1); 

यह काम करता है, मुझे नहीं यकीन है कि कैसे कुशलतापूर्वक ...

Answer 5

public static ConcurrentBag<String> RemoveItemFromConcurrentBag(ConcurrentBag<String> Array, String Item) 
{ 
    var Temp=new ConcurrentBag<String>(); 
    Parallel.ForEach(Array, Line => 
    { 
     if (Line != Item) Temp.Add(Line); 
    }); 
    return Temp; 
} 

Answer 6

ConcurrentBag एक सूची आप आइटम जोड़ने और से गणना कर सकते हैं जहां संभाल करने महान है कर रहा हूँ कई थ्रेड, फिर आखिरकार इसे फेंक दें क्योंकि इसका नाम सुझाव दे रहा है :)

As Mark Byers told, आप एक नया ConcurrentBag फिर से बना सकते हैं जिसमें उस आइटम को शामिल नहीं किया गया है जिसे आप निकालना चाहते हैं, bu आपको लॉक का उपयोग करके कई धागे हिट के खिलाफ इसे सुरक्षित रखना होगा। यह एक लाइनर है:

myBag = new ConcurrentBag<Entry>(myBag.Except(new[] { removedEntry })); 

यह काम करता है, और उस भावना से मेल खाता है जिसमें ConcurrentBag के लिए डिज़ाइन किया गया है।

Answer 7

मार्क सही है कि ConcurrentDictionary इस तरह से काम करेगा जिस तरह आप काम कर रहे हैं। यदि आप अभी भी ConcurrentBag का उपयोग करना चाहते हैं, तो आपको कोई मज़ेदार दिमाग नहीं है, तो आप वहां पहुंच जाएंगे।

var stringToMatch = "test"; 
var temp = new List<string>(); 
var x = new ConcurrentBag<string>(); 
for (int i = 0; i < 10; i++) 
{ 
    x.Add(string.Format("adding{0}", i)); 
} 
string y; 
while (!x.IsEmpty) 
{ 
    x.TryTake(out y); 
    if(string.Equals(y, stringToMatch, StringComparison.CurrentCultureIgnoreCase)) 
    { 
     break; 
    } 
    temp.Add(y); 
} 
foreach (var item in temp) 
{ 
    x.Add(item); 
} 

Answer 8

public static void Remove<T>(this ConcurrentBag<T> bag, T item) 
{ 
    while (bag.Count > 0) 
    { 
     T result; 
     bag.TryTake(out result); 

     if (result.Equals(item)) 
     { 
      break; 
     } 

     bag.Add(result); 
    } 

} 

Answer 9

यह मेरा विस्तार वर्ग जो मैं अपनी परियोजनाओं में उपयोग कर रहा हूँ है। यह एक ConcurrentBag से एक आइटम को हटा सकते हैं और यह भी बैग से आइटम की सूची से हटा सकते हैं

public static class ConcurrentBag 
{ 
    static Object locker = new object(); 

    public static void Clear<T>(this ConcurrentBag<T> bag) 
    { 
     bag = new ConcurrentBag<T>(); 
    } 


    public static void Remove<T>(this ConcurrentBag<T> bag, List<T> itemlist) 
    { 
     try 
     { 
      lock (locker) 
      { 
       List<T> removelist = bag.ToList(); 

       Parallel.ForEach(itemlist, currentitem => { 
        removelist.Remove(currentitem); 
       }); 

       bag = new ConcurrentBag<T>(); 


       Parallel.ForEach(removelist, currentitem => 
       { 
        bag.Add(currentitem); 
       }); 
      } 

     } 
     catch (Exception ex) 
     { 
      Debug.WriteLine(ex.Message); 
     } 
    } 

    public static void Remove<T>(this ConcurrentBag<T> bag, T removeitem) 
    { 
     try 
     { 
      lock (locker) 
      { 
       List<T> removelist = bag.ToList(); 
       removelist.Remove(removeitem);     

       bag = new ConcurrentBag<T>(); 

       Parallel.ForEach(removelist, currentitem => 
       { 
        bag.Add(currentitem); 
       }); 
      } 

     } 
     catch (Exception ex) 
     { 
      Debug.WriteLine(ex.Message); 
     } 
    } 
}