[c#] Quelle est la meilleure façon de parcourir un dictionnaire en C #?


Answers

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

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

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

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

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

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

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

Question

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




Il y a plein d'options. Mon préféré est 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 façon 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
}



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

De 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 voulais juste ajouter mes 2 cents, car la plupart des réponses se rapportent à foreach-loop. S'il vous plaît, regardez le 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));
});

Bien que 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 () {} ), en particulier lorsque vous travaillez avec de grands Dictionnaires et que vous ne travaillez pas en parallèle. option / n'aura aucun effet.

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

Lorsque vous voulez juste "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 } );



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

var aggregateObjectCollection = dictionary.Select(
    entry => new AggregateObject(entry.Key, entry.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;
}

FYI, foreach ne fonctionne pas si la valeur est de type objet.




Je dirais que foreach est la façon standard, bien que cela dépende évidemment de ce que vous cherchez

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

Est-ce ce que vous cherchez?




Related