c# - 我应该使用什么来替代 System.Collections.Concurrent.ConcurrentDictionary (3.5)

Question

我需要一个线程安全的集合，但无法使用 ConcurrentDictionary 作为其 .NET 4.0，我需要使用 .NET 3.5。有哪些替代品？

Answer 1

最后我找到了我想要的。向后移植到 3.5 的 TPL 的 nuget 包。可以在这里找到 http://nuget.org/packages/TaskParallelLibrary

Answer 2

看看这篇文章

“线程安全”字典（TKey,TValue）

Answer 3

对于 Framework 3.5，我看到以下选项：

• 字典+监视器。简单的换行锁定
• 字典+ ReaderWriterLock。比前一个更好，因为有读写锁。所以几个线程可以读取，只有一个 - 写入。
• 字典+ ReaderWriterLockSlim。这只是对上一个的优化。
• 哈希表。根据我的经验，这是最慢的方法。检查Hashtable.Synchronized()方法，这是 Microsoft 的现成解决方案。

我会使用Dictionary + ReaderWriterLock或ReaderWriterLockSlim。

Answer 4

您可以创建一个简单的包装器，只实现您需要的。请记住，对依赖于先前调用结果的 Dictionary 执行操作不是线程安全的。这在TryAdd方法中得到了例证。

class ConcurrentMap<K, V>
{
    readonly Dictionary<K, V> _map = new Dictionary<K, V>();

    public bool TryGetValue(K key, out V value)
    {
        lock (_map)
        {
            return _map.TryGetValue(key, out value);
        }
    }

    public bool TryAdd(K key, V value)
    {
        lock (_map)
        {
            if (!_map.ContainsKey(key))
            {
                _map.Add(key, value);
                return true;
            }
            return false;
        }
    }

    public bool TryRemove(K key)
    {
        lock (_map)
        {
            return _map.Remove(key);
        }
    }
}

Answer 5

我只需要.Net 3.5 ......有人还在那里:)

添加我的课程，添加了比以前附加的代码更多的功能。

 public class SafeDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{

    private readonly object _Padlock = new object();

    private readonly Dictionary<TKey, TValue> _Dictionary = new Dictionary<TKey, TValue>();
    public TValue this[TKey key]
    {
        get
        {
            lock (_Padlock)
            {
                return _Dictionary[key];
            }
        }

        set
        {
            lock (_Padlock)
            {
                _Dictionary[key] = value;
            }
        }
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        lock (_Padlock)
            return _Dictionary.TryGetValue(key, out value);

    }
public bool TryAdd(TKey key, TValue value)
{
    lock (_Padlock)
    {
        if (!_Dictionary.ContainsKey(key))
        {
            _Dictionary.Add(key, value);
            return true;
        }
        return false;
        }
  }

public bool TryRemove(TKey key)
{
    lock (_Padlock)
    {
        return _dictionary.Remove(key);
    }
}
}

    internal void Add(TKey key, TValue val)
    {
        lock (_Padlock)
        {
            _Dictionary.Add(key, val);
        }
    }

    public bool ContainsKey(TKey id)
    {
        lock (_Padlock)
            return _Dictionary.ContainsKey(id);
    }

    public List<KeyValuePair<TKey, TValue>> OrderBy(Func<KeyValuePair<TKey, TValue>, TKey> func)
    {
        lock (_Padlock)
            return _Dictionary.OrderBy(func).ToList();
    }

    public Dictionary<TKey, TValue>.ValueCollection Values
    {
        get
        {
            lock (_Padlock)
                return _Dictionary.Values;
        }
    }
    public Dictionary<TKey, TValue>.KeyCollection Keys
    {
        get
        {
            lock (_Padlock)
                return _Dictionary.Keys;
        }
    }





    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        lock (_Padlock)
            return _Dictionary.GetEnumerator();

    }



    IEnumerator IEnumerable.GetEnumerator()
    {
        lock (_Padlock)
            return _Dictionary.GetEnumerator();

    }
}