Meilleur moyen de supprimer plusieurs éléments correspondant à un prédicat dans un dictionnaire .NET ?

Question

Je dois supprimer plusieurs éléments d'un dictionnaire. Une façon simple de le faire est la suivante :

  List<string> keystoremove= new List<string>();
  foreach (KeyValuePair<string,object> k in MyCollection)
     if (k.Value.Member==foo)
        keystoremove.Add(k.Key);
  foreach (string s in keystoremove)
        MyCollection.Remove(s);

La raison pour laquelle je ne peux pas supprimer directement les éléments dans le bloc foreach est que cela entraînerait une exception ("La collection a été modifiée...").

Je voudrais faire ce qui suit :

 MyCollection.RemoveAll(x =>x.Member==foo)

Mais la classe Dictionary<> n'expose pas une méthode RemoveAll(Predicate<> Match), comme le fait la classe List<>.

Quelle est la meilleure façon (à la fois en termes de performances et d'élégance) de le faire ?

Answer 1

Voici une autre façon de procéder

foreach ( var s in MyCollection.Where(kv => kv.Value.Member == foo).ToList() ) {
  MyCollection.Remove(s.Key);
}

Le fait de placer le code directement dans une liste permet d'éviter le problème de "suppression pendant l'énumération". Le site .ToList() forcera l'énumération avant que le foreach ne commence vraiment.

Answer 2

Vous pouvez créer un méthode d'extension :

public static class DictionaryExtensions
{
    public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> dict, 
        Func<TValue, bool> predicate)
    {
        var keys = dict.Keys.Where(k => predicate(dict[k])).ToList();
        foreach (var key in keys)
        {
            dict.Remove(key);
        }
    }
}

...

dictionary.RemoveAll(x => x.Member == foo);

Answer 3

Au lieu de supprimer, faites simplement l'inverse. Créez un nouveau dictionnaire à partir de l'ancien, contenant uniquement les éléments qui vous intéressent.

public Dictionary<T, U> NewDictionaryFiltered<T, U>
(
  Dictionary<T, U> source,
  Func<T, U, bool> filter
)
{
return source
  .Where(x => filter(x.Key, x.Value))
  .ToDictionary(x => x.Key, x => x.Value);
}

Answer 4

Version modifiée de la solution de la méthode d'extension d'Aku. La principale différence est qu'elle permet au prédicat d'utiliser la clé du dictionnaire. Une différence mineure est qu'elle étend IDictionary plutôt que Dictionary.

public static class DictionaryExtensions
{
    public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> dic,
        Func<TKey, TValue, bool> predicate)
    {
        var keys = dic.Keys.Where(k => predicate(k, dic[k])).ToList();
        foreach (var key in keys)
        {
            dic.Remove(key);
        }
    }
}

. . .

dictionary.RemoveAll((k,v) => v.Member == foo);

Answer 5

L'amélioration de Jérôme par rapport à la méthode d'Aku est bonne. Cependant, elle avait besoin d'une mise au point critique. J'ai soumis le code modifié. J'espère qu'il sera affiché bientôt, mais le voici pour référence :

.......

var keyValuePairs = dic.Where(predicate).ToList();
            foreach (var kvp in keyValuePairs)

.......

Le reste du code est correct.