¿Cómo eliminar un único objeto específico de un ConcurrentBag <>?

Con lo nuevo ConcurrentBag<T>en .NET 4, ¿cómo se elimina un determinado objeto específico cuando solo TryTake()y TryPeek()están disponibles?

Estoy pensando en usar TryTake()y luego agregar el objeto resultante nuevamente a la lista si no quiero eliminarlo, pero siento que me falta algo. ¿Es esta la forma correcta?

La respuesta corta: no puedes hacerlo de una manera fácil.

ConcurrentBag mantiene una cola local de subprocesos para cada subproceso y solo mira las colas de otros subprocesos una vez que su propia cola se vacía. Si quita un elemento y lo vuelve a colocar, el siguiente elemento que elimine puede ser el mismo elemento nuevamente. No hay garantía de que quitar elementos repetidamente y volver a colocarlos le permitirá iterar sobre todos los elementos.

Dos alternativas para ti:

• Elimine todos los elementos y recuérdelos hasta que encuentre el que desea eliminar, luego vuelva a colocar los demás. Tenga en cuenta que si dos subprocesos intentan hacer esto simultáneamente, tendrá problemas.
• Utilice una estructura de datos más adecuada, como ConcurrentDictionary .

No puedes. Es una bolsa, no está ordenada. Cuando lo vuelvas a poner, te quedarás atrapado en un bucle sin fin.

Quieres un set. Puede emular uno con ConcurrentDictionary. O un HashSet que te proteges con un candado.

El ConcurrentBag es excelente para manejar una lista donde puede agregar elementos y enumerar de muchos subprocesos, y luego desecharlo como sugiere su nombre :)

Como dijo Mark Byers , puede reconstruir un nuevo ConcurrentBag que no contenga el elemento que desea eliminar, pero debe protegerlo contra múltiples subprocesos usando un candado. Este es un resumen:

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

Esto funciona y coincide con el espíritu para el que se ha diseñado ConcurrentBag.

Mark tiene razón en que el ConcurrentDictionary funcionará de la manera que usted desea. Si aún desea usar un ConcurrentBag, lo siguiente, no eficiente, lo llevará allí.

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

Como mencionas, TryTake()es la única opción. Este es también el ejemplo en MSDN . Reflector tampoco muestra otros métodos internos ocultos de interés.

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

}

Esta es mi clase de extensión que estoy usando en mis proyectos. Puede eliminar un solo artículo de ConcurrentBag y también puede eliminar la lista de artículos de la bolsa

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

qué tal si:

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

Funciona, no estoy seguro de cuán eficientemente ...