Wie zählen der vorkommen der eindeutigen Werte im Wörterbuch?

Das erste, was zu beachten ist, dass Sie nicht wirklich Pflege über die Schlüssel des dictionary. Schritt eins ist daher, ignorieren Sie als irrelevant für die Aufgabe in der hand. Wir arbeiten mit der Values Eigenschaft des Wörterbuchs und die Arbeit ist viel das gleiche wie für jede andere Sammlung von ganzen zahlen (oder in der Tat jede andere zählbare jede andere Art können wir vergleichen für Gleichheit).

Gibt es zwei Allgemeine Ansätze, um dieses problem, die beide die es Wert sind zu wissen.

Die erste verwendet ein anderes Wörterbuch, halten Sie die Zählung der Werte:

//Start with setting up the dictionary you described.
Dictionary<string, int> dict = new Dictionary<string, int>{
    {"key1", 2},
    {"key2", 2},
    {"key3", 3},
    {"key4", 2},
    {"key5", 5},
    {"key6", 5}
};
//Create a different dictionary to store the counts.
Dictionary<int, int> valCount = new Dictionary<int, int>();
//Iterate through the values, setting count to 1 or incrementing current count.
foreach(int i in dict.Values)
    if(valCount.ContainsKey(i))
        valCount[i]++;
    else
        valCount[i] = 1;
//Finally some code to output this and prove it worked:
foreach(KeyValuePair<int, int> kvp in valCount)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", kvp.Key, kvp.Value);

Hoffentlich ist das ziemlich einfach. Ein weiterer Ansatz ist komplizierter, aber hat einige Pluspunkte:

//Start with setting up the dictionary you described.
Dictionary<string, int> dict = new Dictionary<string, int>{
    {"key1", 2},
    {"key2", 2},
    {"key3", 3},
    {"key4", 2},
    {"key5", 5},
    {"key6", 5}
};
IEnumerable<IGrouping<int, int>> grp = dict.Values.GroupBy(x => x);
//Two options now. One is to use the results directly such as with the
//equivalent code to output this and prove it worked:
foreach(IGrouping<int, int> item in grp)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", item.Key, item.Count());
//Alternatively, we can put these results into another collection for later use:
Dictionary<int, int> valCount = grp.ToDictionary(g => g.Key, g => g.Count());
//Finally some code to output this and prove it worked:
foreach(KeyValuePair<int, int> kvp in valCount)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", kvp.Key, kvp.Value);

(Wir würden wahrscheinlich verwenden var anstatt der ausführlichen IEnumerable<IGrouping<int, int>>, aber es lohnt sich, es wird genau erläutert code).

Im direkten Vergleich, diese version unterlegen ist - sowohl schwieriger zu verstehen und weniger effizient. Aber das erlernen dieser Ansatz ermöglicht einige prägnante und effiziente Variante (N) der gleichen Technik, also es lohnt sich zu untersuchen.

GroupBy() dauert eine Aufzählung und erzeugt weitere enumeration enthält Schlüssel-Wert-Paaren, wobei der Wert eine Aufzählung zu. Die lambda - x => x bedeutet, dass das, was es ist, gruppiert von selbst, aber wir haben die Flexibilität, für unterschiedliche Gruppierung der Regeln als das. Der Inhalt grp sieht ein bisschen aus wie:

{
  {Key=2, {2, 2, 2}}
  {Key=3, {3}}
  {Key=5, {5, 5}}
}

So, wenn wir eine Schleife durch dieses eine für jede Gruppe ziehen wir die Key - und call - Count() auf die Gruppe, wir bekommen die Ergebnisse, die wir wollen.

Nun, im ersten Fall Bauten wir unsere Zählung in einer einzigen O(n) übergeben, während hier bauen wir die Gruppe in eine O(n) passieren, und dann erhalten Sie die Anzahl in einer Sekunde von O(n) übergeben, so dass es viel weniger effizient. Es ist auch ein bisschen schwerer zu verstehen, also warum die Mühe es zu erwähnen?

Gut, die erste ist, dass, wenn wir es verstehen, können wir wiederum die Zeilen:

IEnumerable<IGrouping<int, int>> grp = dict.Values.GroupBy(x => x);
foreach(IGrouping<int, int> item in grp)
    Console.WriteLine("{0} - {1}", item.Key, item.Count());

In:

foreach(var item in dict.Values.GroupBy(x => x))
  Console.WriteLine("{0} - {1}", item.Key, item.Count());

Ist ziemlich prägnant, und wird idiomatisch. Es ist vor allem schön, wenn wir wollen, dann gehen Sie auf und tun Sie etwas komplizierter mit der Wert-Anzahl Paare wie können wir diese Kette in einem anderen Betrieb.

Die version, die speichert die Ergebnisse in einem Wörterbuch können noch präziser noch:

var valCount = dict.Values.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());

Dort deine ganze Frage beantwortet, in einer kurzen Zeile, anstatt die 6 (Ausschneiden Kommentare) für die erste version.

(Einige könnten es vorziehen, zu ersetzen dict.Values.GroupBy(x => x) mit dict.GroupBy(x => x.Value) die haben genau die gleichen Ergebnisse sobald wir laufen die Count() auf Sie. Wenn Sie nicht sofort sicher, warum, versuchen, es herauszufinden,).

Der andere Vorteil ist, dass wir mehr Flexibilität mit GroupBy in anderen Fällen. Aus diesen Gründen, Menschen genutzt, um mit Hilfe GroupBy sind sehr wahrscheinlich beginnen Sie mit der ein-Linie Prägnanz der dict.Values.GroupBy(x => x).ToDictinary(g => g.Key, g => g.Count()); und wechseln Sie dann in Ausführlicher, aber mehr effient form der ersten version (wo erhöhen wir mit Laufenden Summen in neue Wörterbuch), wenn es erwies sich als ein performance-hotspot.