Come rimuovere un singolo oggetto specifico da un ConcurrentBag <>?

Con il nuovo ConcurrentBag<T>in .NET 4, come si rimuove un determinato oggetto specifico da esso quando solo TryTake()e TryPeek()sono disponibili?

Sto pensando di utilizzare TryTake()e quindi aggiungere nuovamente l'oggetto risultante all'elenco se non voglio rimuoverlo, ma mi sento come se mi mancasse qualcosa. È questo il modo corretto?

La risposta breve: non puoi farlo in modo semplice.

Il ConcurrentBag mantiene una coda locale di thread per ogni thread e guarda solo le code degli altri thread quando la sua coda diventa vuota. Se rimuovi un elemento e lo rimetti a posto, l'elemento successivo che rimuovi potrebbe essere di nuovo lo stesso elemento. Non vi è alcuna garanzia che la rimozione ripetuta di elementi e il loro reinserimento ti consentirà di scorrere tutti gli elementi.

Due alternative per te:

• Rimuovi tutti gli elementi e ricordali, finché non trovi quello che desideri rimuovere, quindi rimetti gli altri in seguito. Nota che se due thread tentano di farlo contemporaneamente, avrai problemi.
• Usa una struttura dati più adatta come ConcurrentDictionary .

Non puoi. È una borsa, non è ordinato. Quando lo rimetti a posto, rimarrai bloccato in un ciclo infinito.

Vuoi un set. Puoi emularne uno con ConcurrentDictionary. O un HashSet che ti proteggi con un lucchetto.

Il ConcurrentBag è ottimo per gestire un elenco in cui è possibile aggiungere elementi ed enumerare da molti thread, quindi eventualmente buttarlo via come suggerisce il nome :)

Come ha detto Mark Byers , puoi ricostruire un nuovo ConcurrentBag che non contiene l'oggetto che desideri rimuovere, ma devi proteggerlo da più thread colpi usando un lucchetto. Questa è una battuta:

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

Funziona e corrisponde allo spirito per cui è stato progettato ConcurrentBag.

Mark ha ragione in quanto il ConcurrentDictionary funzionerà nel modo desiderato. Se desideri ancora utilizzare un ConcurrentBag, quanto segue, non è efficiente per te, ti porterà lì.

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

Come dici tu, TryTake()è l'unica opzione. Questo è anche l'esempio su MSDN . Reflector non mostra nemmeno altri metodi interni nascosti di 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);
    }

}

Questa è la mia classe di estensione che sto usando nei miei progetti. Può rimuovere un singolo articolo da ConcurrentBag e può anche rimuovere l'elenco di articoli dalla borsa

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

che ne dite di:

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

Funziona, non sono sicuro di quanto sia efficiente ...