Wie entferne ich ein einzelnes bestimmtes Objekt aus einem ConcurrentBag <>?

Mit dem neuen ConcurrentBag<T>in .NET 4, wie entfernen Sie ein bestimmtes, spezifisches Objekt aus ihm , wenn nur TryTake()und TryPeek()verfügbar sind?

Ich denke darüber nach TryTake(), das resultierende Objekt zu verwenden und es dann wieder in die Liste aufzunehmen, wenn ich es nicht entfernen möchte, aber ich habe das Gefühl, dass mir etwas fehlt. Ist das der richtige Weg?

Die kurze Antwort: Sie können es nicht einfach machen.

Das ConcurrentBag führt für jeden Thread eine lokale Thread-Warteschlange und überprüft die Warteschlangen anderer Threads erst, wenn die eigene Warteschlange leer ist. Wenn Sie ein Element entfernen und zurücklegen, ist das nächste Element, das Sie entfernen, möglicherweise wieder dasselbe Element. Es gibt keine Garantie dafür, dass Sie durch wiederholtes Entfernen und Zurücksetzen von Elementen alle Elemente durchlaufen können.

Zwei Alternativen für Sie:

• Entfernen Sie alle Elemente und merken Sie sich diese, bis Sie das Element gefunden haben, das Sie entfernen möchten, und setzen Sie die anderen anschließend wieder ein. Beachten Sie, dass Probleme auftreten, wenn zwei Threads dies gleichzeitig versuchen.
• Verwenden Sie eine geeignetere Datenstruktur wie ConcurrentDictionary .

Das kannst du nicht. Es ist eine Tasche, es wird nicht bestellt. Wenn Sie es zurücklegen, bleiben Sie einfach in einer Endlosschleife stecken.

Du willst ein Set. Sie können eine mit ConcurrentDictionary emulieren. Oder ein HashSet, das Sie mit einem Schloss schützen.

Die ConcurrentBag eignet sich hervorragend für die Verarbeitung einer Liste, in der Sie Elemente hinzufügen und aus vielen Threads aufzählen und sie schließlich wegwerfen können, wie der Name schon sagt :)

Wie Mark Byers sagte , können Sie eine neue ConcurrentBag neu erstellen, die nicht das Element enthält, das Sie entfernen möchten. Sie müssen dies jedoch mit einer Sperre vor mehreren Thread-Treffern schützen. Dies ist ein Einzeiler:

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

Dies funktioniert und entspricht dem Geist, für den die ConcurrentBag entwickelt wurde.

Mark ist insofern richtig, als das ConcurrentDictionary so funktioniert, wie Sie es möchten. Wenn Sie weiterhin eine ConcurrentBag verwenden möchten , werden Sie mit den folgenden, nicht effizienten, wohlgemerkt dorthin gebracht.

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);
}

Wie Sie bereits erwähnt haben, TryTake()ist dies die einzige Option. Dies ist auch das Beispiel für MSDN . Der Reflektor zeigt auch keine anderen versteckten internen Methoden von Interesse.

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);
    }

}

Dies ist meine Erweiterungsklasse, die ich in meinen Projekten verwende. Es kann einen einzelnen Artikel aus ConcurrentBag entfernen und auch eine Liste von Artikeln aus der Tasche entfernen

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);
        }
    }
}

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;
}

wie wäre es mit:

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

Es funktioniert, ich bin mir nicht sicher, wie effizient ...