Ich habe verschiedene Möglichkeiten gesehen, ein Wörterbuch in C # zu durchlaufen. Gibt es einen Standardweg?

foreach(KeyValuePair<string, string> entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}

Wenn Sie versuchen, ein generisches Wörterbuch in C # wie ein assoziatives Array in einer anderen Sprache zu verwenden:

foreach(var item in myDictionary)
{
  foo(item.Key);
  bar(item.Value);
}

Oder verwenden Sie, wenn Sie nur die Schlüsselsammlung durchlaufen müssen

foreach(var item in myDictionary.Keys)
{
  foo(item);
}

Und zum Schluss, wenn Sie nur an den Werten interessiert sind:

foreach(var item in myDictionary.Values)
{
  foo(item);
}

(Beachten Sie, dass das varSchlüsselwort eine optionale Funktion ab C # 3.0 ist. Sie können hier auch den genauen Typ Ihrer Schlüssel / Werte verwenden.)

In einigen Fällen benötigen Sie möglicherweise einen Zähler, der durch die For-Loop-Implementierung bereitgestellt wird. Dafür bietet LINQ ElementAtFolgendes:

for (int index = 0; index < dictionary.Count; index++) {
  var item = dictionary.ElementAt(index);
  var itemKey = item.Key;
  var itemValue = item.Value;
}

Kommt darauf an, ob du hinter den Schlüsseln oder den Werten her bist ...

Aus der Dictionary(TKey, TValue)Beschreibung der MSDN- Klasse:

// When you use foreach to enumerate dictionary elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine();
foreach( KeyValuePair<string, string> kvp in openWith )
{
    Console.WriteLine("Key = {0}, Value = {1}", 
        kvp.Key, kvp.Value);
}

// To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl =
    openWith.Values;

// The elements of the ValueCollection are strongly typed
// with the type that was specified for dictionary values.
Console.WriteLine();
foreach( string s in valueColl )
{
    Console.WriteLine("Value = {0}", s);
}

// To get the keys alone, use the Keys property.
Dictionary<string, string>.KeyCollection keyColl =
    openWith.Keys;

// The elements of the KeyCollection are strongly typed
// with the type that was specified for dictionary keys.
Console.WriteLine();
foreach( string s in keyColl )
{
    Console.WriteLine("Key = {0}", s);
}

Im Allgemeinen ist die Frage nach dem "besten Weg" ohne einen bestimmten Kontext wie die Frage nach der besten Farbe .

Einerseits gibt es viele Farben und es gibt keine beste Farbe. Es kommt auf die Bedürfnisse und oft auch auf den Geschmack an.

Auf der anderen Seite gibt es viele Möglichkeiten, ein Wörterbuch in C # zu durchlaufen, und es gibt keinen besten Weg. Es kommt auf die Bedürfnisse und oft auch auf den Geschmack an.

Einfachster Weg

foreach (var kvp in items)
{
    // key is kvp.Key
    doStuff(kvp.Value)
}

Wenn Sie nur den Wert benötigen (erlaubt es, ihn aufzurufen item, besser lesbar als kvp.Value).

foreach (var item in items.Values)
{
    doStuff(item)
}

Wenn Sie eine bestimmte Sortierreihenfolge benötigen

Im Allgemeinen sind Anfänger über die Reihenfolge der Aufzählung eines Wörterbuchs überrascht.

LINQ bietet eine präzise Syntax, mit der Sie die Reihenfolge (und viele andere Dinge) festlegen können, z.

foreach (var kvp in items.OrderBy(kvp => kvp.Key))
{
    // key is kvp.Key
    doStuff(kvp.Value)
}

Auch hier benötigen Sie möglicherweise nur den Wert. LINQ bietet auch eine präzise Lösung für:

• iterieren Sie direkt auf dem Wert (ermöglicht es, ihn aufzurufen item, besser lesbar als kvp.Value)
• aber sortiert nach den Schlüsseln

Hier ist es:

foreach (var item in items.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value))
{
    doStuff(item)
}

Es gibt viel mehr reale Anwendungsfälle, die Sie anhand dieser Beispiele ausführen können. Wenn Sie keine bestimmte Bestellung benötigen, halten Sie sich einfach an den "einfachsten Weg" (siehe oben)!

Ich würde sagen, foreach ist der Standardweg, obwohl es offensichtlich davon abhängt, wonach Sie suchen

foreach(var kvp in my_dictionary) {
  ...
}

Ist es das, wonach du suchst?

Sie können dies auch in großen Wörterbüchern für die Multithread-Verarbeitung ausprobieren.

dictionary
.AsParallel()
.ForAll(pair => 
{ 
    // Process pair.Key and pair.Value here
});

In C # 7.0 wurden Dekonstruktoren eingeführt. Wenn Sie eine .NET Core 2.0+ -Anwendung verwenden, enthält die StrukturKeyValuePair<>bereits eineDeconstruct()für Sie. So können Sie tun:

var dic = new Dictionary<int, string>() { { 1, "One" }, { 2, "Two" }, { 3, "Three" } };
foreach (var (key, value) in dic) {
    Console.WriteLine($"Item [{key}] = {value}");
}
//Or
foreach (var (_, value) in dic) {
    Console.WriteLine($"Item [NO_ID] = {value}");
}
//Or
foreach ((int key, string value) in dic) {
    Console.WriteLine($"Item [{key}] = {value}");
}

Ich schätze, dass diese Frage bereits viele Antworten erhalten hat, aber ich wollte ein wenig Nachforschungen anstellen.

Das Iterieren über ein Wörterbuch kann im Vergleich zum Iterieren über ein Array ziemlich langsam sein. In meinen Tests dauerte eine Iteration über ein Array 0,015003 Sekunden, während eine Iteration über ein Wörterbuch (mit der gleichen Anzahl von Elementen) 0,0365073 Sekunden dauerte, was 2,4-mal so lang ist! Obwohl ich viel größere Unterschiede gesehen habe. Zum Vergleich lag eine Liste irgendwo zwischen 0,00215043 Sekunden.

Das ist jedoch wie ein Vergleich von Äpfeln und Orangen. Mein Punkt ist, dass das Durchlaufen von Wörterbüchern langsam ist.

Wörterbücher sind für Suchvorgänge optimiert. Aus diesem Grund habe ich zwei Methoden erstellt. Einer macht einfach einen foreach, der andere iteriert die Schlüssel und schaut dann nach oben.

public static string Normal(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var kvp in dictionary)
    {
        value = kvp.Value;
        count++;
    }

    return "Normal";
}

Dieser lädt die Schlüssel und iteriert stattdessen darüber (ich habe auch versucht, die Schlüssel in eine Zeichenfolge [] zu ziehen, aber der Unterschied war vernachlässigbar.

public static string Keys(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var key in dictionary.Keys)
    {
        value = dictionary[key];
        count++;
    }

    return "Keys";
}

In diesem Beispiel dauerte der normale foreach-Test 0,0310062 und die Schlüsselversion 0,2205441. Das Laden aller Schlüssel und das Durchlaufen aller Suchvorgänge ist eindeutig viel langsamer!

Für einen abschließenden Test habe ich meine Iteration zehn Mal durchgeführt, um festzustellen, ob die Verwendung der Schlüssel hier Vorteile bringt (zu diesem Zeitpunkt war ich nur neugierig):

Hier ist die RunTest-Methode, mit der Sie visualisieren können, was gerade passiert.

private static string RunTest<T>(T dictionary, Func<T, string> function)
{            
    DateTime start = DateTime.Now;
    string name = null;
    for (int i = 0; i < 10; i++)
    {
        name = function(dictionary);
    }
    DateTime end = DateTime.Now;
    var duration = end.Subtract(start);
    return string.Format("{0} took {1} seconds", name, duration.TotalSeconds);
}

Hier dauerte der normale foreach-Lauf 0,2820564 Sekunden (ungefähr zehnmal länger als eine einzelne Iteration - wie zu erwarten). Die Iteration über die Schlüssel dauerte 2,2249449 Sekunden.

Zum Hinzufügen bearbeitet: Beim Lesen einiger anderer Antworten fragte ich mich, was passieren würde, wenn ich Dictionary anstelle von Dictionary verwenden würde. In diesem Beispiel dauerte das Array 0,0120024 Sekunden, die Liste 0,0185037 Sekunden und das Wörterbuch 0,0465093 Sekunden. Es ist zu erwarten, dass der Datentyp einen Unterschied darin macht, wie viel langsamer das Wörterbuch ist.

Was sind meine Schlussfolgerungen ?

• Vermeiden Sie das Durchlaufen eines Wörterbuchs, wenn Sie können. Diese sind wesentlich langsamer als das Durchlaufen eines Arrays mit denselben Daten.
• Wenn Sie sich dafür entscheiden, ein Wörterbuch zu durchlaufen, versuchen Sie nicht, zu klug zu sein, obwohl Sie langsamer viel schlechter abschneiden könnten als mit der Standardmethode foreach.

Es gibt viele Möglichkeiten. Mein persönlicher Favorit ist von KeyValuePair

Dictionary<string, object> myDictionary = new Dictionary<string, object>();
// Populate your dictionary here

foreach (KeyValuePair<string,object> kvp in myDictionary)
{
     // Do some interesting things
}

Sie können auch die Schlüssel- und Wertesammlungen verwenden

Mit .NET Framework 4.7kann man Zersetzung verwenden

var fruits = new Dictionary<string, int>();
...
foreach (var (fruit, number) in fruits)
{
    Console.WriteLine(fruit + ": " + number);
}

System.ValueTuple NuGet packageFügen Sie irgendwo hinzu und schreiben Sie, damit dieser Code in niedrigeren C # -Versionen funktioniert

public static class MyExtensions
{
    public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple,
        out T1 key, out T2 value)
    {
        key = tuple.Key;
        value = tuple.Value;
    }
}

Ab C # 7 können Sie Objekte in Variablen zerlegen. Ich glaube, dies ist der beste Weg, um ein Wörterbuch zu durchlaufen.

Beispiel:

Erstellen Sie eine Erweiterungsmethode KeyValuePair<TKey, TVal>, die es dekonstruiert:

public static void Deconstruct<TKey, TVal>(this KeyValuePair<TKey, TVal> pair, out TKey key, out TVal value)
{
   key = pair.Key;
   value = pair.Value;
}

Iterieren Sie über eine Dictionary<TKey, TVal>der folgenden Methoden

// Dictionary can be of any types, just using 'int' and 'string' as examples.
Dictionary<int, string> dict = new Dictionary<int, string>();

// Deconstructor gets called here.
foreach (var (key, value) in dict)
{
   Console.WriteLine($"{key} : {value}");
}

Sie haben unten vorgeschlagen, zu iterieren

Dictionary<string,object> myDictionary = new Dictionary<string,object>();
//Populate your dictionary here

foreach (KeyValuePair<string,object> kvp in myDictionary) {
    //Do some interesting things;
}

Zu Ihrer Information, foreachfunktioniert nicht, wenn der Wert vom Typ Objekt ist.

Einfachste Form zum Iterieren eines Wörterbuchs:

foreach(var item in myDictionary)
{ 
    Console.WriteLine(item.Key);
    Console.WriteLine(item.Value);
}

Fügen Sie mit C # 7 diese Erweiterungsmethode zu jedem Projekt Ihrer Lösung hinzu:

public static class IDictionaryExtensions
{
    public static IEnumerable<(TKey, TValue)> Tuples<TKey, TValue>(
        this IDictionary<TKey, TValue> dict)
    {
        foreach (KeyValuePair<TKey, TValue> kvp in dict)
            yield return (kvp.Key, kvp.Value);
    }
}

Und verwenden Sie diese einfache Syntax

foreach (var(id, value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}

Oder dieses, wenn Sie es vorziehen

foreach ((string id, object value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}

Anstelle des Traditionellen

foreach (KeyValuePair<string, object> kvp in dict)
{
    string id = kvp.Key;
    object value = kvp.Value;

    // your code using 'id' and 'value'
}

Die Erweiterungsmethode verwandelt die KeyValuePairvon Ihnen IDictionary<TKey, TValue>in eine stark typisierte Methode tuple, sodass Sie diese neue komfortable Syntax verwenden können.

Es konvertiert -just- die erforderlichen Wörterbucheinträge in tuples, konvertiert also NICHT das gesamte Wörterbuch in tuples, sodass diesbezüglich keine Leistungsprobleme bestehen.

Es gibt nur geringe Kosten für das Aufrufen der Erweiterungsmethode zum Erstellen eines tupleim Vergleich zur KeyValuePairdirekten Verwendung, was KEIN Problem sein sollte, wenn Sie die KeyValuePairEigenschaften des ' Keyund Valueohnehin neuen Schleifenvariablen zuweisen .

In der Praxis eignet sich diese neue Syntax in den meisten Fällen sehr gut, mit Ausnahme von Szenarien mit extrem hoher Leistung auf niedriger Ebene, in denen Sie immer noch die Möglichkeit haben, sie einfach nicht an dieser bestimmten Stelle zu verwenden.

Schauen Sie sich das an: MSDN Blog - Neue Funktionen in C # 7

Ich weiß, dass dies eine sehr alte Frage ist, aber ich habe einige Erweiterungsmethoden erstellt, die nützlich sein könnten:

    public static void ForEach<T, U>(this Dictionary<T, U> d, Action<KeyValuePair<T, U>> a)
    {
        foreach (KeyValuePair<T, U> p in d) { a(p); }
    }

    public static void ForEach<T, U>(this Dictionary<T, U>.KeyCollection k, Action<T> a)
    {
        foreach (T t in k) { a(t); }
    }

    public static void ForEach<T, U>(this Dictionary<T, U>.ValueCollection v, Action<U> a)
    {
        foreach (U u in v) { a(u); }
    }

Auf diese Weise kann ich Code wie folgt schreiben:

myDictionary.ForEach(pair => Console.Write($"key: {pair.Key}, value: {pair.Value}"));
myDictionary.Keys.ForEach(key => Console.Write(key););
myDictionary.Values.ForEach(value => Console.Write(value););

Wenn Sie nur die Werte aufzählen müssen, verwenden Sie manchmal die Wertsammlung des Wörterbuchs:

foreach(var value in dictionary.Values)
{
    // do something with entry.Value only
}

Dieser Beitrag berichtet, dass dies die schnellste Methode ist: http://alexpinsker.blogspot.hk/2010/02/c-fastest-way-to-iterate-over.html

Ich habe diese Methode in der Dokumentation für die DictionaryBase-Klasse auf MSDN gefunden:

foreach (DictionaryEntry de in myDictionary)
{
     //Do some stuff with de.Value or de.Key
}

Dies war die einzige, die in einer Klasse, die von der DictionaryBase geerbt wurde, ordnungsgemäß funktionieren konnte.

foreachist am schnellsten und wenn Sie nur iterieren ___.Values, ist es auch schneller

Ich werde den Vorteil von .NET 4.0+ nutzen und eine aktualisierte Antwort auf die ursprünglich akzeptierte geben:

foreach(var entry in MyDic)
{
    // do something with entry.Value or entry.Key
}

Die Standardmethode zum Durchlaufen eines Wörterbuchs laut offizieller Dokumentation zu MSDN lautet:

foreach (DictionaryEntry entry in myDictionary)
{
     //Read entry.Key and entry.Value here
}

Ich habe eine Erweiterung geschrieben, um ein Wörterbuch zu durchlaufen.

public static class DictionaryExtension
{
    public static void ForEach<T1, T2>(this Dictionary<T1, T2> dictionary, Action<T1, T2> action) {
        foreach(KeyValuePair<T1, T2> keyValue in dictionary) {
            action(keyValue.Key, keyValue.Value);
        }
    }
}

Dann können Sie anrufen

myDictionary.ForEach((x,y) => Console.WriteLine(x + " - " + y));

Wenn Sie beispielsweise standardmäßig über die Wertsammlung iterieren möchten, können Sie IEnumerable <> implementieren, wobei T der Typ des Werteobjekts im Wörterbuch ist und "this" ein Wörterbuch ist.

public new IEnumerator<T> GetEnumerator()
{
   return this.Values.GetEnumerator();
}

Ich wollte nur meine 2 Cent hinzufügen, da sich die meisten Antworten auf foreach-loop beziehen. Bitte schauen Sie sich den folgenden Code an:

Dictionary<String, Double> myProductPrices = new Dictionary<String, Double>();

//Add some entries to the dictionary

myProductPrices.ToList().ForEach(kvP => 
{
    kvP.Value *= 1.15;
    Console.Writeline(String.Format("Product '{0}' has a new price: {1} $", kvp.Key, kvP.Value));
});

Obwohl dies einen zusätzlichen Aufruf von '.ToList ()' hinzufügt, kann es zu einer leichten Leistungsverbesserung kommen (wie hier für jeden im Vergleich zu someList.Foreach () {} ausgeführt ), insbesondere wenn Sie mit großen Wörterbüchern arbeiten und parallel laufen Option / hat überhaupt keine Wirkung.

Beachten Sie außerdem, dass Sie der Eigenschaft 'Value' in einer foreach-Schleife keine Werte zuweisen können. Auf der anderen Seite können Sie auch den 'Schlüssel' manipulieren, wodurch Sie möglicherweise zur Laufzeit in Schwierigkeiten geraten.

Wenn Sie nur Schlüssel und Werte "lesen" möchten, können Sie auch IEnumerable.Select () verwenden.

var newProductPrices = myProductPrices.Select(kvp => new { Name = kvp.Key, Price = kvp.Value * 1.15 } );

var dictionary = new Dictionary<string, int>
{
    { "Key", 12 }
};

var aggregateObjectCollection = dictionary.Select(
    entry => new AggregateObject(entry.Key, entry.Value));

Wörterbuch <TKey, TValue> Es handelt sich um eine generische Auflistungsklasse in c #, in der die Daten im Schlüsselwertformat gespeichert werden. Der Schlüssel muss eindeutig sein und darf nicht null sein, während der Wert doppelt und null sein kann. Wie jedes Element im Wörterbuch wird als KeyValuePair <TKey, TValue> -Struktur behandelt, die einen Schlüssel und seinen Wert darstellt. Daher sollten wir während der Iteration des Elements den Elementtyp KeyValuePair <TKey, TValue> verwenden. Unten ist das Beispiel.

Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1,"One");
dict.Add(2,"Two");
dict.Add(3,"Three");

foreach (KeyValuePair<int, string> item in dict)
{
    Console.WriteLine("Key: {0}, Value: {1}", item.Key, item.Value);
}

Wenn Sie die for-Schleife verwenden möchten, können Sie dies tun:

var keyList=new List<string>(dictionary.Keys);
for (int i = 0; i < keyList.Count; i++)
{
   var key= keyList[i];
   var value = dictionary[key];
 }

Wie bereits in dieser Antwort erwähnt , wird KeyValuePair<TKey, TValue>eine DeconstructMethode implementiert , die mit .NET Core 2.0, .NET Standard 2.1 und .NET Framework 5.0 (Vorschau) beginnt.

Auf diese Weise ist es möglich, ein Wörterbuch auf KeyValuePairagnostische Weise zu durchlaufen :

var dictionary = new Dictionary<int, string>();

// ...

foreach (var (key, value) in dictionary)
{
    // ...
}

einfach mit linq

 Dictionary<int, string> dict = new Dictionary<int, string>();
 dict.Add(1, "American Ipa");
 dict.Add(2, "Weiss");
 dict.ToList().ForEach(x => Console.WriteLine($"key: {x.Key} | value: {x.Value}") );

Zusätzlich zu den am höchsten bewerteten Posts, in denen eine Diskussion zwischen der Verwendung besteht

foreach(KeyValuePair<string, string> entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}

oder

foreach(var entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}

Am vollständigsten ist Folgendes, da Sie den Wörterbuchtyp anhand der Initialisierung sehen können. Kvp ist KeyValuePair

var myDictionary = new Dictionary<string, string>(x);//fill dictionary with x

foreach(var kvp in myDictionary)//iterate over dictionary
{
    // do something with kvp.Value or kvp.Key
}