Question

我需要线程安全集合，但无法使用ConcurrentDictionary作为其.NET 4.0，我需要使用.NET 3.5。那里有什么替代品？

Answer 1

最后，我找到了我追求的东西。 TPL的nuget包向后移植到3.5。在这里能找到它 http://nuget.org/packages/TaskParallelLibrary

Answer 2

看一下这篇文章

“Thread safe” Dictionary(TKey,TValue)

Answer 3

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

字典 + Monitor。简单包装到 lock
字典 + ReaderWriterLock。比前一个好，因为有读写锁。所以有几个线程可以读取，只有一个 - 写。
字典 + ReaderWriterLockSlim。这只是对前一个的优化。
Hashtable。根据我的经验，这是最慢的方法。检查Hashtable.Synchronized()方法，这是微软准备好的解决方案。

我会使用 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();

    }
}

我应该使用什么作为System.Collections.Concurrent.ConcurrentDictionary（3.5）的替代品

5 个答案: