როგორ განვახორციელოთ Dictionary-ი, რომ არ გამოვიყენოთ ConcurrentDictionary?

მოწყობილობის უსაფრთხო Dictionary-ის განხორციელებისთვის, რომელიც არ იყენებს ConcurrentDictionary-ს, შეიძლება გამოიყენოთ სინქრონიზაციის პრიმიტივები System.Threading-დან.

ძირითადი მიდგომები:

1. საერთო ლოკის გამოყენება (lock): ყველა წაკითხვასა და დაწერაზე ოპერაციის გარშემო ჩასმა lock-ით ერთსა და იმავე სინქრონიზაციის ობიექტზე.

   // ობიექტი მონაცემთა ბაზის წვდომის სინქრონიზაციისთვის
   private readonly object _lockObject = new object();
   private readonly Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();
   
   public void AddOrUpdate(TKey key, TValue value)
   {
       lock (_lockObject)
       {
           if (_dictionary.ContainsKey(key))
           {
               _dictionary[key] = value;
           }
           else
           {
               _dictionary.Add(key, value);
           }
       }
   }
   
   public bool TryGetValue(TKey key, out TValue value)
   {
       lock (_lockObject)
       {
           return _dictionary.TryGetValue(key, out value);
       }
   }
   
   public bool TryRemove(TKey key, out TValue value)
   {
       lock (_lockObject)
       {
           if (_dictionary.TryGetValue(key, out value))
           {
               _dictionary.Remove(key);
               return true;
           }
           return false;
       }
   }
   

   უპირატესობები: მარტივი რეალიზაცია. მინუსები: დაბალი შესრულება მაღალი კონკურენციის დროს, რადგან ლოკი იკეტება მთელი მონაცემთა ბაზისთვის წაკითხვასა და დაწერაზე.

2. ReaderWriterLockSlim-ის გამოყენება: საშუალებას აძლევს განყენოს ლოკები წაკითხვასა და დაწერაზე. რამდენიმე ნაკადი ერთდროულად წაიკითხავს, მაგრამ მხოლოდ ერთი ნაკადი შეძლებს დაწერას.

   private readonly ReaderWriterLockSlim _lockSlim = new ReaderWriterLockSlim();
   private readonly Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();
   
   public void AddOrUpdate(TKey key, TValue value)
   {
       _lockSlim.EnterWriteLock();
       try
       {
           if (_dictionary.ContainsKey(key))
           {
               _dictionary[key] = value;
           }
           else
           {
               _dictionary.Add(key, value);
           }
       }
       finally
       {
           _lockSlim.ExitWriteLock();
       }
   }
   
   public bool TryGetValue(TKey key, out TValue value)
   {
       _lockSlim.EnterReadLock();
       try
       {
           return _dictionary.TryGetValue(key, out value);
       }
       finally
       {
           _lockSlim.ExitReadLock();
       }
   }
   
   public bool TryRemove(TKey key, out TValue value)
   {
       _lockSlim.EnterWriteLock();
       try
       {
           if (_dictionary.TryGetValue(key, out value))
           {
               _dictionary.Remove(key);
               return true;
           }
           return false;
       }
       finally
       {
           _lockSlim.ExitWriteLock();
       }
   }
   

   უპირატესობები: უკეთესი შესრულება წაკითხვაზე ინტენსიური ოპერაციების დროს, შედარებით lock-თან. მინუსები: უფრო რთული რეალიზაცია, ვიდრე უბრალო lock-ით.

აირჩიეთ ეს მიდგომა თქვენი მონაცემთა ბაზის გამოყენების სპეციფიკიდან, წაკითხვებისა და დაწერების ოპერაციების თანაფარდობიდან და საჭირო შესრულების დონიდან. ReaderWriterLockSlim ჩვეულებრივ უპირატესია ხშირი წაკითხვების დროს.