dictionary c# Quel est le meilleur moyen de parcourir un dictionnaire?



12 Answers

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

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

Ou, si vous devez seulement parcourir la collection de clés, utilisez

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

Et enfin, si vous ne vous intéressez qu'aux valeurs:

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

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

dictionary c# example

J'ai vu différentes façons de parcourir un dictionnaire en C #. Y a-t-il un moyen standard?




Cela dépend si vous êtes après les clés ou les valeurs ...

À partir du Dictionary(TKey, TValue) MSDN Dictionary(TKey, TValue) Description de la classe:

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



Je dirais que foreach est la méthode standard, bien que cela dépende évidemment de ce que vous recherchez.

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

Est-ce ce que vous cherchez?




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.7 on 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 le System.ValueTuple NuGet package et é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;
    }
}



La forme la plus simple pour itérer un dictionnaire:

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



En utilisant 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'
}


À la place de la traditionnelle

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 KeyValuePair de votre IDictionary<TKey, TValue> en un tuple fortement typé, vous permettant d'utiliser cette nouvelle syntaxe confortable.

Il convertit -just- les entrées de dictionnaire requises en tuples , de sorte qu'il ne convertit PAS l'intégralité du dictionnaire en tuples , de sorte qu'il n'y a pas de problème de performances lié à cela.

La méthode d’extension permettant de créer un tuple est relativement peu coûteuse par rapport à l’ KeyValuePair directe de KeyValuePair , ce qui ne devrait PAS être un problème si vous affectez les propriétés KeyValuePair Key and Value aux nouvelles variables de boucle.

En pratique, cette nouvelle syntaxe convient très bien dans la plupart des cas, à l'exception des scénarios de performances ultra-hautes performances de bas niveau, où vous avez toujours la possibilité de ne pas l'utiliser tout simplement à cet endroit spécifique.

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




Je vais tirer parti de .NET 4.0+ et fournir une réponse mise à jour à celle initialement acceptée:

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



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

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



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

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



J'ai écrit une extension à boucler 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));



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
}



Related