Wie kann ich diesen Wörterbuch-TryGetValue-Code lesbarer machen?

Question

Ich möchte testen, ob eine ID noch nicht bekannt war oder, falls bekannt, ob sich der zugehörige Wert geändert hat. Ich verwende derzeit Code ähnlich, aber es ist schwer zu verstehen für diejenigen, die nicht mit dem Muster vertraut sind. Können Sie sich einen Weg vorstellen, um es lesbarer zu machen, während Sie es im LOC kurz halten?

string id; 
string actual; 
string stored; 

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

Answer 1

Es sieht gut zu mir ... liest so einfach wie jede andere 2 Bedingung if-Anweisung. Über das einzige, was ich vielleicht ist ändern würde die Negationen für einen frühzeitigen Ausstieg zu kippen:

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

ich keine Verwirrung in es überhaupt nicht sehen, die noch nie als besonders störend Idiom daran gedacht, und Demut suggerieren, dass sich diese von ihm verwirrten C# Entwickler daran gewöhnen. Es ist üblich, succint und gibt so viele LOC an das Problem, wie es verdient. Drehen Sie es in 10 Zeilen Code macht es Weg zu wichtig.

Wenn ich es oft verwendete, wäre eine Extension-Methode namens etwa ContainsEqualValue geeignet - aber ich würde den exakt gleichen Code in der Erweiterungsmethode verwenden, wie Sie haben.

Answer 2

Also würde ich es wahrscheinlich zerlegen und ihm aussagekräftige Namen geben. Dies ist mehr zu lesen, aber Sie brauchen nicht viel zu sagen in Kommentaren:

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

Duality.

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

Nicht sicher, ob es zwar lesbarer ist ... aber es ist gut zu wissen.

Answer 4

jeden Teil der || in seine eigenen Methode oder Eigenschaft, als Sie es wie diese

if (IdIsNew() || IdChanged()) 

Answer 5

ich eine neue Methode würde es vorziehen, schreiben:

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; 
    } 
} 

dann in der bestehenden Methode würde ich nur:

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

Answer 6

Sie können eine Erweiterungsmethode mit einem guten Namen schreiben:

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); 
    } 
} 

so später können Sie

string id; 
string actual; 

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

Answer 7

Eine Erweiterung Methode wäre glatt verwenden:

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)); 
    } 
} 

Verbrauch:

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

Answer 8

Wenn Sie meinen, dass Sie immer wieder, dies zu tun haben, und es ist lang und hässlich, abstrahiere die Logik einer anderen Klasse und verwende eine Erweiterungsmethode.

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); 
    } 
} 

Jetzt Ihren Code ersetzen:

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

Während ich erkennen, dass die „versuchen“ Muster notwendig ist, ich mag nicht Implementierungen, die eine „out“ Parameter erfordern. Es wäre viel nützlicher Funktionen haben scheinen ähnlich wie TryGetValue:

• TryGetDictValue (Wörterbuch, key) gibt null zurück, wenn Schlüssel nicht im Wörterbuch ist
• TryGetDictValue (Wörterbuch, Schlüssel, default) liefert default wenn Schlüssel nicht in Wörterbuch
• TryGetDictValue (Wörterbuch, Schlüssel, valueReturningDelegate) ruft die mitgelieferte Delegat, wenn Schlüssel nicht im Wörterbuch ist und gibt das Ergebnis

in jedem Fall wird der Rückgabetyp des Ergebnisses, dass der Wörterbuch der Daten wäre.

Es ist schade, dass es keine Möglichkeit gibt, sich in eine Zeitmaschine zu schleichen und solche Dinge zu Methoden des Wörterbuchs zu machen. Auf der anderen Seite könnte man sie als statische Funktionen implementieren, indem man ein Wörterbuch als ersten Parameter nimmt.