Come posso rendere più leggibile questo codice TryGetValue del dizionario?

Question

Vorrei provare se un ID non era ancora noto o, se è noto, se il valore associato è cambiato. Attualmente sto usando un codice simile a questo, ma è difficile da capire per chi non ha familiarità con il modello. Riesci a pensare a un modo per renderlo più leggibile senza tenerlo a 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

Si guarda bene a me ... recita facile come qualsiasi altra condizione di 2 if. L'unica cosa che vorrei cambiare forse è quello di capovolgere le negazioni per una rapida uscita:

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

non vedo qualsiasi confusione a tutti, non hanno mai pensato a come un linguaggio particolarmente fastidioso, e umilmente suggerisco che quegli sviluppatori di C# confusi da esso si abituino ad esso. È comune, succint e fornisce il numero di LOC al problema che merita. Trasformarlo in 10 righe di codice lo rende così importante come modo.

Se l'ho usato spesso, un metodo di estensione chiamato qualcosa come ContainsEqualValue sarebbe appropriato - ma io userei lo stesso codice esatto nel metodo di estensione come avete.

Answer 2

Quindi probabilmente lo suddividerei e darei nomi significativi. Questo è più da leggere, ma non c'è bisogno di molto da dire nei commenti:

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

Dualità.

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

Non so se è più leggibile se ... ma è bene sapere.

Answer 4

avvolgere ogni parte del || in proprio metodo o proprietà, che si può scrivere in questo modo

if (IdIsNew() || IdChanged()) 

Answer 5

Preferirei un nuovo metodo:

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

poi nel metodo esistente Vorrei solo:

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

Answer 6

È possibile scrivere un metodo di estensione con un buon nome:

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

così più tardi è possibile utilizzare

string id; 
string actual; 

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

Answer 7

un metodo di estensione sarebbe chiazza di petrolio:

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

Usage:

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

Answer 8

Se vuoi dire che si deve fare questo più volte, ed è è lunga e brutta, astratta la logica di un'altra classe e usa un metodo di estensione.

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

oggi sostituiscono il codice con:

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

Mentre riconosco che il modello "try" è necessario, non mi piacciono le implementazioni che richiedono un parametro "out". Sembrerebbe molto più utile avere funzioni simili a TryGetValue:

• TryGetDictValue (dizionario, key) restituisce null se la chiave non è nel dizionario
• TryGetDictValue (dizionario, chiave, defaultValue) restituisce defaultValue se la chiave non è in dizionario
• TryGetDictValue (dizionario, chiave, valueReturningDelegate) invoca il delegato in dotazione se la chiave non è nel dizionario e restituisce il suo risultato

in ogni caso, il tipo di ritorno del risultato sarebbe che dei dati del dizionario.

È un peccato che non ci sia modo di intrufolarsi in una macchina del tempo e fare in modo che tali metodi siano metodi di dizionario. D'altra parte, si potrebbero implementarli come funzioni statiche prendendo un dizionario come primo parametro.