尝试从 C# 中的 ConcurrentDictionary 中删除键值对

Question

我的情况是我想要一个像这样在ConcurrentDictionary 上的方法。

bool TryRemove(TKey key, TValue value) {
    // remove the value IF the value passed in == dictionary[key]
    // return false if the key is not in the dictionary, or the value is not equal
}

有没有办法同时做到这一点？我正在努力寻找这种情况的答案，尽管这似乎是一个常见的用例。

我可以做这样的事情，但如果我已经在使用ConcurrentDictionary，我想避免锁定。我还必须锁定 GetOrAdd() 或 AddOrUpdate() 其他地方的电话。似乎应该有更好的方法使用ConcurrentDictionary。

ConcurrentDictionary<int, string> dict = ...;

/// stuff

int keyTryToRemove = 1337;
string valTryToRemove = "someValue";

bool success = false;
lock(keyTryToRemove) {
    string val;
    if (dict.TryRemove(keyTryToRemove, out val)) {
        if (val == valTryToRemove) {
            success = true;
        }
        else { // reinsert value, UGLY!
            dict[keyTryToRemove] = val;
            success = false;
        }
    } else {
        success = false;
    }
}

Answer 1

由于ConcurrentDictionary<TKey, TValue> 类实现（虽然显式）IDictionary<TKey, TValue>，因此ICollection<KeyValuePair<TKey, TValue>>，您可以简单地将其转换为后者并使用Remove 方法，如下所示：

bool success = ((ICollection<KeyValuePair<TKey, TValue>>)dict).Remove(
    new KeyValuePair<TKey, TValue>(key, value));

implementation 在内部使用与公共 TryRemove 方法相同的线程安全方法（另外传递要检查的值） - 完全符合其应有的要求。

编辑： 一般而言，通过引入像这样的自定义扩展方法：

public static class Extensions
{
    public static bool TryRemove<TKey, TValue>(this ICollection<KeyValuePair<TKey, TValue>> source, TKey key, TValue value)
    {
        return source.Remove(new KeyValuePair<TKey, TValue>(key, value));
    }
}

这样示例代码就变得简单了：

bool success = dict.TryRemove(key, value);

Answer 2

我会做这样的事情

bool success = false;
lock(lockForDictionary) 
{
    string val;
    if (dict.TryGetValue(keyTryToRemove, out val) && val == valTryToRemove) 
    {
        dict.Remove(keyTryToRemove);
        success = true;
    } 
}

Answer 3

您可以在IDictionary 上编写类似这样的扩展方法。

public static class DictionaryHelper
{
    public static bool TryRemoveIfValue<TKey, TValue>(this IDictionary<TKey,TValue> owner, TKey key, TValue value)
    {
        var success = false;
        lock (owner)
        {
            TValue existingValue;
            if (owner.TryGetValue(key, out existingValue))
            {
                if (value.Equals(existingValue))
                {
                    owner.Remove(key);
                    success = true;
                }
            }
        }
        return success;
    }
}

Answer 4

下面是一段代码，可以稍微简化一下步骤。

readonly object _locker = new object();
readonly ConcurrentDictionary<int, string> _dict = new ConcurrentDictionary<int, string>();

public bool TryRemove(int key, string value)
{
    var success = false;
    lock (_locker)
    {
        if (_dict.ContainsKey(key) && _dict[key] == value)
        {
            string val;
            success = _dict.TryRemove(key, out val);
        }
    }
    return success;
}

话虽如此，似乎目标本质上是非原子的，这就是我们需要锁的原因。重要的是要问，你的目标是什么，你能以原子的方式表达目标。 ConcurrentDictionary 的 2 个有用方法包括 TryUpdate 和 AddOrUpdate。这些方法有什么帮助吗？