C#: Supprimer les valeurs en double à partir du dictionnaire?

Comment puis-je créer un dictionnaire sans dupliquer les valeurs d'un dictionnaire qui peuvent avoir des valeurs en double?

IDictionary<string, string> myDict = new Dictionary<string, string>();

myDict.Add("1", "blue");
myDict.Add("2", "blue");
myDict.Add("3", "red");
myDict.Add("4", "green");


uniqueValueDict = myDict.???

Edit:

-Je n'ai pas de soins qui touche est maintenue.
- Est-il quelque chose à l'aide Distinctes() opération?

La clé voulez-vous garder? "1", "2", ou pas du tout?
Je pense que vous avez besoin de donner plus d'informations sur le comportement de l'unique prise de fonction. Pour le bleu, sur quelle touche faut-il garder, 1 ou 2?
http://www.codeproject.com/KB/linq/Unique.aspx

InformationsquelleAutor User | 2009-09-22

.net-3.5 c#dictionary linq

48

Que voulez-vous faire avec les doublons? Si vous n'avez pas l'esprit qui vous perdre, tout simplement construire un autre dictionnaire comme ceci:
```
IDictionary<string, string> myDict = new Dictionary<string, string>();

myDict.Add("1", "blue");
myDict.Add("2", "blue");
myDict.Add("3", "red");
myDict.Add("4", "green");

HashSet<string> knownValues = new HashSet<string>();
Dictionary<string, string> uniqueValues = new Dictionary<string, string>();

foreach (var pair in myDict)
{
    if (knownValues.Add(pair.Value))
    {
        uniqueValues.Add(pair.Key, pair.Value);
    }
}
```
Qui suppose que vous utilisez .NET 3.5, certes. Laissez-moi savoir si vous avez besoin d'un .NET 2.0 solution.

Voici une LINQ solution je trouve agréablement compact...
```
var uniqueValues = myDict.GroupBy(pair => pair.Value)
                         .Select(group => group.First())
                         .ToDictionary(pair => pair.Key, pair => pair.Value);
```
- Wow Jon, vous presque cassé le 100K marque 🙂
- Ne sait-il peu après 100K revient en boucle à 0, ruuhaha
- Merci. Le linq solution est ce que je cherchais. Curieux pourrait vous en quelque sorte d'utiliser les différentes méthode d'extension?
- Je ne pense pas que Distincte permettrait de les aider dans ce cas... DistinctBy de MoreLINQ serait bien.
- Le LINQ méthode ne fonctionne pas dans tous les situtions. Dictionnaire jeux ne vous autorise pas à appeler le .GroupBy() la méthode.
- Pourriez-vous donner plus de détails? Qu'entendez-vous par "le dictionnaire définit"?
- Je ne suis pas sûr exactement. Je suis en tirant une ObservableCollection de imbriquée usercontrol et il ne me permet pas de l'utiliser .Distinctes ou .Sélectionnez et ainsi de suite. J'ai même essayé de conversion que pour un Dictionnaire/IDictionary et puis essayer d'obtenir l'distinctes. Cela encore n'a pas fonctionné. J'ai fini par faire une boucle foreach sur chaque élément, puis en utilisant le hashset pour obtenir détecter si c'est un doublon. Ensuite, j'ai créé le nouveau comboboxitems (projet silverlight) et les ajouter à la zone de liste déroulante. Cette a été .Net 4/Silverlight 4. Alors que la méthode LINQ aurait été idéal, je suis juste de la chance que votre autre méthode a fonctionné
- Il y a plusieurs raisons à cela, mais il est difficile de se plonger dans les dans les commentaires. Veuillez commencer une nouvelle question, et de donner plus de détails. Par exemple, assurez-vous que vous avez une référence à System.Core.dll et une aide de la directive pour le Système.Linq. Aussi, est-ce le générique ObservableCollection<T> ou un nongeneric collection?
- ouais...j'ai oublié de Système de référence.Linq. Je devrais avoir su mieux. Merci pour votre aide!
InformationsquelleAutor Jon Skeet
7

La force brute solution serait quelque chose comme ce qui suit
```
var result = dictionary
    .GroupBy(kvp => kvp.Value)
    .ToDictionary(grp => grp.First().Value, grp.Key)
```
en supposant que vous n'avez pas vraiment à la clé utilisée pour représenter un groupe de doublons et il est acceptable pour reconstruire le dictionnaire.
- J'ai essayé d'imaginer linq-comme solution mais je n'avais pas VS au bout de mes doigts. +1 pour concrétiser cette approche 😉
- Je ne suis pas sûr que même s'il compile ... va juste le feu jusqu'à VS et de le tester...
- Ne compile pas parce que j'ai raté .Valeur après le Premier appel, mais il fixe.
- Cela n'a pas fonctionné pour moi. Il a créé un dictionnaire avec la "valeur" comme à la fois la clé et la valeur.
- Cela produit un dictionnaire avec les valeurs de la clé et de la valeur! 🙁
InformationsquelleAutor Daniel Brückner

Jon me battre pour le .NET 3.5 solution, mais cela devrait fonctionner si vous avez besoin d'un .NET 2.0 solution:

        List<string> vals = new List<string>();
        Dictionary<string, string> newDict = new Dictionary<string, string>();
        foreach (KeyValuePair<string, string> item in myDict)
        {
            if (!vals.Contains(item.Value))
            {
                newDict.Add(item.Key, item.Value);
                vals.Add(item.Value);
            }
        }

InformationsquelleAutor Timothy Carter

foreach (var key in mydict.Keys)
  tempdict[mydict[key]] = key;
foreach (var value in tempdict.Keys)
  uniquedict[tempdict[value]] = value;

InformationsquelleAutor queen3

Dictionary<string, string> test = new Dictionary<string,string>();
test.Add("1", "blue");
test.Add("2", "blue");
test.Add("3", "green");
test.Add("4", "red");
Dictionary<string, string> test2 = new Dictionary<string, string>();
foreach (KeyValuePair<string, string> entry in test)
{
    if (!test2.ContainsValue(entry.Value))
        test2.Add(entry.Key, entry.Value);
}

InformationsquelleAutor Sivvy

C'est la façon dont je l'ai fait:

                dictionary.add(control, "string1");
                dictionary.add(control, "string1");
                dictionary.add(control, "string2");
              int x = 0;
        for (int i = 0; i < dictionary.Count; i++)
        {         
            if (dictionary.ElementAt(i).Value == valu)
            {
                x++;
            }
            if (x > 1)
            {
                dictionary.Remove(control);
            }
        }

InformationsquelleAutor MILAD

En plus de la réponse de Jon Skeet , si votre valeur est un stagiaire objet que vous pouvez utiliser :

var uniqueValues = myDict.GroupBy(pair => pair.Value.Property)
                     .Select(group => group.First())
                     .ToDictionary(pair => pair.Key, pair => pair.Value);

Cela vous permettra de supprimer les doublons uniquement sur l'une des propriétés de l'objet

InformationsquelleAutor Guillaume V

Juste une note pour ceux qui utilisent le Revit API, c'est une méthode qui fonctionne pour moi en enlevant les éléments en double, lorsque vous ne pouvez pas utiliser le dire wallType que votre type d'objet et la place nécessaire de tirer parti des éléments bruts. c'est une beaut mate.

  //Add Pair.value to known values HashSet
                 HashSet<string> knownValues = new HashSet<string>();

                Dictionary<Wall, string> uniqueValues = new Dictionary<Wall, string>();

                 foreach (var pair in wall_Dict)
                 {
                     if (knownValues.Add(pair.Value))
                     {
                         uniqueValues.Add(pair.Key, pair.Value);
                     }
                 }

InformationsquelleAutor frank jock halliday

Vous devez vous connecter pour publier un commentaire.