शब्दकोश सी #

Question

में गणना शब्दकोश मैं एक शब्दकोश का आकलन कैसे करूं?

मान लीजिए कि मैं डिक्शनरी गणना के लिए foreach() का उपयोग करता हूं। मैं foreach() के अंदर एक कुंजी/मूल्य जोड़ी अपडेट नहीं कर सकता। तो मुझे कुछ और तरीका चाहिए।

Answer 1

एक शब्दकोश की गणना करने के लिए आप या तो इसे भीतर मूल्यों की गणना:

Dictionary<int, string> dic; 

foreach(string s in dic.Values) 
{ 
    Console.WriteLine(s); 
} 

या KeyValuePairs

foreach(KeyValuePair<int, string> kvp in dic) 
{ 
    Console.WriteLine("Key : " + kvp.Key.ToString() + ", Value : " + kvp.Value); 
} 

या कुंजियों

foreach(int key in dic.Keys) 
{ 
    Console.WriteLine(key.ToString()); 
} 

आप आइटम अपडेट करना चाहते हैं शब्दकोश के भीतर आपको थोड़ा अलग करने की ज़रूरत है, क्योंकि आप इंस्टेंस अपडेट नहीं कर सकते हैं जबकि गणना।

Dictionary<int, string> newValues = new Dictionary<int, string>() { 1, "Test" }; 
foreach(KeyValuePair<int, string> kvp in newValues) 
{ 
    dic[kvp.Key] = kvp.Value; // will automatically add the item if it's not there 
} 

आइटम निकालने के लिए, एक समान तरीके से ऐसा करते हैं, आइटम हम नहीं बल्कि निकालना चाहते हैं उसके संग्रह की गणना: आपको क्या करने की आवश्यकता होगी एक अलग संग्रह है कि अद्यतन नहीं किया जा रहा करके बताना है, तो तरह है शब्दकोश से खुद ही।

List<int> keys = new List<int>() { 1, 3 }; 
foreach(int key in keys) 
{ 
    dic.Remove(key); 
} 

Answer 2

Foreach। तीन तरीके हैं: आप संपत्ति पर Values संपत्ति पर या शब्दकोश में स्वयं को KeyValuePair<TKey, TValue> के गणक के बारे में बता सकते हैं।

Answer 3

समस्या के जवाब में "मैं foreach() के अंदर मूल्य/कुंजी अपडेट नहीं कर सकता", आप इसे गणना करते समय संग्रह को संशोधित नहीं कर सकते हैं। मैं कुंजी संग्रह की एक प्रतिलिपि बनाकर इस दृष्टिकोण होगा:

Dictionary<int,int> dic=new Dictionary<int, int>(); 

//...fill the dictionary 

int[] keys = dic.Keys.ToArray(); 
foreach (int i in keys) 
{ 
    dic.Remove(i); 
} 

Answer 4

मैं सिर्फ सूचियों के लिए एक ही (अद्यतन) सवाल का जवाब है, तो यहां शब्दकोशों के लिए एक ही बात है।

public static void MutateEach(this IDictionary<TKey, TValue> dict, Func<TKey, TValue, KeyValuePair<TKey, TValue>> mutator) 
{ 
    var removals = new List<TKey>(); 
    var additions = new List<KeyValuePair<TKey, TValue>>(); 

    foreach (var pair in dict) 
    { 
     var newPair = mutator(pair.Key, pair.Value); 
     if ((newPair.Key != pair.Key) || (newPair.Value != pair.Value)) 
     { 
      removals.Add(pair.Key); 
      additions.Add(newPair); 
     } 
    } 

    foreach (var removal in removals) 
     dict.Remove(removal); 

    foreach (var addition in additions) 
     dict.Add(addition.Key, addition.Value); 
} 

नोट हम पाश के बाहर अपडेट करना है, अतः हमने शब्दकोश को संशोधित नहीं कर रहे हैं जैसा कि हम इसे करके बताना। इसके अलावा यह दो कुंजी बनाने के कारण होने वाली झड़पों का पता लगाता है - यह फेंक देगा (Add के उपयोग के कारण)।

उदाहरण - सभी कुंजियों लोअरकेस बनाने के लिए और एक Dictionary<string, string> साथ सभी मूल्यों ट्रिम,: अगर कुंजियां अनन्य जब लोअरकेस नहीं बने हैं

myDict.MutateEach(key => key.ToLower(), value => value.Trim()); 

, इस फेंक देते हैं।