सी # शब्दकोश प्रकार अद्वितीय कुंजी और मूल्यों के साथ

Question

मैं सोच रहा था कि सी # में एक प्रकार का प्रकार था जो 'डिक्शनरी' जैसा था, लेकिन जहां टीके और टीवील्यू दोनों अद्वितीय थे।

उदाहरण के लिए ::

d.Add(1, "1"); 
d.Add(2, "1"); // This would not be OK because "1" has already been used as a value. 

मैं जानता हूँ कि यह विदेशी की तरह है, लेकिन ऐसा लगता है कि यह मौजूद हो सकता है के बाद से देखते हैं बीसीएल में संग्रह प्रकार अरब एक के बारे में। कोई विचार?

Answer 1

शब्दकोश और हैशसेट/माध्यमिक रिवर्स डिक्शनरी के बारे में कैसे - यह समस्या को हल करेगा और एकल शब्दकोश पर चेक से बेहतर प्रदर्शन करेगा।

कुछ इस तरह, वर्ग के रूप में लिपटे:

HashSet<string> secondary = new HashSet<string>(/*StringComparer.InvariantCultureIgnoreCase*/); 
Dictionary<int, string>dictionary = new Dictionary<int, string>(); 
object syncer = new object(); 

public override void Add(int key, string value) 
{ 
    lock(syncer) 
    { 
    if(dictionary.ContainsKey(key)) 
    { 
     throw new Exception("Key already exists"); 
    } 

    if(secondary.Add(value) 
    { 
     throw new Exception("Value already exists"); 
    } 
    dictionary.Add(key, value); 
    } 
} 

Answer 2

here इस तरह की एक प्रकार है कि स्थित एक परियोजना है। इसे PairDictionary कहा जाता है और यह बहुत अच्छी तरह से काम करता है। सबसे अच्छा जवाब नहीं है, लेकिन किसी भी व्यक्ति के लिए जो उस कस्टम वर्ग की जरूरत है।

Answer 3

मैंने डेटा को Dictionary<TKey, HashSet<TValue>> के रूप में संग्रहीत करके इस समस्या को हल किया। यदि आप एक मूल्य चाहते हैं जिसमें 2 प्राथमिक कुंजी हैं तो आप हैशसेट को किसी अन्य शब्दकोश से प्रतिस्थापित कर सकते हैं।

Dictionary<int, HashSet<int>> _myUniquePairOfIntegerKeys; 
// OR 
Dictionary<string, Dictionary<string, bool>> _myUniquePairOfStringKeysWithABooleanValue; 

Answer 4

आंतरिक puposes के लिए मैंने BiDictionary लिखा था। यह बुलेट प्रूफ नहीं है क्योंकि मैं इसे उपयोगकर्ता को बेनकाब नहीं करता हूं, इसलिए यह मेरे लिए ठीक काम करता है। यह मुझे या तो कुंजी प्राप्त करने की अनुमति देता है क्योंकि मुझे आवश्यकता है।

KeyPair<,>IEnumerable<,> को लागू करने में सक्षम होना आवश्यक है और इस प्रकार Add विधि ताकि हम ऑब्जेक्ट प्रारंभकर्ता का उपयोग कर सकें।

internal class KeyPair<TKey1, TKey2> 
{ 
    public TKey1 Key1 { get; set; } 
    public TKey2 Key2 { get; set; } 
} 

यह एक गतिशील वस्तु के रूप में मुख्य वर्ग इतना है कि हम इस पर प्रमुख के नाम का इस्तेमाल कर सकते हैं जब मूल्यों को पुन: प्राप्त है:

internal class BiDictionary<TKey1, TKey2> : DynamicObject, IEnumerable<KeyPair<TKey1, TKey2>> 
{ 
    private readonly Dictionary<TKey1, TKey2> _K1K2 = new Dictionary<TKey1, TKey2>(); 
    private readonly Dictionary<TKey2, TKey1> _K2K1 = new Dictionary<TKey2, TKey1>(); 

    private readonly string _key1Name; 
    private readonly string _key2Name; 

    public BiDictionary(string key1Name, string key2Name) 
    { 
     _key1Name = key1Name; 
     _key2Name = key2Name; 
    } 

    public override bool TryGetMember(GetMemberBinder binder, out object result) 
    { 
     if (binder.Name == _key1Name) 
     { 
      result = _K1K2; 
      return true; 
     } 

     if (binder.Name == _key2Name) 
     { 
      result = _K2K1; 
      return true; 
     } 

     result = null; 
     return false; 
    } 

    public void Add(TKey1 key1, TKey2 key2) 
    { 
     _K1K2.Add(key1, key2); 
     _K2K1.Add(key2, key1); 
    } 

    public IEnumerator<KeyPair<TKey1, TKey2>> GetEnumerator() 
    { 
     return _K1K2.Zip(_K2K1, (d1, d2) => new KeyPair<TKey1, TKey2> 
     { 
      Key1 = d1.Key, 
      Key2 = d2.Key 
     }).GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 
} 

उदाहरण:

dynamic bidic = new BiDictionary<string, string>("Key1", "Key2") 
{ 
    { "foo", "bar" }, 
    { "baz", "qux" } 
}; 
var bar = bidic.Key1["foo"]; 
var foo = bidic.Key2["bar"]; 

---

वे हो सकता है यदि आप बाहर के किसी भी शब्दकोश को संशोधित करते हैं तो सिंक से बाहर निकलें। इस उद्देश्य के लिए मैं ObservableDictionary का उपयोग करता हूं ताकि अगर कोई बदलता है लेकिन सादगी के लिए मैं दूसरे को अपडेट कर सकता हूं तो मैंने मुख्य तर्क को केवल डेमोस्टेट करने के लिए कोड के इस भाग को हटा दिया।