Saya telah melihat beberapa cara berbeda untuk beralih ke kamus di C #. Apakah ada cara standar?

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

Jika Anda mencoba menggunakan Kamus generik dalam C # seperti Anda akan menggunakan array asosiatif dalam bahasa lain:

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

Atau, jika Anda hanya perlu mengulangi pengumpulan kunci, gunakan

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

Dan terakhir, jika Anda hanya tertarik pada nilai-nilai:

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

(Perhatikan bahwa varkata kunci adalah fitur C # 3.0 opsional dan di atas, Anda juga dapat menggunakan jenis kunci / nilai yang tepat di sini)

Dalam beberapa kasus, Anda mungkin memerlukan penghitung yang mungkin disediakan oleh implementasi for-loop. Untuk itu, LINQ menyediakan ElementAtyang memungkinkan berikut ini:

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

Tergantung pada apakah Anda setelah kunci atau nilai ...

Dari Dictionary(TKey, TValue)deskripsi Kelas 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);
}

Secara umum, meminta "cara terbaik" tanpa konteks tertentu seperti bertanya apa warna terbaik ?

Di satu sisi, ada banyak warna dan tidak ada warna terbaik. Itu tergantung pada kebutuhan dan sering juga pada rasa.

Di sisi lain, ada banyak cara untuk beralih ke Kamus di C # dan tidak ada cara terbaik. Itu tergantung pada kebutuhan dan sering juga pada rasa.

Cara yang paling mudah

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

Jika Anda hanya membutuhkan nilainya (memungkinkan untuk memanggilnya item, lebih dapat dibaca daripada kvp.Value).

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

Jika Anda memerlukan urutan pengurutan tertentu

Secara umum, pemula terkejut tentang urutan enumerasi suatu Kamus.

LINQ menyediakan sintaksis ringkas yang memungkinkan untuk menentukan pesanan (dan banyak hal lainnya), misalnya:

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

Sekali lagi Anda mungkin hanya perlu nilai. LINQ juga menyediakan solusi ringkas untuk:

• iterate langsung pada nilai (memungkinkan untuk menyebutnya item, lebih mudah dibaca daripada kvp.Value)
• tetapi diurutkan berdasarkan tombol

Ini dia:

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

Ada banyak lagi kasus penggunaan dunia nyata yang dapat Anda lakukan dari contoh-contoh ini. Jika Anda tidak memerlukan pesanan khusus, cukup ikuti "cara paling mudah" (lihat di atas)!

Saya akan mengatakan foreach adalah cara standar, meskipun itu jelas tergantung pada apa yang Anda cari

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

Itukah yang kamu cari?

Anda juga dapat mencoba ini pada kamus besar untuk pemrosesan multithreaded.

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

C # 7.0 memperkenalkan Deconstructors dan jika Anda menggunakan .NET Core 2.0+ Application, structKeyValuePair<>sudah menyertakan aDeconstruct()untuk Anda. Jadi kamu bisa melakukan:

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

Saya menghargai pertanyaan ini sudah memiliki banyak tanggapan tetapi saya ingin melakukan sedikit riset.

Iterasi pada kamus bisa agak lambat jika dibandingkan dengan iterasi pada sesuatu seperti array. Dalam pengujian saya, iterasi pada array membutuhkan waktu 0,015003 detik sedangkan iterasi pada kamus (dengan jumlah elemen yang sama) mengambil 0,0365073 detik, yang 2,4 kali lebih lama! Meskipun saya telah melihat perbedaan yang jauh lebih besar. Sebagai perbandingan, suatu Daftar berada di antara 0,00215043 detik.

Namun, itu seperti membandingkan apel dan jeruk. Maksud saya adalah iterasi kamus lebih lambat.

Kamus dioptimalkan untuk pencarian, jadi dengan itu dalam pikiran saya telah membuat dua metode. Satu hanya melakukan pendahuluan, yang lain iterates kunci kemudian melihat ke atas.

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

    return "Normal";
}

Yang ini memuat kunci dan beralih di atasnya (saya juga mencoba menarik kunci menjadi string [] tetapi perbedaannya dapat diabaikan.

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

Dengan contoh ini tes foreach normal mengambil 0,0310062 dan versi kunci mengambil 0,2205441. Memuat semua kunci dan mengulangi semua pencarian jelas BANYAK lebih lambat!

Untuk tes akhir saya telah melakukan iterasi saya sepuluh kali untuk melihat apakah ada manfaat menggunakan kunci di sini (pada titik ini saya hanya ingin tahu):

Inilah metode RunTest jika itu membantu Anda memvisualisasikan apa yang terjadi.

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

Di sini proses normal foreach memakan waktu 0,2820564 detik (sekitar sepuluh kali lebih lama dari iterasi tunggal - seperti yang Anda harapkan). Iterasi pada tombol mengambil 2,2249449 detik.

Diedit Untuk Menambahkan: Membaca beberapa jawaban lain membuat saya mempertanyakan apa yang akan terjadi jika saya menggunakan Kamus dan bukan Kamus. Dalam contoh ini array membutuhkan waktu 0,0120024 detik, daftar 0,0185037 detik dan kamus 0,0465093 detik. Masuk akal untuk berharap bahwa tipe data membuat perbedaan pada seberapa lambat kamus.

Apa Kesimpulan Saya ?

• Hindari pengulangan pada kamus jika Anda bisa, mereka jauh lebih lambat daripada pengulangan pada array dengan data yang sama di dalamnya.
• Jika Anda memilih untuk beralih ke kamus jangan mencoba terlalu pintar, meskipun lebih lambat Anda bisa melakukan jauh lebih buruk daripada menggunakan metode standar foreach.

Ada banyak pilihan. Favorit pribadi saya adalah oleh KeyValuePair

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

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

Anda juga dapat menggunakan Koleksi Tombol dan Nilai

Dengan .NET Framework 4.7satu dapat menggunakan dekomposisi

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

Agar kode ini berfungsi pada versi C # yang lebih rendah, tambahkan System.ValueTuple NuGet packagedan tulis di suatu tempat

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

Pada C # 7, Anda dapat mendekonstruksi objek menjadi variabel. Saya percaya ini menjadi cara terbaik untuk beralih ke kamus.

Contoh:

Buat metode ekstensi untuk KeyValuePair<TKey, TVal>mendekonstruksinya:

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

Iterasi Dictionary<TKey, TVal>dengan cara berikut

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

Anda menyarankan di bawah ini untuk beralih

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

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

FYI, foreachtidak berfungsi jika nilainya bertipe objek.

Bentuk paling sederhana untuk beralih ke kamus:

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

Dengan menggunakan C # 7 , tambahkan metode ekstensi ini ke proyek apa pun dari solusi Anda:

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

Dan gunakan sintaksis sederhana ini

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

Atau yang ini, jika Anda mau

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

Di tempat tradisional

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

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

Metode ekstensi mengubah KeyValuePairAnda IDictionary<TKey, TValue>menjadi sangat diketiktuple , memungkinkan Anda untuk menggunakan sintaks nyaman baru ini.

Itu mengkonversi-hanya- entri kamus yang diperlukan untuk tuples, sehingga TIDAK mengubah seluruh kamustuples , sehingga tidak ada masalah kinerja yang terkait dengan itu.

Hanya ada sedikit biaya memanggil metode ekstensi untuk membuat tupledibandingkan dengan menggunakan KeyValuePairlangsung, yang TIDAK boleh menjadi masalah jika Anda menetapkan KeyValuePairproperti KeydanValue variabel loop baru.

Dalam praktiknya, sintaksis baru ini sangat cocok untuk sebagian besar kasus, kecuali untuk skenario kinerja ultra-tinggi tingkat rendah, di mana Anda masih memiliki opsi untuk tidak menggunakannya di tempat tertentu.

Lihat ini: Blog MSDN - Fitur baru di C # 7

Saya tahu ini adalah pertanyaan yang sangat lama, tetapi saya membuat beberapa metode ekstensi yang mungkin berguna:

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

Dengan cara ini saya dapat menulis kode seperti ini:

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

Kadang-kadang jika Anda hanya perlu nilai untuk dihitung, gunakan koleksi nilai kamus:

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

Dilaporkan oleh pos ini yang menyatakan itu adalah metode tercepat: http://alexpinsker.blogspot.hk/2010/02/c-fastest-way-to-iterate-over.html

Saya menemukan metode ini dalam dokumentasi untuk kelas DictionaryBase di MSDN:

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

Ini adalah satu-satunya yang saya bisa berfungsi dengan benar di kelas yang diwarisi dari DictionaryBase.

foreachtercepat dan jika Anda hanya beralih ___.Values, itu juga lebih cepat

Saya akan memanfaatkan .NET 4.0+ dan memberikan jawaban yang diperbarui untuk yang diterima semula:

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

Cara standar untuk beralih ke Kamus, menurut dokumentasi resmi pada MSDN adalah:

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

Saya menulis ekstensi untuk mengulang kamus.

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

Maka Anda bisa menelepon

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

Jika mengatakan, Anda ingin mengulangi pengumpulan nilai secara default, saya yakin Anda dapat mengimplementasikan IEnumerable <>, Di mana T adalah jenis objek nilai dalam kamus, dan "ini" adalah Kamus.

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

Sebagaimana telah ditunjukkan pada jawaban ini , KeyValuePair<TKey, TValue>mengimplementasikan aDeconstruct metode yang dimulai pada .NET Core 2.0, .NET Standard 2.1 dan .NET Framework 5.0 (pratinjau).

Dengan ini, dimungkinkan untuk beralih melalui kamus dengan KeyValuePaircara agnostik:

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

Hanya ingin menambahkan 2 sen saya, karena sebagian besar jawaban berkaitan dengan foreach-loop. Silakan lihat kode berikut:

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

Kalau dipikir-pikir ini menambahkan panggilan tambahan '.ToList ()', mungkin ada sedikit peningkatan kinerja (seperti yang ditunjukkan di sini foreach vs someList.Foreach () {} ), terutama ketika bekerja dengan Kamus besar dan berjalan secara paralel tidak ada option / tidak akan berpengaruh sama sekali.

Juga, harap dicatat bahwa Anda tidak dapat menetapkan nilai ke properti 'Nilai' di dalam foreach-loop. Di sisi lain, Anda akan dapat memanipulasi 'Kunci' juga, mungkin membuat Anda mendapat masalah saat runtime.

Saat Anda hanya ingin "membaca" Tombol dan Nilai, Anda mungkin juga menggunakan IEnumerable.Select ().

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

Kamus <TKey, TValue> Ini adalah kelas koleksi generik dalam c # dan menyimpan data dalam format nilai kunci. Kunci harus unik dan tidak boleh nol sedangkan nilai dapat digandakan dan null. Karena setiap item dalam kamus adalah diperlakukan sebagai struktur KeyValuePair <TKey, TValue> yang mewakili kunci dan nilainya. dan karenanya kita harus mengambil tipe elemen KeyValuePair <TKey, TValue> selama iterasi elemen. Di bawah ini adalah contohnya.

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

Jika Anda ingin menggunakan untuk loop, Anda dapat melakukan ini:

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

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

selain posting berperingkat tertinggi di mana ada diskusi antara menggunakan

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

atau

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

paling lengkap adalah yang berikut karena Anda bisa melihat jenis kamus dari inisialisasi, kvp adalah 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
}