c# - जेनेरिक शब्दकोश के लिए केस असंवेदनशील पहुंच




generics dictionary (2)

मेरे पास एक ऐसा एप्लिकेशन है जो प्रबंधित डीएलएस का उपयोग करता है। उन डीएलएस में से एक सामान्य शब्दकोष लौटाता है:

Dictionary<string, int> MyDictionary;  

शब्दकोश में ऊपरी और निचले मामले वाले कुंजियां हैं।

दूसरी ओर मुझे संभावित कुंजी (स्ट्रिंग) की एक सूची मिल रही है हालांकि मैं मामले की गारंटी नहीं दे सकता। मैं कुंजी का उपयोग कर शब्दकोश में मूल्य प्राप्त करने की कोशिश कर रहा हूं। लेकिन निश्चित रूप से निम्नलिखित विफल हो जाएंगे क्योंकि मेरे पास मामला मेल नहीं है:

bool Success = MyDictionary.TryGetValue( MyIndex, out TheValue );  

मैं उम्मीद कर रहा था कि TryGetValue में एमएसडीएन दस्तावेज़ में उल्लिखित एक अनदेखा केस ध्वज होगा, लेकिन ऐसा लगता है कि यह सामान्य शब्दकोशों के लिए मान्य नहीं है।

क्या कुंजीपटल को अनदेखा करने वाले उस शब्द का मूल्य प्राप्त करने का कोई तरीका है? क्या उचित StringComparer.OrdinalIgnoreCase पैरामीटर के साथ शब्दकोश की एक नई प्रति बनाने की तुलना में बेहतर कामकाज है?


आपके लिए LINQers वहां हैं जो नियमित शब्दकोश कन्स्ट्रक्टर का कभी भी उपयोग नहीं करते हैं:

myCollection.ToDictionary(x => x.PartNumber, x => x.PartDescription, StringComparer.OrdinalIgnoreCase)

उस बिंदु पर StringComparer निर्दिष्ट करने का कोई तरीका नहीं है जहां आप मूल्य प्राप्त करने का प्रयास करते हैं। यदि आप इसके बारे में सोचते हैं, तो "foo".GetHashCode() और "FOO".GetHashCode() पूरी तरह से अलग हैं इसलिए केस-सेंसिटिव हैश मैप पर केस-असंवेदनशील प्राप्त करने का कोई उचित तरीका नहीं है।

हालांकि, आप पहले स्थान पर एक केस-असंवेदनशील शब्दकोश बना सकते हैं: -

var comparer = StringComparer.OrdinalIgnoreCase;
var caseInsensitiveDictionary = new Dictionary<string, int>(comparer);

या एक मौजूदा केस-संवेदनशील शब्दकोश की सामग्री के साथ एक नया केस-असंवेदनशील शब्दकोश बनाएं (यदि आप सुनिश्चित हैं कि कोई केस टकराव नहीं है): -

var oldDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
var newDictionary = new Dictionary<string, int>(oldDictionary, comparer);

यह शब्द तब StringComparer.OrdinalIgnoreCase पर GetHashCode() कार्यान्वयन का उपयोग करता है जैसे comparer.GetHashCode("foo") और comparer.GetHashcode("FOO") आपको वही मान देता है।

वैकल्पिक रूप से, यदि शब्दकोश में केवल कुछ तत्व हैं, और / या आपको केवल एक या दो बार देखने की आवश्यकता है, तो आप मूल शब्दकोश को एक IEnumerable<KeyValuePair<TKey, TValue>> और बस इसे फिर से चालू कर सकते हैं: -

var myKey = ...;
var myDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
var value = myDictionary.FirstOrDefault(x => String.Equals(x.Key, myKey, comparer))?.Value;

या यदि आप LINQ के बिना पसंद करते हैं: -

var myKey = ...;
var myDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
int? value;
foreach (var element in myDictionary)
{
  if (String.Equals(element.Key, myKey, comparer))
  {
    value = element.Value;
    break;
  }
}

यह आपको एक नई डेटा संरचना बनाने की लागत बचाता है, लेकिन बदले में लुकअप की लागत ओ (एन) के बजाय ओ (एन) है।





dictionary