Comment supprimer un seul objet spécifique d'un ConcurrentBag <>?

Avec le nouveau ConcurrentBag<T>dans 4 .NET, comment vous supprimez un certain objet spécifique de celui - ci quand seulement TryTake()et TryPeek()sont disponibles?

Je pense utiliser TryTake()puis simplement ajouter l'objet résultant dans la liste si je ne veux pas le supprimer, mais j'ai l'impression qu'il me manque peut-être quelque chose. C'est la bonne route?

La réponse courte: vous ne pouvez pas le faire de manière simple.

Le ConcurrentBag conserve une file d'attente locale pour chaque thread et il ne regarde que les files des autres threads une fois que sa propre file d'attente est vide. Si vous supprimez un élément et le remettez en place, l'élément suivant que vous supprimez peut être à nouveau le même. Il n'y a aucune garantie que la suppression répétée d'éléments et leur remise en place vous permettront d'itérer sur tous les éléments.

Deux alternatives pour vous:

• Supprimez tous les éléments et mémorisez-les jusqu'à ce que vous trouviez celui que vous souhaitez supprimer, puis remettez les autres en place par la suite. Notez que si deux threads essaient de faire cela simultanément, vous aurez des problèmes.
• Utilisez une structure de données plus appropriée, telle que ConcurrentDictionary .

Vous ne pouvez pas. C'est un sac, il n'est pas commandé. Lorsque vous le remettrez, vous resterez coincé dans une boucle sans fin.

Vous voulez un ensemble. Vous pouvez en émuler un avec ConcurrentDictionary. Ou un HashSet que vous vous protégez avec un verrou.

Le ConcurrentBag est idéal pour gérer une liste où vous pouvez ajouter des éléments et énumérer à partir de nombreux threads, puis finalement le jeter comme son nom l'indique :)

Comme Mark Byers l'a dit , vous pouvez reconstruire un nouveau ConcurrentBag qui ne contient pas l'élément que vous souhaitez supprimer, mais vous devez le protéger contre les hits de plusieurs threads à l'aide d'un verrou. C'est un one-liner:

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

Cela fonctionne et correspond à l'esprit dans lequel le ConcurrentBag a été conçu.

Mark a raison en ce que le ConcurrentDictionary fonctionnera comme vous le souhaitez. Si vous souhaitez continuer à utiliser un ConcurrentBag , ce qui n'est pas efficace vous y conduira.

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

Comme vous le mentionnez, TryTake()c'est la seule option. C'est également l'exemple sur MSDN . Reflector ne montre pas non plus d'autres méthodes internes cachées d'intérêt.

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

}

C'est ma classe d'extension que j'utilise dans mes projets. Il peut supprimer un seul article de ConcurrentBag et peut également supprimer la liste des articles du sac

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

que diriez-vous:

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

Cela fonctionne, je ne sais pas avec quelle efficacité ...