如何使此 Dictionary TryGetValue 代码更具可读性？

Question

我想测试一个 id 是否未知，或者如果已知，则关联的值是否已更改。我目前正在使用与此类似的代码，但对于那些不熟悉该模式的人来说很难理解。你能想出一种方法使其更具可读性，同时保持 LOC 简短吗？

string id;
string actual;
string stored;

if (!someDictionary.TryGetValue (id, out stored) || stored != actual) {
    // id not known yet or associated value changed.
}

Answer 1

您可以编写一个具有好名称的扩展方法：

public static class Utility
{
    public static bool ValueChangedOrUnknown(this Dictionary<string, string> dictionary, string id, string actual)
    {
        string stored = null;
        return (!dictionary.TryGetValue(id, out actual) || stored != actual);
    }
}

以便稍后您可以使用

string id;
string actual;

if (someDictionary.ValueChangedOrUnknown(id, actual) {
    // id not known yet or associated value changed.
}

Answer 2

所以我很可能会把它分解并给它有意义的名字。这是更多需要阅读的内容，但您不需要在评论中说太多：

bool isKnown = someDictionary.TryGetValue (id, out stored);
// can only change when it is known
bool valueChanged = isKnown && stored != actual;

// quite self-explanatory, isn't it?
if (!isKnown || valueChanged) 
{

}

Answer 3

包裹 || 的每个部分进入它自己的方法或属性，而不是你可以这样写

if ( IdIsNew() || IdChanged())

Answer 4

二元性。

if (!(someDictionary.TryGetValue (id, out stored) && stored == actual)) ...

虽然不确定它是否更具可读性...但很高兴知道。

Answer 5

它对我来说看起来不错...读起来和任何其他 2 个条件 if 语句一样简单。我唯一可能改变的就是翻转否定以提前退出：

if (someDictionary.TryGetValue(id, out stored) && stored == actual) {
    return;
}
// store new value

我根本没有看到任何混乱，从来没有认为它是一个特别麻烦的习惯用法，并谦虚地建议那些 C# 开发人员感到困惑就这样习惯了。它很常见、简洁，并且为问题提供了尽可能多的 LOC。将其变成 10 行代码使其变得太重要了。

如果我经常使用它，那么名为 ContainsEqualValue 之类的扩展方法将是合适的 - 但我会在扩展方法中使用与您完全相同的代码。

Answer 6

我更喜欢一种新方法：

public bool ShouldSetValue(Dictionary someDictionary, object id,object actualValue)
{
    string stored;

    if (someDictionary.TryGetValue (id, out stored)) 
    {
        if (stored != actualValue)
            return true;
    }
    else
    {
        return true;
    }
}

然后在现有方法中我只需：

if (ShouldSetValue(someDictionary,id,actual))
{
     someDictionary[id]=actual;
}

Answer 7

扩展方法会很灵活：

public static class DictionaryExtensions
{
    public static bool ShouldAddValue<TKey, TValue>(this Dictionary<TKey, TValue> someDictionary, TKey id, TValue actual)
    {
        TValue stored;
        return (!someDictionary.TryGetValue(id, out stored) || !stored.Equals(actual)); 
    }
}

用法：

someDictionary.ShouldAddValue("foo", "bar")

Answer 8

如果您的意思是必须重复执行此操作，并且它又长又难看，请将逻辑抽象到另一个类并使用扩展方法。

public static class DictionaryExtensions
{
    public static DictionaryChecker<TKey,TValue> contains<TKey,TValue>(this IDictionary<TKey,TValue> dictionary, TValue value)
    {
        return new DictionaryChecker<TKey,TValue>(value, dictionary);
    }
}

public class DictionaryChecker<TKey,TValue>
{
    TValue value;
    IDictionary<TKey,TValue> dictionary;

    internal DictionaryChecker(TValue value, IDictionary<TKey, TValue> dictionary)
    {
        this.value = value;
        this.dictionary = dictionary;
    }

    public bool For(TKey key)
    {
        TValue result;
        return dictionary.TryGetValue(key, out result) && result.Equals(value);
    }
}

现在将您的代码替换为：

if(!someDictionary.contains(actual).For(id)){
    // id not known yet or associated value changed.
}

Answer 9

public T GetValue(int id, object actual)
{
  object stored;
 if (someDictionary.TryGetValue (id, out stored) || stored == actual) 
    return stored;
  return new object();
}

Answer 10

虽然我认识到“try”模式是必要的，但我不喜欢需要“out”参数的实现。与 TryGetValue 类似的函数似乎更有用：

• 如果键不在字典中，TryGetDictValue(dictionary, key) 返回 null
• 如果键不在字典中，则 TryGetDictValue(dictionary, key, defaultValue) 返回 defaultValue
• TryGetDictValue(dictionary, key, valueReturningDelegate)如果键不在字典中，则调用提供的委托并返回其结果

在每种情况下，结果的返回类型将是字典数据的返回类型。

可惜没有办法潜入时间机器，让这些东西成为 Dictionary 的方法。另一方面，可以将它们实现为静态函数，将字典作为第一个参数。