2

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

4

5 回答 5

6

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

于 2012-09-04T22:42:39.027 回答
4

看看这篇文章

“线程安全”字典(TKey,TValue)

于 2012-08-30T04:51:44.457 回答
3

对于 Framework 3.5,我看到以下选项:

我会使用Dictionary + ReaderWriterLockReaderWriterLockSlim

于 2012-10-28T22:21:50.453 回答
2

您可以创建一个简单的包装器,只实现您需要的。请记住,对依赖于先前调用结果的 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);
        }
    }
}
于 2012-08-30T05:28:42.583 回答
1

我只需要.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();

    }
}
于 2018-07-23T18:59:30.467 回答