c# - Supprimer des éléments à partir du Dictionnaire<Clé, le Point>

17

Il est plus simple de construire le nouveau Dictionnaire de contenir des éléments qui sont dans la liste:
```
List<string> keysToInclude = new List<string> {"A", "B", "C"};
var newDict = myDictionary
     .Where(kvp=>keysToInclude.Contains(kvp.Key))
     .ToDictionary(kvp=>kvp.Key, kvp=>kvp.Value);
```
Si il est important de modifier le dictionnaire déjà existant (par exemple, c'est une propriété en lecture seule de la classe)
```
var keysToRemove = myDictionary.Keys.Except(keysToInclude).ToList();

foreach (var key in keysToRemove)
     myDictionary.Remove(key);
```
Note le ToList() il est important de matérialiser la liste des clés à supprimer. Si vous essayez d'exécuter le code sans la matérialisation de la keysToRemove, vous aurez probablement à une exception indiquant quelque chose comme "La collecte a changé".

quels seraient les avantages et les inconvénients des deux façons ?
ancien chemin des constructions nouvelles dictionnaire, si vous avez un vieux intact, mais au prix d'une plus grande quantité de mémoire. Plus tard, on modifie existant dictionnaire en place. En un mot, si vous ne travaillez pas sur de vraiment énorme dictionnaires, aucun des avantages et des inconvénients de l'état de programmes ne sont pas équivalentes entre ces deux façons.

OriginalL'auteur J0HN
7
```
//For efficiency with large lists, for small ones use myList below instead.  
var mySet = new HashSet<string>(myList);

//Create a new dictionary with just the keys in the set
myDictionary = myDictionary
               .Where(x => mySet.Contains(x.Key))
               .ToDictionary(x => x.Key, x => x.Value);
```
Ne pensez-vous pas que créer un nouveau dictionnaire peut être inefficace?
Maintenant, c'est une bonne question, ce qui est plus efficace, la création d'un nouveau dictionnaire, ou de prendre un certain nombre d'éléments. Je suppose que ça dépend du nombre de personnes concernées, il serait intéressant de mesurer les choses difficiles.
Voici un test de vitesse que j'ai effectué, votre solution contre le mien. Vous pouvez facilement voir que la création d'un dictionnaire est plus efficace, puisque vous n'avez pas itérer sur mySet pour chaque élément dans le dictionnaire: pastebin.com/iY1LHRM1
Les gens vont arrêter de poster ce lien de manière inappropriée? Ce n'est pas prématuré, et il n'est pas "d'optimisation". L'optimisation est l'endroit où vous prenez le code et le modifier un peu pour qu'il effectue un tout petit peu plus rapide. C'est sur un tout autre algorithme, et vous ne pouvez même pas dire que c'est prématuré, parce que tout ce que j'ai ici est l'OP de la question, je ne suis pas en faisant de son projet.
Ce n'est pas l'optimisation prématurée...

OriginalL'auteur Joachim Isaksson

dict.Keys.Except(list).ToList()
    .ForEach(key => dict.Remove(key));

OriginalL'auteur L.B

Code:

public static void RemoveAll<TKey, TValue>(this Dictionary<TKey, TValue> target,
                                           List<TKey> keys)
{
    var tmp = new Dictionary<TKey, TValue>();

    foreach (var key in keys)
    {
        TValue val;
        if (target.TryGetValue(key, out val))
        {
            tmp.Add(key, val);
        }
    }

    target.Clear();

    foreach (var kvp in tmp)
    {
        target.Add(kvp.Key, kvp.Value);
    }
}

Exemple:

var d = new Dictionary<string, int>
            {
                {"A", 4},
                {"B", 44},
                {"bye", 56},
                {"C", 99},
                {"D", 46},
                {"6672", 0}
            };

var l = new List<string> {"A", "C", "D"};

d.RemoveAll(l);

foreach (var kvp in d)
{
    Console.WriteLine(kvp.Key + ": " + kvp.Value);
}

De sortie:

A: 4
C: 99
D: 46

OriginalL'auteur SimpleVar

Vous devez vous connecter pour publier un commentaire.