c# dictionary new - Qual è il modo migliore per scorrere su un dizionario?



12 Answers

Se stai cercando di utilizzare un dizionario generico in C # come si usa un array associativo in un'altra lingua:

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

Oppure, se hai solo bisogno di iterare sulla collezione di chiavi, usa

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

E infine, se sei interessato solo ai valori:

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

(Prendi nota che la parola chiave var è una caratteristica C # 3.0 opzionale e sopra, puoi anche usare il tipo esatto di chiavi / valori qui)

all scan examples

Ho visto alcuni modi diversi per scorrere su un dizionario in C #. C'è un modo standard?




Dipende se stai cercando le chiavi o i valori ...

Dal Dictionary(TKey, TValue) MSDN Dictionary(TKey, TValue) Descrizione della 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);
}



Direi che foreach è il modo standard, anche se ovviamente dipende da cosa stai cercando

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

E 'quello che stai cercando?




Ci sono molte opzioni. Il mio preferito è KeyValuePair

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

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

Puoi anche utilizzare le raccolte di chiavi e valori




Con .NET Framework 4.7 si può usare la decomposizione

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

Per fare in modo che questo codice funzioni su versioni C # inferiori, aggiungi il System.ValueTuple NuGet package e scrivi da qualche parte

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



Forma più semplice per iterare un dizionario:

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



Usando C # 7 , aggiungi questo metodo di estensione a qualsiasi progetto della tua soluzione:

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


E usa questa semplice sintassi

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


O questo, se preferisci

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


Al posto del tradizionale

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

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


Il metodo di estensione trasforma KeyValuePair del tuo IDictionary<TKey, TValue> in una tuple fortemente tipizzata, permettendoti di usare questa nuova sintassi confortevole.

Converte le sole voci del dizionario richieste in tuples , quindi NON converte l'intero dizionario in tuples , quindi non ci sono problemi di prestazioni correlati a questo.

C'è solo un costo minore che chiama il metodo di estensione per creare una tuple in confronto all'uso diretto di KeyValuePair , il che NON dovrebbe essere un problema se si assegnano le proprietà Key e Value KeyValuePair alle nuove variabili di loop.

In pratica, questa nuova sintassi si adatta molto bene alla maggior parte dei casi, ad eccezione degli scenari di prestazioni ultraveloce a basso livello, in cui è ancora possibile scegliere di non utilizzarlo in quel determinato punto.

Dai un'occhiata a questo: Blog MSDN - Nuove funzionalità in C # 7




Approfitterò di .NET 4.0+ e fornirò una risposta aggiornata a quella originariamente accettata:

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



Se, per esempio, si desidera eseguire un'iterazione sulla raccolta di valori per impostazione predefinita, credo che sia possibile implementare IEnumerable <>, dove T è il tipo di valori oggetto nel dizionario e "this" è un dizionario.

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



Ho scritto un'estensione per scorrere su un dizionario.

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

Quindi puoi chiamare

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



oltre ai post più alti in cui c'è una discussione tra l'utilizzo

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

o

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

il più completo è il seguente perché è possibile visualizzare il tipo di dizionario dall'inizializzazione, kvp è 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