J'ai vu plusieurs façons différentes d'itérer sur un dictionnaire en C #. Existe-t-il une méthode standard?

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

Si vous essayez d'utiliser un dictionnaire générique en C # comme vous utiliseriez un tableau associatif dans une autre langue:

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

Ou, si vous avez seulement besoin d'itérer sur la collection de clés, utilisez

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

Et enfin, si vous êtes uniquement intéressé par les valeurs:

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

(Notez que le varmot-clé est une fonctionnalité facultative C # 3.0 et supérieure, vous pouvez également utiliser le type exact de vos clés / valeurs ici)

Dans certains cas, vous aurez peut-être besoin d'un compteur fourni par l'implémentation de la boucle for. Pour cela, LINQ fournit ElementAtce qui permet ce qui suit:

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

Selon que vous recherchez les clés ou les valeurs ...

De la Dictionary(TKey, TValue)description de la classe MSDN :

// 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);
}

Généralement, demander «la meilleure façon» sans contexte spécifique revient à demander quelle est la meilleure couleur ?

D'une part, il y a beaucoup de couleurs et il n'y a pas de meilleure couleur. Cela dépend du besoin et souvent du goût aussi.

D'un autre côté, il existe de nombreuses façons d'itérer un dictionnaire en C # et il n'y a pas de meilleur moyen. Cela dépend du besoin et souvent du goût aussi.

Manière la plus simple

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

Si vous n'avez besoin que de la valeur (permet de l'appeler item, plus lisible que kvp.Value).

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

Si vous avez besoin d'un ordre de tri spécifique

Généralement, les débutants sont surpris de l'ordre d'énumération d'un dictionnaire.

LINQ fournit une syntaxe concise qui permet de spécifier l'ordre (et bien d'autres choses), par exemple:

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

Encore une fois, vous n'aurez peut-être besoin que de la valeur. LINQ fournit également une solution concise pour:

• itérer directement sur la valeur (permet de l'appeler item, plus lisible quekvp.Value )
• mais trié par les clés

C'est ici:

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

Il existe de nombreux autres cas d'utilisation réels que vous pouvez faire à partir de ces exemples. Si vous n'avez pas besoin d'une commande spécifique, respectez simplement la "voie la plus simple" (voir ci-dessus)!

Je dirais que foreach est le moyen standard, bien que cela dépende évidemment de ce que vous recherchez

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

C'est ça que vous cherchez?

Vous pouvez également l'essayer sur de gros dictionnaires pour le traitement multithread.

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

C # 7.0 a introduit les déconstructeurs et si vous utilisez l'application .NET Core 2.0+ , la structureKeyValuePair<>inclut déjà unDeconstruct()pour vous. Vous pouvez donc faire:

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}");
}

J'apprécie que cette question a déjà eu beaucoup de réponses mais je voulais apporter un peu de recherche.

L'itération sur un dictionnaire peut être assez lente par rapport à l'itération sur quelque chose comme un tableau. Dans mes tests, une itération sur un tableau a pris 0,015003 secondes tandis qu'une itération sur un dictionnaire (avec le même nombre d'éléments) a pris 0,0365073 secondes, soit 2,4 fois plus longtemps! Bien que j'aie vu des différences beaucoup plus importantes. A titre de comparaison, une liste se situait quelque part entre 0,00215043 secondes.

Cependant, c'est comme comparer des pommes et des oranges. Mon point est que l'itération sur les dictionnaires est lente.

Les dictionnaires sont optimisés pour les recherches, donc dans cet esprit, j'ai créé deux méthodes. L'un fait simplement un foreach, l'autre itère les touches puis lève les yeux.

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

    return "Normal";
}

Celui-ci charge les clés et les parcourt à la place (j'ai également essayé de tirer les clés dans une chaîne [] mais la différence était négligeable.

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";
}

Avec cet exemple, le test normal de foreach a pris 0,0310062 et la version des clés a pris 0,2205441. Charger toutes les clés et itérer sur toutes les recherches est clairement beaucoup plus lent!

Pour un test final, j'ai effectué mon itération dix fois pour voir s'il y a des avantages à utiliser les clés ici (à ce stade, j'étais juste curieux):

Voici la méthode RunTest si cela vous aide à visualiser ce qui se passe.

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);
}

Ici, l'exécution normale de chaque séquence a pris 0,2820564 secondes (environ dix fois plus longtemps qu'une seule itération - comme vous vous en doutez). L'itération sur les clés a pris 2,2249449 secondes.

Modifié pour ajouter: La lecture de certaines des autres réponses m'a fait me demander ce qui se passerait si j'utilisais Dictionnaire au lieu de Dictionnaire. Dans cet exemple, le tableau a pris 0,0120024 secondes, la liste 0,0185037 secondes et le dictionnaire 0,0465093 secondes. Il est raisonnable de s'attendre à ce que le type de données fasse une différence sur la lenteur du dictionnaire.

Quelles sont mes conclusions ?

• Évitez d'itérer sur un dictionnaire si vous le pouvez, ils sont beaucoup plus lents que d'itérer sur un tableau contenant les mêmes données.
• Si vous choisissez d'itérer sur un dictionnaire, n'essayez pas d'être trop intelligent, bien que plus lent, vous pourriez faire bien pire que d'utiliser la méthode foreach standard.

Il y a plein d'options. Mon préféré est par KeyValuePair

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

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

Vous pouvez également utiliser les collections de clés et de valeurs

Avec .NET Framework 4.7on peut utiliser la décomposition

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

Pour que ce code fonctionne sur les versions C # inférieures, ajoutez System.ValueTuple NuGet packageet écrivez quelque part

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;
    }
}

Depuis C # 7, vous pouvez déconstruire des objets en variables. Je pense que c'est la meilleure façon de parcourir un dictionnaire.

Exemple:

Créez une méthode d'extension KeyValuePair<TKey, TVal>qui la déconstruit:

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

Itérer sur tout Dictionary<TKey, TVal>de la manière suivante

// 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}");
}

Vous avez suggéré ci-dessous d'itérer

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

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

Pour info, foreachne fonctionne pas si la valeur est de type objet.

Forme la plus simple pour itérer un dictionnaire:

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

À l'aide de C # 7 , ajoutez cette méthode d'extension à n'importe quel projet de votre solution:

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);
    }
}

Et utilisez cette syntaxe simple

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

Ou celui-ci, si vous préférez

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

Au lieu du traditionnel

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

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

La méthode d'extension transforme le KeyValuePairde votre IDictionary<TKey, TValue>en un texte fortement typétuple , vous permettant d'utiliser cette nouvelle syntaxe confortable.

Il convertit -juste- les entrées de dictionnaire requises en tuples, donc il ne convertit PAS le dictionnaire entier entuples , donc il n'y a aucun problème de performance lié à cela.

Il n'y a qu'un coût mineur appelant la méthode d'extension pour créer un tupleen comparaison avec l'utilisation KeyValuePairdirecte de, ce qui ne devrait PAS être un problème si vous affectez les KeyValuePairpropriétés de Keyet Valueà de nouvelles variables de boucle de toute façon.

Dans la pratique, cette nouvelle syntaxe convient très bien à la plupart des cas, sauf pour les scénarios de très haut niveau à très hautes performances, où vous avez toujours la possibilité de simplement ne pas l'utiliser à cet endroit spécifique.

Découvrez ceci: Blog MSDN - Nouvelles fonctionnalités dans C # 7

Je sais que c'est une très vieille question, mais j'ai créé quelques méthodes d'extension qui pourraient être utiles:

    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); }
    }

De cette façon, je peux écrire du code comme ceci:

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););

Parfois, si vous avez seulement besoin d'énumérer les valeurs, utilisez la collection de valeurs du dictionnaire:

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

Rapporté par ce post qui déclare que c'est la méthode la plus rapide: http://alexpinsker.blogspot.hk/2010/02/c-fastest-way-to-iterate-over.html

J'ai trouvé cette méthode dans la documentation de la classe DictionaryBase sur MSDN:

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

Ce fut le seul que j'ai réussi à faire fonctionner correctement dans une classe héritée de DictionaryBase.

foreachest plus rapide et si vous ne faites que répéter ___.Values, c'est aussi plus rapide

Je profiterai de .NET 4.0+ et fournirai une réponse mise à jour à celle initialement acceptée:

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

La manière standard d'itérer sur un dictionnaire, selon la documentation officielle sur MSDN, est:

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

J'ai écrit une extension pour faire une boucle sur un dictionnaire.

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);
        }
    }
}

Ensuite, vous pouvez appeler

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

Si, par exemple, vous souhaitez parcourir la collection de valeurs par défaut, je pense que vous pouvez implémenter IEnumerable <>, où T est le type de l'objet valeurs dans le dictionnaire, et "ceci" est un dictionnaire.

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

Comme déjà indiqué dans cette réponse , KeyValuePair<TKey, TValue>implémente une Deconstructméthode commençant par .NET Core 2.0, .NET Standard 2.1 et .NET Framework 5.0 (préversion).

Avec cela, il est possible de parcourir un dictionnaire de manière KeyValuePairagnostique:

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

// ...

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

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

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

Je voulais juste ajouter mes 2 cents, car la plupart des réponses se rapportent à foreach-loop. Veuillez jeter un œil au code suivant:

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));
});

Même si cela ajoute un appel supplémentaire de '.ToList ()', il pourrait y avoir une légère amélioration des performances (comme indiqué ici foreach vs someList.Foreach () {} ), surtout lorsque vous travaillez avec de gros dictionnaires et que l'exécution en parallèle n'est pas option / n'aura aucun effet.

Notez également que vous ne pourrez pas attribuer de valeurs à la propriété 'Value' dans une boucle foreach. D'un autre côté, vous pourrez également manipuler la «clé», ce qui pourrait vous causer des problèmes lors de l'exécution.

Lorsque vous souhaitez simplement "lire" les clés et les valeurs, vous pouvez également utiliser IEnumerable.Select ().

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

Dictionary <TKey, TValue> C'est une classe de collection générique en c # et elle stocke les données dans le format de valeur de clé. La clé doit être unique et elle ne peut pas être nulle tandis que la valeur peut être dupliquée et nulle. Comme chaque élément du dictionnaire est traitée comme une structure KeyValuePair <TKey, TValue> représentant une clé et sa valeur. et donc nous devons prendre le type d'élément KeyValuePair <TKey, TValue> pendant l'itération de l'élément. Voici l'exemple.

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);
}

Si vous souhaitez utiliser for loop, vous pouvez le faire:

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

simple avec 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}") );

en plus des postes les plus élevés où il y a une discussion entre l'utilisation

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

ou

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

le plus complet est le suivant car vous pouvez voir le type de dictionnaire depuis l'initialisation, kvp est 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
}