Kā īstenot Dictionary, neizmantojot…

Lai īstenotu sērijas drošu Dictionary bez ConcurrentDictionary, var izmantot sinhronizācijas primitivus no System.Threading telpas.

Galvenie pieejas veidi:

Visa vārdnīcas bloķēšana (lock): Visu lasīšanas un rakstīšanas operāciju ietveršana lock ar to pašu sinhronizācijas objektu.

// Objekts vārdnīcas piekļuves sinhronizācijai
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;
    }
}

Priekšrocības: Vienkārša realizācija. Trūkumi: Zema veiktspēja augstas konkurences apstākļos, jo bloķēta ir visa vārdnīca pat lasīšanas operāciju laikā.

Izmantojot ReaderWriterLockSlim: Atļauj atdalīt bloķēšanu lasīšanas un rakstīšanas operācijām. Dažas plūsmas var vienlaikus lasīt, bet tikai viena rakstīt.

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

Priekšrocības: Labāka veiktspēja salīdzinājumā ar lock intensīvu lasīšanas operāciju laikā. Trūkumi: Sarežģītāka realizācija nekā ar vienkāršu lock.

Izvēle starp šiem pieejas veidiem ir atkarīga no vārdnīcas izmantošanas specifikas, lasīšanas un rakstīšanas operāciju attiecības un nepieciešamā veiktspējas līmeņa. ReaderWriterLockSlim parasti ir priekšroka, ja ir biežas lasīšanas operācijas.

Kā īstenot Dictionary, neizmantojot ConcurrentDictionary?