Benötigen Sie ein Diktat mit meinem eigenen benutzerdefinierten Paartyp?

Question

KeyValuePair implementiert nicht INotifyPropertyChanged, so habe ich meinen eigenen Pair Typ implementiert, aber ich möchte es in einem Wörterbuch verwenden.

Was ist der einfachste Weg, das zu tun?

---

Also hier ist der Deal. In meinem Code brauche ich ein Wörterbuch mit Schlüssel/Wert-Paaren. Dies muss nicht wirklich beobachtbar sein.

Ich habe jedoch ein Bearbeitungsfenster, das dieses Diktat in einem Datagrid anzeigt. Das muss beobachtbar sein, damit das Datagrid seine Wirkung entfalten kann.

Also, was ich habe, ist, getan machen machen das Fenster zur Bearbeitung jedes zählbare von Paaren akzeptieren:

public ObservableCollection<Pair<string,object>> Variables { get; private set; } 

    public VariablesWindow(IEnumerable<Pair<string, object>> vars) 
    { 
     Variables = new ObservableCollection<Pair<string, object>>(vars.DeepCopy()); 

so dass es seine Sache zu tun. Und dann im Haupt Code, den ich ein dict wie normale verwenden, aber wenn ich das Bearbeitungsfenster öffnen muss ich das Bearbeitungsfenster können die dict in etwas umwandeln verwenden:

var window = new VariablesWindow(Dict2Enum(_dict)); 

Also habe ich diese 2 Helfermethoden hinzugefügt :

private static IEnumerable<Pair<TKey, TValue>> Dict2Enum<TKey, TValue>(Dictionary<TKey, TValue> dict) 
    { 
     return dict.Select(i => new Pair<TKey, TValue>(i.Key, i.Value)); 
    } 

    private static Dictionary<TKey, TValue> Enum2Dict<TKey, TValue>(IEnumerable<Pair<TKey, TValue>> collection) 
    { 
     return collection.ToDictionary(p => p.Key, p => p.Value); 
    } 

Scheint ein bisschen teuer, obwohl. Ich wiederhole die Sammlung jetzt zweimal. Einmal, um das Dictionary in ein Enumerable zu konvertieren, dann erneut, um es tief zu kopieren, so dass die Variablen nicht geändert werden, bis der Benutzer save trifft, und dann wandle ich dieses Enumerable in eine beobachtbare Sammlung um.

Answer 1

Hier ist eine Probe, die als Referenz verwendet werden kann:

http://drwpf.com/blog/2007/09/16/can-i-bind-my-itemscontrol-to-a-dictionary/

Answer 2

Wollen Sie einen Wert Wechsel benachrichtigen? Wenn ja, würde ich in Betracht ziehen, eine Wrapper<T> Klasse zu schreiben, die INotifyPropertyChanged unterstützt, und dann (sagen wir) Dictionary<string, Wrapper<int>> (für ein "string/int" Wörterbuch, das die Benachrichtigung über Änderungen unterstützt).

Beachten Sie, dass dies bedeutet, dass jeder, der einen Verweis auf den Wrapper behält, die vorgenommenen Änderungen sehen wird - das ist etwas, um das Sie sehr vorsichtig sein müssen.

EDIT: auf meine Ausführungen etwas erweitern ...

Wenn Sie in der Lage sein wollen, als auch den Schlüssel zu bearbeiten, ich vermute, Sie werden feststellen, dass für eine veränderbare TKey/TValue Paar Sie wollen werden Dictionary<TKey, MutablePair<TKey, TValue>>. Sie müssen INotifyPropertyChanging sowie INotifyPropertyChanged unterstützen, und es würde irgendwo haarig werden ... Sie müssen möglicherweise entfernen Sie es per Schlüssel auf INotifyPropertyChanging, und fügen Sie es dann erneut auf INotifyPropertyChanged. Zweifellos würden die Dinge chaotisch werden, wenn die Veränderung auf halbem Wege aufgegeben würde. Sie würde auch funktionieren müssen, was Sie wollen würde passieren, wenn eine Taste eine andere überschrieben ... und dann das ursprüngliche Objekt geändert wurde:

// Rough code - imagine we'd got a wrapper around Dictionary<TKey, TValue> 
// to create the pairs automatically. 
oddDictionary["key1"] = "value1"; 
oddDictionary["key2"] = "value2"; 

var pair1 = oddDictictionary.GetMutablePair("key1"); 
var pair2 = oddDictictionary.GetMutablePair("key2"); 
pair1.Key = "key2"; // Overwrite pair2, presumably... 
// Does the "changing" remove pair1? Or check for consistency? As it's 
// not part of the dictionary before the operation, does this not affect 
// the dictionary at all? 
pair2.Key = "key3"; 

Grundsätzlich gibt es eine Menge von Semantik Sie durch denken müssen wirklich vorsichtig bevor viel weiter geht.

Ich schlage vor, Sie schreiben Lose Unit Tests für das Verhalten, das Sie implementieren möchten, und dann sehen, was Sie tun können.