ConcurrentDictionary istifadə etmədən Dictionary necə…

ConcurrentDictionary istifadə etmədən axın-safe Dictionary-nin həyata keçirilməsi üçün System.Threading ad sahəsindən sinxronizasiya primitivləri tətbiq oluna bilər.

Əsas yanaşmalar:

Bütnü bütün lüğət üçün kilidləmək (lock): Bütün oxuma və yazma əməliyyatlarını eyni sinxronizasiya obyekti ilə lock daxilində əhatə etmək.

// Lüğətə giriş üçün sinxronizasiya obyekti
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;
    }
}

Artılar: Sadə tətbiq. Eksilər: Yüksək tələbat zamanı aşağı performans, çünki oxuma əməliyyatları zamanı belə bütün lüğət bloklanır.

ReaderWriterLockSlim istifadə etmək: Oxuma və yazma əməliyyatları üçün bloklamaları ayırmağa imkan verir. Bir neçə axın eyni zamanda oxuya bilər, amma yalnız bir axın yaza bilər.

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

Artılar: lock ilə müqayisədə oxuma əməliyyatları intensiv olduqda daha yaxşı performans. Eksilər: Sadə lock-a nisbətən daha mürəkkəb tətbiq.

Bu yanaşmalar arasından seçim lüğətin istifadə xüsusiyyətlərinə, oxuma və yazma əməliyyatlarının nisbətinə və tələb olunan performansa əsaslanır. ReaderWriterLockSlim adətən oxuma əməliyyatları çox olan hallarda üstünlük təşkil edir.

ConcurrentDictionary istifadə etmədən Dictionary necə həyata keçirmək olar?