.NET অভিধানগুলিতে সদৃশ কী?

Question

.NET বেস ক্লাস লাইব্রেরিতে এমন কোনও অভিধানের ক্লাস রয়েছে যা সদৃশ কী ব্যবহার করতে দেয়? আমি খুঁজে পেয়েছি একমাত্র সমাধান হ'ল উদাহরণস্বরূপ, একটি শ্রেণি তৈরি করা:

Dictionary<string, List<object>>

তবে এটি ব্যবহার করতে বেশ বিরক্তিকর। জাভাতে, আমি বিশ্বাস করি যে একটি মাল্টিম্যাপ এটি সম্পাদন করে, তবে। নেট এ এনালগ খুঁজে পাচ্ছে না।

Comments

এই সদৃশ কীটি কীভাবে, এটির সদৃশ মান (তালিকা), ঠিক আছে?

— শামীম হাফিজ

@ শামীম হাফিজ, না, মানগুলি সদৃশ হওয়ার দরকার নেই। আপনার যদি নকল সংরক্ষণ করতে হয় { a, 1 }এবং { a, 2 }একটি হ্যাশ টেবিলে যেখানে aকী হচ্ছে, একটি বিকল্প হ'ল { a, [1, 2] }।

— নওফাল

প্রকৃতপক্ষে, আমি বিশ্বাস করি যে এখানে যা চাইছিল তা হ'ল একটি সংগ্রহ যেখানে প্রতিটি কী এক বা একাধিক মানের মানচিত্র করতে পারে। আমি মনে করি "সদৃশ কী" এক্সপ্রেশনটি সত্যিই এটি প্রকাশ করে না।

— ডেভিডআরআর

ভবিষ্যতের রেফারেন্সের জন্য, আপনাকে একই কীগুলি বারবার যুক্ত করার পরিবর্তে 1 টি কীটি এতে মান যুক্ত করার কথা বিবেচনা করা উচিত।

— ইয়া ওয়াং

যদি কী এবং মান উভয়ই স্ট্রিং থাকে তবে নেমভ্যালু কালেকশন রয়েছে (যা প্রতিটি স্ট্রিং কী এর সাথে একাধিক স্ট্রিংয়ের মানকে সংযুক্ত করতে পারে)।

— আনোরজাকেন

Answer 1

আপনি .NET 3.5 ব্যবহার করছেন, Lookupক্লাসটি ব্যবহার করুন ।

সম্পাদনা: আপনি সাধারণত একটি Lookupব্যবহার তৈরি Enumerable.ToLookup। এটি ধরে নিয়েছে যে পরে আপনার এটি পরিবর্তন করার দরকার নেই - তবে আমি সাধারণত এটি যথেষ্ট ভাল পাই।

যদি এটি আপনার পক্ষে কাজ করে না , তবে আমি মনে করি না যে কাঠামোটিতে এমন কিছু আছে যা সাহায্য করবে - এবং অভিধানটি ব্যবহার করা যতটা ভাল তা পাওয়া যায় :(

Comments

ধন্যবাদ লুড আপ নেওয়ার জন্য ধন্যবাদ। এটি একটি লিনক ক্যোয়ারী থেকে পার্টিশন (গোষ্ঠী) ফলাফলের দুর্দান্ত উপায় সরবরাহ করে যা মানক অর্ডারবাইয়ের মানদণ্ড নয়।

— রবার্ট পলসন

@ জোশ: আপনি একটি তৈরি করতে এনিউমারেবল T টুকলুকআপ ব্যবহার করেন।

— জন স্কিটি

সাবধানতার কথা : Lookupক্রমিক নয়

— স্লাইভারনিজা - এমএসএফটি

কীভাবে আমাদের সেই চেহারাতে আইটেম যুক্ত করা উচিত?

— মোডোভানু

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

তালিকা <কীভ্যালিউপায়ার <স্ট্রিং, স্ট্রিং>> এর সাহায্যে এটি করার একটি উপায় এখানে

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

ফলাফলগুলি কে 1 = ভি 1, কে 1 = ভি 2, কে 1 = ভি 3

Comments

আমার দৃশ্যে দুর্দান্ত এবং ব্যবহার করাও সহজ কাজ করে।

— ব্যবহারকারী 6121177

Answer 4

আপনি উভয় কী ও মান হিসাবে স্ট্রিং ব্যবহার করে থাকেন, আপনি ব্যবহার করতে পারেন System.Collections.Specialized.NameValueCollection , যা GetValues (STRING চাবি) পদ্ধতির মাধ্যমে স্ট্রিং মূল্যবোধের একটি অ্যারের ফিরে আসবে।

Comments

নামভ্যালু সংগ্রহটি একাধিক কী ব্যবহারের অনুমতি দেয় না।

— জেনি ও'রিলি

@ জেনি ও'রেলি: অবশ্যই, আপনি নকল কী যুক্ত করতে পারেন।

— isHuman

কঠোরভাবে @ জেনিও'রিলি বলতে গেলে সঠিক, লিঙ্কযুক্ত এমএসডিএন পৃষ্ঠায় মন্তব্যগুলি পরিষ্কারভাবে বলে: এই শ্রেণিটি একক কী এর অধীনে একাধিক স্ট্রিংয়ের মান সংরক্ষণ করে ।

— রোনাল্ড

এটি অনুমতি দেবে তবে একাধিক মান ফিরিয়ে দেবে, আমি সূচি এবং কী ব্যবহার করার চেষ্টা করেছি।

— ব্যবহারকারী 6121177

Answer 5

আমি সবেমাত্র পাওয়ার কালেকশন লাইব্রেরি জুড়ে এসেছি যার মধ্যে অন্যান্য জিনিসগুলির সাথে মাল্টি ডিকশনারি নামে একটি ক্লাস রয়েছে। এটি ঝরঝরেভাবে এই ধরণের কার্যকারিতা আবদ্ধ করে।

Answer 6

লুকআপ ব্যবহার সম্পর্কিত অত্যন্ত গুরুত্বপূর্ণ নোট:

আপনি কার্যকর একটি অবজেক্টে Lookup(TKey, TElement)কল ToLookupকরে একটি উদাহরণ তৈরি করতে পারেনIEnumerable(T)

এর কোনও নতুন উদাহরণ তৈরি করার জন্য কোনও পাবলিক কনস্ট্রাক্টর নেই Lookup(TKey, TElement)। অতিরিক্তভাবে, Lookup(TKey, TElement)অবজেক্টগুলি অপরিবর্তনীয়, অর্থাৎ আপনি কোনও Lookup(TKey, TElement)বস্তু তৈরির পরে উপাদান বা কীগুলি যুক্ত বা সরাতে পারবেন না ।

(এমএসডিএন থেকে)

আমি মনে করি এটি বেশিরভাগ ব্যবহারের জন্য শো স্টপার হবে।

Comments

আমি খুব কম ব্যবহারের কথা ভাবতে পারি যেখানে এটি শো স্টপার হবে। তবে তারপরে, আমার মনে হয় অপরিবর্তনীয় জিনিসগুলি দুর্দান্ত।

— জোয়েল মুলার

@ জোয়েলমিউলার আমি এমন অনেকগুলি ক্ষেত্রে ভাবতে পারি যেখানে এটি শো স্টপার। কোনও আইটেম যুক্ত করার জন্য একটি অভিধান পুনরায় তৈরি করা কোনও বিশেষ সমাধান নয় ...

— রিরব

Answer 7

আমি মনে করি List<KeyValuePair<object, object>>জব এর মতো কিছু করবে।

Comments

আপনি কীভাবে তালিকার কিছুতে কীটির কী দিয়ে দেখছেন?

— ওয়েইন ব্লস

আপনাকে এটির মাধ্যমে পুনরাবৃত্তি করতে হবে: তবে আমি .NET 3.5 এর লুকআপ-ক্লাস সম্পর্কে অবগত ছিলাম না: এটি এর সামগ্রীতে অনুসন্ধানের জন্য এটি আরও কার্যকর।

— এমএডম্যাপ

@ উইজলিব: একমাত্র উপায় হল তালিকাটি লুপ করা যা হ্যাশিংয়ের মতো প্রায় দক্ষ নয়। -1

— পেটার কে।

@petrk। এটি আপনার ডেটা কীসের উপর নির্ভর করে। আমি এই বাস্তবায়নটি ব্যবহার করেছি কারণ আমার খুব কম অনন্য কী রয়েছে এবং হ্যাশের সংঘর্ষগুলির ওভারহেড ব্যয় করতে চান না। +1

— ইভান এম

Answer 8

আপনি যদি> =। নেট 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>>উপরের মত একটি সমাধান মত দেখায় । আমি কি ভূল?

— নাথান Goings

Answer 9

"ডুপ্লিকেট কী" এন্ট্রিগুলিকে মঞ্জুরি দেয় এমন কোনও অভিধানের "নিজের নিজস্ব সংস্করণ" রোল করা যথেষ্ট সহজ। এখানে মোটামুটি সহজ বাস্তবায়ন is আপনি মূলত সর্বাধিক (সমস্ত না থাকলে) সমর্থন যোগ করার বিষয়টি বিবেচনা করতে পারেন 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/ মাল্টিকেকিড অভিধান.এএসপিএক্স

Answer 11

নেমভ্যালু কালেকশনটি একটি কী এর অধীনে একাধিক স্ট্রিং মানকে সমর্থন করে (যা একটি স্ট্রিংও) তবে এটি সম্পর্কে আমি অবগত একমাত্র উদাহরণ।

আমি যখন আপনার এমন ধরণের কার্যকারিতা প্রয়োজন তখন আমার দৃষ্টান্তের মতোই কন্সট্রাক্টস তৈরির প্রবণতা রাখি।

Answer 12

List<KeyValuePair<string, object>>বিকল্পটি ব্যবহার করার সময় , আপনি অনুসন্ধান করতে লিনকিউ ব্যবহার করতে পারেন:

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

যেহেতু নতুন সি # (আমি এটি 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

আপনার অর্থ কি একত্রিত করা এবং প্রকৃত সদৃশ নয়? অন্যথায় একটি হ্যাশটেবল কাজ করতে সক্ষম হবে না।

একত্রিত হওয়ার অর্থ দুটি পৃথক কী সমান মানের হ্যাশ করতে পারে তবে কীগুলি সমান নয়।

উদাহরণস্বরূপ: বলুন যে আপনার হ্যাশ টেবিলের হ্যাশ ফাংশনটি হ্যাশওয়াল = কী মোড 3.. উভয়ই 1 এবং 4 টি মানচিত্র 1 পর্যন্ত, তবে বিভিন্ন মান। এখানেই আপনার তালিকার একটি ধারণা কার্যকর হয়।

আপনার যখন 1 অনুসন্ধান করতে হবে তখন সেই মানটি 1 এ চলে গেছে, কী = 1 সন্ধান না হওয়া পর্যন্ত তালিকাটি ট্র্যাশ করা হবে।

যদি আপনি সদৃশ কীগুলি সন্নিবেশ করার অনুমতি দেয় তবে আপনি কোন মানগুলি কোন মানগুলি মানচিত্রের মধ্যে পার্থক্য করতে পারবেন না।

Comments

একটি হ্যাশ টেবিল ইতিমধ্যে কীগুলি পরিচালনা করে যা হ্যাশের সাথে একই মানের হয়ে যায় (এটিকে সংঘর্ষ বলা হয়)। আমি এমন একটি পরিস্থিতিতে উল্লেখ করছি যেখানে আপনি একই সঠিক কীতে একাধিক মান মানচিত্র করতে চান।

Answer 15

আমি যেভাবে ব্যবহার করি তা কেবল একটি

Dictionary<string, List<string>>

এইভাবে আপনার কাছে একটি একক কী রয়েছে তার একটি তালিকা রয়েছে list

উদাহরণ:

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

Comments

এটা সুন্দর এবং পরিষ্কার।

— জেরি নিকসন

এটি আমার ব্যবহারের কেসটি পরিচালনা করার জন্য দুর্দান্ত সমাধান।

— ডাব স্টাইল 21

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

আমি @ হেক্টর কোরিয়ার উত্তরটিকে জেনেরিক ধরণের সাথে একটি এক্সটেনশনে পরিবর্তন করেছি এবং এটিতে একটি কাস্টম ট্রাইগেটভ্যালুও যুক্ত করেছি।

  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

আপনার কোড কী করে, কীভাবে প্রশ্নটির উত্তর দেয় এবং কয়েকটি উদাহরণ ব্যবহার করে তার চারপাশে আপনি কিছু ব্যাখ্যা ছুঁড়ে দিতে পারেন?

— শিরোনাম

@ দক্ষতা, এটি যা অনুরোধ করেছিল ঠিক তাই করে, প্রশ্নটি হ'ল ডুপ্লিকেটগুলিকে সমর্থন করে এমন কিছু অভিধানের পরামর্শ দেওয়ার জন্য, তাই আমি। নেট অভিধানের চারপাশে একটি মোড়ক তৈরি করার প্রস্তাব দিয়েছিলাম যা এই কার্যকারিতাটি সমর্থন করবে এবং উদাহরণ হিসাবে যেমন একটি মোড়ক তৈরি করতে পারে, বোনাস হিসাবে এটি করতে পারে কী হিসাবে নাল হ্যান্ডেল করুন (এটি একটি খারাপ অভ্যাস হলেও, নিশ্চিতভাবেই) ব্যবহারটি বেশ সহজ: 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

পারফরম্যান্স লাভের জন্য অভিধান ব্যবহারের পুরো পয়েন্টটি কি নয়? ডেটাসেট ব্যবহার করা <কীভ্যালিউপায়ার <টি, ইউ >> এর চেয়ে ভাল বলে মনে হয় না।

— ডগ

Answer 23

এছাড়াও এটি সম্ভব:

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

এইভাবে, আমাদের অনন্য কীগুলি থাকতে পারে। আশা করি এটি আপনার পক্ষে কাজ করে।

Comments

ওপি এমন একটি অভিধান চেয়েছিল যা সদৃশ কীগুলিকে অনুমতি দেয়।

— স্ক্যাপারেতে

Answer 24

আপনি বিভিন্ন কেসের সাথে একই কী যুক্ত করতে পারেন:

কী 1
কী 1
কেই 1 1
কেওয়াই 1
কেই 1
কেওয়াই 1

আমি জানি জঘন্য উত্তর, তবে আমার পক্ষে কাজ করেছে।

Comments

না, এটি আপনার পক্ষে কার্যকর হয়নি। অভিধানগুলি খুব দ্রুত দেখার অনুমতি দেয় - ও (1) হিসাবে শ্রেণীবদ্ধ - কী অনুসারে, আপনি যখন আপনার ভিন্ন ভিন্ন কেসযুক্ত একাধিক কী যুক্ত করেন তখন আপনি তা হারাবেন কারণ আপনি কীভাবে সেগুলি পুনরুদ্ধার করবেন? প্রতিটি আপার / লোয়ার কেস কম্বিনেশন চেষ্টা করে দেখুন? আপনি এটি কীভাবে করেন না কেন, পারফরম্যান্সটি সাধারণ, একক অভিধানের অনুসন্ধানের মতো হবে না। এটি অন্যান্য ছাড়াও আরও কী হিসাবে মূল্যগুলির সীমাবদ্ধতার মতো আরও সুস্পষ্ট ত্রুটি, কীতে থাকা আপসেসেবল অক্ষরের সংখ্যার উপর নির্ভর করে।

— ইউজিন বেরেসভস্কি