.NET शब्दकोशों में डुप्लिकेट कुंजियाँ?

Question

क्या .NET बेस क्लास लाइब्रेरी में कोई डिक्शनरी क्लासेस हैं जो डुप्लिकेट कीज़ का उपयोग करने की अनुमति देती हैं? एकमात्र समाधान जो मैंने पाया है, उदाहरण के लिए, एक वर्ग जैसे:

Dictionary<string, List<object>>

लेकिन यह वास्तव में उपयोग करने के लिए काफी परेशान है। Java में, मेरा मानना ​​है कि एक MultiMap इसे पूरा करता है, लेकिन .NET में एनालॉग नहीं खोज सकता।

Comments

यह डुप्लिकेट कुंजी कैसे है, यह डुप्लिकेट मान (सूची), सही है?

— शमीम हाफिज

@ शमीम हफीज, नहीं, मूल्यों की नकल करने की जरूरत नहीं है। यदि आपको डुप्लिकेट { a, 1 }और { a, 2 }एक हैश तालिका में स्टोर करना है जहां aकुंजी है, तो एक विकल्प है { a, [1, 2] }।

— नवफाल

वास्तव में, मुझे विश्वास है कि वास्तव में यहां क्या चाहिए था एक संग्रह है जहां प्रत्येक कुंजी एक या एक से अधिक मूल्यों पर मैप कर सकती है। मुझे लगता है कि अभिव्यक्ति "डुप्लिकेट कुंजी" वास्तव में यह व्यक्त नहीं करता है।

— डेविड आरआर

भविष्य के संदर्भ के लिए, आपको एक ही कुंजी को बार-बार जोड़ने के बजाय 1 कुंजी को रखने पर विचार करना चाहिए।

— हां वांग

यदि कुंजी और मान दोनों तार हैं, तो NameValueCollection है (जो प्रत्येक स्ट्रिंग कुंजी के साथ कई स्ट्रिंग मानों को जोड़ सकता है)।

— AnorZaken 16

Answer 1

यदि आप .NET 3.5 का उपयोग कर रहे हैं, तो Lookupकक्षा का उपयोग करें ।

संपादित करें: आप आम तौर पर एक Lookupप्रयोग करते हैं Enumerable.ToLookup। यह मान लेता है कि आपको इसे बाद में बदलने की आवश्यकता नहीं है - लेकिन मुझे आमतौर पर लगता है कि यह काफी अच्छा है।

यदि वह आपके लिए काम नहीं करता है , तो मुझे नहीं लगता कि फ्रेमवर्क में ऐसा कुछ भी है जो मदद करेगा - और शब्दकोश का उपयोग करना उतना ही अच्छा है जितना कि यह :(

Comments

लुकअप में हेड-अप के लिए धन्यवाद। यह एक linq क्वेरी से विभाजन (समूह) परिणामों के लिए एक शानदार तरीका प्रदान करता है जो मानक क्रम मापदंड नहीं हैं।

— राबर्ट पॉलसन

@ जोश: आप एक बनाने के लिए Enumerable.ToLookup का उपयोग करते हैं।

— जॉन स्कीट

सावधान का शब्द : Lookupक्रमिक नहीं है

— स्लीवरनिंजा - MSFT

हमें उस लुकअप में आइटम कैसे जोड़ना चाहिए?

— मोलदोवनु

Answer 2

सूची वर्ग वास्तव में डुप्लिकेट वाले कुंजी / मान संग्रह के लिए बहुत अच्छी तरह से काम करता है जहां आप संग्रह पर पुनरावृति करना चाहते हैं। उदाहरण:

List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();

// add some values to the collection here

for (int i = 0;  i < list.Count;  i++)
{
    Print(list[i].Key, list[i].Value);
}

Comments

यह समाधान कार्यात्मक रूप से काम करता है, लेकिन सूची के कार्यान्वयन में कुंजी या मूल्य का कोई ज्ञान नहीं है और कठबोली कुंजी की खोज सभी में नहीं है

— स्पेन्सर रोज

Answer 3

यहाँ सूची <KeyValuePair <string, string>> के साथ ऐसा करने का एक तरीका है

public class ListWithDuplicates : List<KeyValuePair<string, string>>
{
    public void Add(string key, string value)
    {
        var element = new KeyValuePair<string, string>(key, value);
        this.Add(element);
    }
}

var list = new ListWithDuplicates();
list.Add("k1", "v1");
list.Add("k1", "v2");
list.Add("k1", "v3");

foreach(var item in list)
{
    string x = string.format("{0}={1}, ", item.Key, item.Value);
}

आउटपुट k1 = v1, k1 = v2, k1 = v3

Comments

मेरे परिदृश्य में बढ़िया काम करता है और उपयोग में भी आसान है।

— user6121177

Answer 4

यदि आप स्ट्रिंग्स को कुंजी और मान दोनों के रूप में उपयोग कर रहे हैं, तो आप System.Collections.Specialized.NameValueCollection का उपयोग कर सकते हैं , जो GetValues ​​(स्ट्रिंग कुंजी) विधि के माध्यम से स्ट्रिंग मानों की एक सरणी लौटाएगा।

Comments

NameValueCollection कई कुंजियों की अनुमति नहीं देता है।

— जेनी ओ'रिली

@ जेनी ओ'रिली: ज़रूर, आप डुप्लिकेट कुंजी जोड़ सकते हैं।

— 12

कड़ाई से बोलना @ JennyO'Reilly सही है, क्योंकि लिंक किए गए MSDN पृष्ठ पर टिप्पणी स्पष्ट रूप से बताती है: यह वर्ग एकल कुंजी के तहत कई स्ट्रिंग मान संग्रहीत करता है ।

— रोनाल्ड

यह अनुमति देगा लेकिन कई मान लौटाएगा, मैंने सूचकांक और कुंजी का उपयोग करने की कोशिश की।

— 206 बजे user6121177

Answer 5

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

Answer 6

लुकअप के उपयोग के संबंध में बहुत महत्वपूर्ण नोट:

आप उस ऑब्जेक्ट पर Lookup(TKey, TElement)कॉल करके एक उदाहरण बना सकते हैं ToLookupजो लागू करता हैIEnumerable(T)

का एक नया उदाहरण बनाने के लिए कोई सार्वजनिक निर्माणकर्ता नहीं है Lookup(TKey, TElement)। इसके अतिरिक्त, Lookup(TKey, TElement)ऑब्जेक्ट अपरिवर्तनीय हैं, अर्थात, आप Lookup(TKey, TElement)इसे बनाए जाने के बाद किसी ऑब्जेक्ट से तत्वों या कुंजियों को जोड़ या हटा नहीं सकते हैं ।

(MSDN से)

मुझे लगता है कि यह अधिकांश उपयोगों के लिए एक शो स्टॉपर होगा।

Comments

मैं बहुत कम उपयोगों के बारे में सोच सकता हूं जहां यह शो स्टॉपर होगा। लेकिन फिर, मुझे लगता है कि अपरिवर्तनीय वस्तुएँ महान हैं।

— जोएल मुलर

@JoelMueller मैं कई मामलों के बारे में सोच सकता हूं जहां यह शो स्टॉपर है। किसी आइटम को जोड़ने के लिए एक शब्दकोश को फिर से बनाने के लिए एक विशेष रूप से कुशल समाधान नहीं है ...

— लिखना

Answer 7

मुझे लगता है कि कुछ List<KeyValuePair<object, object>>ऐसा काम करेगा।

Comments

आप उस सूची में कुछ कैसे दिखते हैं यह महत्वपूर्ण है?

— वेन ब्लॉस

आपको इसके माध्यम से पुनरावृत्त करना होगा: लेकिन मुझे .NET 3.5 के लुकअप-क्लास के बारे में जानकारी नहीं थी: हो सकता है कि यह इस सामग्री में खोजने के लिए अधिक उपयोगी हो।

— MADMap

@wizlib: एकमात्र तरीका सूची के माध्यम से लूप करना है, जो हैशिंग के रूप में लगभग कुशल नहीं है। -1

— पेट्र के।

@petrk। यह वास्तव में इस बात पर निर्भर करता है कि आपका डेटा क्या है। मैंने इस कार्यान्वयन का उपयोग किया क्योंकि मेरे पास बहुत कम अनूठी कुंजियाँ थीं और हैश टक्करों के ओवरहेड को उकसाना नहीं चाहता था। +1

— इवान एम

Answer 8

अगर आप> = .NET 4 का उपयोग कर रहे हैं तो आप Tupleक्लास का उपयोग कर सकते हैं :

// declaration
var list = new List<Tuple<string, List<object>>>();

// to add an item to the list
var item = Tuple<string, List<object>>("key", new List<object>);
list.Add(item);

// to iterate
foreach(var i in list)
{
    Console.WriteLine(i.Item1.ToString());
}

Comments

यह ऊपर की तरह एक List<KeyValuePair<key, value>>समाधान की तरह दिखता है। क्या मै गलत हु?

— नाथन गोइंग

Answer 9

यह एक शब्दकोश के "अपने खुद के" रोल को करने के लिए काफी आसान है जो "डुप्लिकेट कुंजी" प्रविष्टियों की अनुमति देता है। यहाँ एक सरल कार्यान्वयन है। आप मूल रूप से सबसे (यदि सभी नहीं) के लिए समर्थन जोड़ने पर विचार करना चाह सकते हैं IDictionary<T>।

public class MultiMap<TKey,TValue>
{
    private readonly Dictionary<TKey,IList<TValue>> storage;

    public MultiMap()
    {
        storage = new Dictionary<TKey,IList<TValue>>();
    }

    public void Add(TKey key, TValue value)
    {
        if (!storage.ContainsKey(key)) storage.Add(key, new List<TValue>());
        storage[key].Add(value);
    }

    public IEnumerable<TKey> Keys
    {
        get { return storage.Keys; }
    }

    public bool ContainsKey(TKey key)
    {
        return storage.ContainsKey(key);
    }

    public IList<TValue> this[TKey key]
    {
        get
        {
            if (!storage.ContainsKey(key))
                throw new KeyNotFoundException(
                    string.Format(
                        "The given key {0} was not found in the collection.", key));
            return storage[key];
        }
    }
}

इसका उपयोग करने के तरीके पर एक त्वरित उदाहरण:

const string key = "supported_encodings";
var map = new MultiMap<string,Encoding>();
map.Add(key, Encoding.ASCII);
map.Add(key, Encoding.UTF8);
map.Add(key, Encoding.Unicode);

foreach (var existingKey in map.Keys)
{
    var values = map[existingKey];
    Console.WriteLine(string.Join(",", values));
}

Answer 10

मूल प्रश्न के उत्तर में। द Dictionary<string, List<object>>क्लास नामक एक कक्षा में कुछ लागू किया जाता MultiMapहै Code Project।

आप नीचे दिए गए लिंक पर अधिक जानकारी पा सकते हैं: http://www.codeproject.com/KB/cs/MultiKeyDictionary.aspx

Answer 11

NameValueCollection एक कुंजी (जो एक स्ट्रिंग भी है) के तहत कई स्ट्रिंग मानों का समर्थन करता है, लेकिन यह एकमात्र उदाहरण है जिससे मैं परिचित हूं।

जब मैं उन स्थितियों में दौड़ता हूँ, जब मैं उन स्थितियों में दौड़ता हूँ, जहाँ मुझे उस प्रकार की कार्यक्षमता की आवश्यकता होती है।

Answer 12

List<KeyValuePair<string, object>>विकल्प का उपयोग करते समय, आप खोज करने के लिए LINQ का उपयोग कर सकते हैं:

List<KeyValuePair<string, object>> myList = new List<KeyValuePair<string, object>>();
//fill it here
var q = from a in myList Where a.Key.Equals("somevalue") Select a.Value
if(q.Count() > 0){ //you've got your value }

Comments

हाँ, लेकिन यह इसे तेज़ नहीं करता है (अभी भी कोई हैशिंग नहीं है)

— हुकमैन

Answer 13

चूंकि नया C # (मैं इसे 7.0 से मानता हूं), आप कुछ इस तरह भी कर सकते हैं:

var duplicatedDictionaryExample = new List<(string Key, string Value)> { ("", "") ... }

और आप इसे एक मानक सूची के रूप में उपयोग कर रहे हैं, लेकिन दो मानों के साथ जिसका नाम आप चाहते हैं

foreach(var entry in duplicatedDictionaryExample)
{ 
    // do something with the values
    entry.Key;
    entry.Value;
}

Answer 14

क्या आपका मतलब बधाई है और वास्तविक डुप्लिकेट नहीं है? अन्यथा कोई हैशटेबल काम नहीं कर पाएगा।

कांग्रेंट का मतलब है कि दो अलग-अलग कुंजी बराबर मूल्य के लिए हैश कर सकते हैं, लेकिन चाबियाँ समान नहीं हैं।

उदाहरण के लिए: मान लें कि आपके हैशटेबल का हैश फंक्शन सिर्फ हैशवल = कुंजी आधुनिक है। दोनों 1 और 4 मैप टू 1, लेकिन अलग-अलग मान हैं। यह वह जगह है जहाँ किसी सूची का आपका विचार चलन में आता है।

जब आपको 1 देखने की आवश्यकता होती है, तो उस मान को 1 पर हैशड किया जाता है, कुंजी = 1 मिलने तक सूची का पता लगाया जाता है।

यदि आपने डुप्लिकेट कुंजियों को डालने की अनुमति दी है, तो आप किन कुंजियों को मैप करने में अंतर नहीं कर पाएंगे।

Comments

एक हैश तालिका पहले से ही उन कुंजियों को संभालती है जो उसी मूल्य के लिए हैश होती है (इसे टकराव कहा जाता है)। मैं एक ऐसी स्थिति की बात कर रहा हूँ जहाँ आप एक ही सटीक कुंजी पर कई मानों को मैप करना चाहते हैं।

Answer 15

जिस तरह से मैं का उपयोग सिर्फ एक है

Dictionary<string, List<string>>

इस तरह आपके पास स्ट्रिंग्स की एक सूची रखने वाली एकल कुंजी है।

उदाहरण:

List<string> value = new List<string>();
if (dictionary.Contains(key)) {
     value = dictionary[key];
}
value.Add(newValue);

Comments

यह अच्छा और साफ है।

— जेरी निक्सन

मेरे उपयोग के मामले को संभालने के लिए यह एक बढ़िया उपाय है।

— डब स्टाइल

Answer 16

मैं एक ही उत्तर की तलाश में इस पोस्ट पर ठोकर खाई, और कोई नहीं मिला, इसलिए मैंने शब्दकोशों की एक सूची का उपयोग करके नंगे-हड्डियों के उदाहरण के समाधान में धांधली की, [] ऑपरेटर को ओवरराइड करने के लिए सूची में एक नया शब्दकोश जोड़ने के लिए जब अन्य सभी की सूची है दी गई कुंजी (सेट), और मानों की एक सूची लौटाएं (प्राप्त करें)।
यह बदसूरत और अक्षम है, यह केवल कुंजी द्वारा सेट / प्राप्त करता है, और यह हमेशा एक सूची देता है, लेकिन यह काम करता है:

 class DKD {
        List<Dictionary<string, string>> dictionaries;
        public DKD(){
            dictionaries = new List<Dictionary<string, string>>();}
        public object this[string key]{
             get{
                string temp;
                List<string> valueList = new List<string>();
                for (int i = 0; i < dictionaries.Count; i++){
                    dictionaries[i].TryGetValue(key, out temp);
                    if (temp == key){
                        valueList.Add(temp);}}
                return valueList;}
            set{
                for (int i = 0; i < dictionaries.Count; i++){
                    if (dictionaries[i].ContainsKey(key)){
                        continue;}
                    else{
                        dictionaries[i].Add(key,(string) value);
                        return;}}
                dictionaries.Add(new Dictionary<string, string>());
                dictionaries.Last()[key] =(string)value;
            }
        }
    }

Answer 17

मैंने जेनेरिक प्रकारों के विस्तार में @ हेक्टर कोरे का उत्तर बदल दिया और इसमें एक कस्टम TryGetValue भी जोड़ दिया।

  public static class ListWithDuplicateExtensions
  {
    public static void Add<TKey, TValue>(this List<KeyValuePair<TKey, TValue>> collection, TKey key, TValue value)
    {
      var element = new KeyValuePair<TKey, TValue>(key, value);
      collection.Add(element);
    }

    public static int TryGetValue<TKey, TValue>(this List<KeyValuePair<TKey, TValue>> collection, TKey key, out IEnumerable<TValue> values)
    {
      values = collection.Where(pair => pair.Key.Equals(key)).Select(pair => pair.Value);
      return values.Count();
    }
  }

Answer 18

यह एक तौलिया तरीका है समवर्ती शब्दकोश मुझे लगता है कि यह आपकी मदद करेगा:

public class HashMapDictionary<T1, T2> : System.Collections.IEnumerable
{
    private System.Collections.Concurrent.ConcurrentDictionary<T1, List<T2>> _keyValue = new System.Collections.Concurrent.ConcurrentDictionary<T1, List<T2>>();
    private System.Collections.Concurrent.ConcurrentDictionary<T2, List<T1>> _valueKey = new System.Collections.Concurrent.ConcurrentDictionary<T2, List<T1>>();

    public ICollection<T1> Keys
    {
        get
        {
            return _keyValue.Keys;
        }
    }

    public ICollection<T2> Values
    {
        get
        {
            return _valueKey.Keys;
        }
    }

    public int Count
    {
        get
        {
            return _keyValue.Count;
        }
    }

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public List<T2> this[T1 index]
    {
        get { return _keyValue[index]; }
        set { _keyValue[index] = value; }
    }

    public List<T1> this[T2 index]
    {
        get { return _valueKey[index]; }
        set { _valueKey[index] = value; }
    }

    public void Add(T1 key, T2 value)
    {
        lock (this)
        {
            if (!_keyValue.TryGetValue(key, out List<T2> result))
                _keyValue.TryAdd(key, new List<T2>() { value });
            else if (!result.Contains(value))
                result.Add(value);

            if (!_valueKey.TryGetValue(value, out List<T1> result2))
                _valueKey.TryAdd(value, new List<T1>() { key });
            else if (!result2.Contains(key))
                result2.Add(key);
        }
    }

    public bool TryGetValues(T1 key, out List<T2> value)
    {
        return _keyValue.TryGetValue(key, out value);
    }

    public bool TryGetKeys(T2 value, out List<T1> key)
    {
        return _valueKey.TryGetValue(value, out key);
    }

    public bool ContainsKey(T1 key)
    {
        return _keyValue.ContainsKey(key);
    }

    public bool ContainsValue(T2 value)
    {
        return _valueKey.ContainsKey(value);
    }

    public void Remove(T1 key)
    {
        lock (this)
        {
            if (_keyValue.TryRemove(key, out List<T2> values))
            {
                foreach (var item in values)
                {
                    var remove2 = _valueKey.TryRemove(item, out List<T1> keys);
                }
            }
        }
    }

    public void Remove(T2 value)
    {
        lock (this)
        {
            if (_valueKey.TryRemove(value, out List<T1> keys))
            {
                foreach (var item in keys)
                {
                    var remove2 = _keyValue.TryRemove(item, out List<T2> values);
                }
            }
        }
    }

    public void Clear()
    {
        _keyValue.Clear();
        _valueKey.Clear();
    }

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

उदाहरण:

public class TestA
{
    public int MyProperty { get; set; }
}

public class TestB
{
    public int MyProperty { get; set; }
}

            HashMapDictionary<TestA, TestB> hashMapDictionary = new HashMapDictionary<TestA, TestB>();

            var a = new TestA() { MyProperty = 9999 };
            var b = new TestB() { MyProperty = 60 };
            var b2 = new TestB() { MyProperty = 5 };
            hashMapDictionary.Add(a, b);
            hashMapDictionary.Add(a, b2);
            hashMapDictionary.TryGetValues(a, out List<TestB> result);
            foreach (var item in result)
            {
                //do something
            }

Answer 19

मैं इस सरल वर्ग का उपयोग करता हूं:

public class ListMap<T,V> : List<KeyValuePair<T, V>>
{
    public void Add(T key, V value) {
        Add(new KeyValuePair<T, V>(key, value));
    }

    public List<V> Get(T key) {
        return FindAll(p => p.Key.Equals(key)).ConvertAll(p=> p.Value);
    }
}

उपयोग:

var fruits = new ListMap<int, string>();
fruits.Add(1, "apple");
fruits.Add(1, "orange");
var c = fruits.Get(1).Count; //c = 2;

Answer 20

आप अपना खुद का शब्दकोश आवरण बना सकते हैं, कुछ इस तरह, एक बोनस के रूप में यह एक कुंजी के रूप में शून्य मान का समर्थन करता है:

/// <summary>
/// Dictionary which supports duplicates and null entries
/// </summary>
/// <typeparam name="TKey">Type of key</typeparam>
/// <typeparam name="TValue">Type of items</typeparam>
public class OpenDictionary<TKey, TValue>
{
    private readonly Lazy<List<TValue>> _nullStorage = new Lazy<List<TValue>>(
        () => new List<TValue>());

    private readonly Dictionary<TKey, List<TValue>> _innerDictionary =
        new Dictionary<TKey, List<TValue>>();

    /// <summary>
    /// Get all entries
    /// </summary>
    public IEnumerable<TValue> Values =>
        _innerDictionary.Values
            .SelectMany(x => x)
            .Concat(_nullStorage.Value);

    /// <summary>
    /// Add an item
    /// </summary>
    public OpenDictionary<TKey, TValue> Add(TKey key, TValue item)
    {
        if (ReferenceEquals(key, null))
            _nullStorage.Value.Add(item);
        else
        {
            if (!_innerDictionary.ContainsKey(key))
                _innerDictionary.Add(key, new List<TValue>());

            _innerDictionary[key].Add(item);
        }

        return this;
    }

    /// <summary>
    /// Remove an entry by key
    /// </summary>
    public OpenDictionary<TKey, TValue> RemoveEntryByKey(TKey key, TValue entry)
    {
        if (ReferenceEquals(key, null))
        {
            int targetIdx = _nullStorage.Value.FindIndex(x => x.Equals(entry));
            if (targetIdx < 0)
                return this;

            _nullStorage.Value.RemoveAt(targetIdx);
        }
        else
        {
            if (!_innerDictionary.ContainsKey(key))
                return this;

            List<TValue> targetChain = _innerDictionary[key];
            if (targetChain.Count == 0)
                return this;

            int targetIdx = targetChain.FindIndex(x => x.Equals(entry));
            if (targetIdx < 0)
                return this;

            targetChain.RemoveAt(targetIdx);
        }

        return this;
    }

    /// <summary>
    /// Remove all entries by key
    /// </summary>
    public OpenDictionary<TKey, TValue> RemoveAllEntriesByKey(TKey key)
    {
        if (ReferenceEquals(key, null))
        {
            if (_nullStorage.IsValueCreated)
                _nullStorage.Value.Clear();
        }       
        else
        {
            if (_innerDictionary.ContainsKey(key))
                _innerDictionary[key].Clear();
        }

        return this;
    }

    /// <summary>
    /// Try get entries by key
    /// </summary>
    public bool TryGetEntries(TKey key, out IReadOnlyList<TValue> entries)
    {
        entries = null;

        if (ReferenceEquals(key, null))
        {
            if (_nullStorage.IsValueCreated)
            {
                entries = _nullStorage.Value;
                return true;
            }
            else return false;
        }
        else
        {
            if (_innerDictionary.ContainsKey(key))
            {
                entries = _innerDictionary[key];
                return true;
            }
            else return false;
        }
    }
}

उपयोग का नमूना:

var dictionary = new OpenDictionary<string, int>();
dictionary.Add("1", 1); 
// The next line won't throw an exception; 
dictionary.Add("1", 2);

dictionary.TryGetEntries("1", out List<int> result); 
// result is { 1, 2 }

dictionary.Add(null, 42);
dictionary.Add(null, 24);
dictionary.TryGetEntries(null, out List<int> result); 
// result is { 42, 24 }

Comments

क्या आप अपने कोड के बारे में कुछ स्पष्टीकरण फेंक सकते हैं, यह कैसे प्रश्न का उत्तर देता है, और कुछ उदाहरणों का उपयोग करता है?

— Enigmativity

@ ऊर्जा, यह वही करता है जो पूछा गया था, सवाल कुछ शब्दकोश का सुझाव देने का था जो डुप्लिकेट का समर्थन करता है, इसलिए मैंने .net शब्दकोश के चारों ओर एक आवरण बनाने की पेशकश की जो इस कार्यक्षमता का समर्थन करेगा और एक उदाहरण के रूप में इस तरह के आवरण को एक बोनस के रूप में बनाया। एक कुंजी के रूप में अशक्त संभाल लें (भले ही यह एक बुरा अभ्यास हो, निश्चित रूप से) उपयोग काफी सरल है: var dictionary = new OpenDictionary<string, int>(); dictionary.Add("1", 1); // The next line won't throw an exception; dictionary.Add("1", 2); dictionary.TryGetEntries("1", out List<int> result); // result is { 1, 2 }

— अलेक्जेंडर टॉलस्टिकोव

क्या आप अपने उत्तर में विवरण जोड़ सकते हैं?

— एनग्मेटीविटी

@ निष्ठा, यदि आप मूल उत्तर से मतलब रखते हैं, तो सुनिश्चित करें

— अलेक्जेंडर टॉलस्टिकोव

Answer 21

यू एक कंपाउंड स्ट्रिंग कुंजी बनाने की विधि को परिभाषित कर सकता है, जहां आप यू का उपयोग करना चाहते हैं, उदाहरण के लिए अपनी कुंजी बनाने के लिए इस विधि का उपयोग करना चाहिए:

private string keyBuilder(int key1, int key2)
{
    return string.Format("{0}/{1}", key1, key2);
}

उपयोग के लिए:

myDict.ContainsKey(keyBuilder(key1, key2))

Answer 22

डुप्लिकेट कुंजियाँ शब्दकोश के पूरे अनुबंध को तोड़ती हैं। एक शब्दकोष में प्रत्येक कुंजी अद्वितीय है और एकल मान पर मैप की गई है। यदि आप किसी ऑब्जेक्ट को अतिरिक्त ऑब्जेक्ट की मनमानी संख्या से लिंक करना चाहते हैं, तो सबसे अच्छा शर्त डेटासेट (आम बोलचाल की मेज में) के समान कुछ हो सकता है। एक कॉलम में अपनी चाबी और दूसरे में अपने मान रखें। यह एक शब्दकोश की तुलना में काफी धीमा है, लेकिन यह महत्वपूर्ण वस्तुओं को हैश करने की क्षमता खोने के लिए आपका व्यापार है।

Comments

प्रदर्शन लाभ के लिए एक शब्दकोश का उपयोग करने के पूरे बिंदु नहीं है? डेटासेट का उपयोग करना सूची <KeyValuePair <T, U >> से बेहतर नहीं लगता है।

— डग

Answer 23

यह भी संभव है:

Dictionary<string, string[]> previousAnswers = null;

इस तरह, हमारे पास अद्वितीय कुंजी हो सकती है। उम्मीद है इससे आपका काम बनेगा।

Comments

ओपी ने एक शब्दकोश के लिए कहा जो डुप्लिकेट कुंजियों की अनुमति देता है।

— स्कापरेट

Answer 24

आप विभिन्न मामलों के साथ समान कुंजी जोड़ सकते हैं:

कुंजी 1
कुंजी 1
कुंजी 1
कुंजी 1
कुंजी 1
कुंजी 1

मुझे पता है कि डमी जवाब है, लेकिन मेरे लिए काम किया है।

Comments

नहीं, यह आपके काम नहीं आया। शब्दकोश बहुत तेजी से देखने की अनुमति देते हैं - जिसे ओ (1) के रूप में भी वर्गीकृत किया जाता है - कुंजी से, आप खो देते हैं कि जब आप अपनी अलग-अलग आवरण वाली कई कुंजियों को जोड़ते हैं, क्योंकि आप उन्हें कैसे पुनः प्राप्त करते हैं? हर ऊपरी / निचले मामले के संयोजन का प्रयास करें? कोई फर्क नहीं पड़ता कि आप इसे कैसे करते हैं, प्रदर्शन सामान्य, एकल शब्दकोश लुकअप नहीं होगा। यह अन्य के अतिरिक्त है, कुंजी में मूल्यों की सीमा के आधार पर अधिक स्पष्ट कमियों जैसे कि कुंजी के अपचनीय पात्रों की संख्या पर निर्भर करता है।

— यूजीन बेरेसोव्स्की