ConcurrentDictionary kullanmadan Dictionary nasıl…

ConcurrentDictionary kullanmadan thread-safe bir Dictionary uygulaması yapmak için System.Threading isim alanından senkronizasyon primitive'leri kullanabilirsiniz.

Ana yaklaşımlar:

Tüm sözlüğü kilitle (lock): Tüm okuma ve yazma işlemlerini aynı senkronizasyon nesnesini kullanarak bir lock bloğuna alın.

// Sözlüğe erişimi senkronize etmek için nesne
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ı: Basit uygulama. Eksileri: Yüksek rekabet durumunda düşük performans, çünkü okuma işlemleri bile tüm sözlüğe erişim engellenir.

ReaderWriterLockSlim kullanımı: Okuma ve yazma işlemleri için kilitleri ayırmaya izin verir. Birden fazla thread aynı anda okuyabilir, ancak sadece biri yazabilir.

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 ile karşılaştırıldığında okuma yoğun işlemlerde daha iyi performans sağlar. Eksileri: Basit lock'a göre daha karmaşık bir uygulama.

Bu yaklaşımlar arasındaki seçim, sözlüğün kullanım özelliklerine, okuma ve yazma işlemlerinin oranına ve performans gereksinimlerine bağlıdır. ReaderWriterLockSlim, sık okuma işlemleri için genellikle tercih edilir.

ConcurrentDictionary kullanmadan Dictionary nasıl uygulanır?