ObservableDictionary wirft bei Aktualisieren eines Wertes Exceptions

  • C#

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    ObservableDictionary wirft bei Aktualisieren eines Wertes Exceptions

    Ich hab von hier eine ObservableDictionary-Klasse, die auch wunderbar funktioniert, bis ich versuche, den Wert eines Eintrags zu aktualisieren. Dann kriege ich diese Exception, die ganz unten im Code der Klasse geworfen wird: d.pr/i/umTb
    Wie kann ich das vermeiden?

    Das ist kein ranziger Fremdhoster, sondern Droplr. :p
    Jdfs. hier der Code vom ObservableDictionary:

    C#-Quellcode

    1. using System;
    2. using System.Linq;
    3. using System.ComponentModel;
    4. using System.Collections.Generic;
    5. using System.Collections.Specialized;
    7. namespace System.Collections.ObjectModel
    8. {
    9. public class ObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, INotifyCollectionChanged, INotifyPropertyChanged
    10. {
    11. private const string CountString = "Count";
    12. private const string IndexerName = "Item[]";
    13. private const string KeysName = "Keys";
    14. private const string ValuesName = "Values";
    16. private IDictionary<TKey, TValue> _Dictionary;
    17. protected IDictionary<TKey, TValue> Dictionary
    18. {
    19. get { return _Dictionary; }
    20. }
    22. #region Constructors
    23. public ObservableDictionary()
    24. {
    25. _Dictionary = new Dictionary<TKey, TValue>();
    26. }
    27. public ObservableDictionary(IDictionary<TKey, TValue> dictionary)
    28. {
    29. _Dictionary = new Dictionary<TKey, TValue>(dictionary);
    30. }
    31. public ObservableDictionary(IEqualityComparer<TKey> comparer)
    32. {
    33. _Dictionary = new Dictionary<TKey, TValue>(comparer);
    34. }
    35. public ObservableDictionary(int capacity)
    36. {
    37. _Dictionary = new Dictionary<TKey, TValue>(capacity);
    38. }
    39. public ObservableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
    40. {
    41. _Dictionary = new Dictionary<TKey, TValue>(dictionary, comparer);
    42. }
    43. public ObservableDictionary(int capacity, IEqualityComparer<TKey> comparer)
    44. {
    45. _Dictionary = new Dictionary<TKey, TValue>(capacity, comparer);
    46. }
    47. #endregion
    49. #region IDictionary<TKey,TValue> Members
    51. public void Add(TKey key, TValue value)
    52. {
    53. Insert(key, value, true);
    54. }
    56. public bool ContainsKey(TKey key)
    57. {
    58. return Dictionary.ContainsKey(key);
    59. }
    61. public ICollection<TKey> Keys
    62. {
    63. get { return Dictionary.Keys; }
    64. }
    66. public bool Remove(TKey key)
    67. {
    68. if (key == null) throw new ArgumentNullException("key");
    70. TValue value;
    71. Dictionary.TryGetValue(key, out value);
    72. var removed = Dictionary.Remove(key);
    73. if (removed)
    74. //OnCollectionChanged(NotifyCollectionChangedAction.Remove, new KeyValuePair<TKey, TValue>(key, value));
    75. OnCollectionChanged();
    76. return removed;
    77. }
    79. public bool TryGetValue(TKey key, out TValue value)
    80. {
    81. return Dictionary.TryGetValue(key, out value);
    82. }
    84. public ICollection<TValue> Values
    85. {
    86. get { return Dictionary.Values; }
    87. }
    89. public TValue this[TKey key]
    90. {
    91. get
    92. {
    93. return Dictionary[key];
    94. }
    95. set
    96. {
    97. Insert(key, value, false);
    98. }
    99. }
    101. #endregion
    103. #region ICollection<KeyValuePair<TKey,TValue>> Members
    105. public void Add(KeyValuePair<TKey, TValue> item)
    106. {
    107. Insert(item.Key, item.Value, true);
    108. }
    110. public void Clear()
    111. {
    112. if (Dictionary.Count > 0)
    113. {
    114. Dictionary.Clear();
    115. OnCollectionChanged();
    116. }
    117. }
    119. public bool Contains(KeyValuePair<TKey, TValue> item)
    120. {
    121. return Dictionary.Contains(item);
    122. }
    124. public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    125. {
    126. Dictionary.CopyTo(array, arrayIndex);
    127. }
    129. public int Count
    130. {
    131. get { return Dictionary.Count; }
    132. }
    134. public bool IsReadOnly
    135. {
    136. get { return Dictionary.IsReadOnly; }
    137. }
    139. public bool Remove(KeyValuePair<TKey, TValue> item)
    140. {
    141. return Remove(item.Key);
    142. }
    145. #endregion
    147. #region IEnumerable<KeyValuePair<TKey,TValue>> Members
    149. public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    150. {
    151. return Dictionary.GetEnumerator();
    152. }
    154. #endregion
    156. #region IEnumerable Members
    158. IEnumerator IEnumerable.GetEnumerator()
    159. {
    160. return ((IEnumerable)Dictionary).GetEnumerator();
    161. }
    163. #endregion
    165. #region INotifyCollectionChanged Members
    167. public event NotifyCollectionChangedEventHandler CollectionChanged;
    169. #endregion
    171. #region INotifyPropertyChanged Members
    173. public event PropertyChangedEventHandler PropertyChanged;
    175. #endregion
    177. public void AddRange(IDictionary<TKey, TValue> items)
    178. {
    179. if (items == null) throw new ArgumentNullException("items");
    181. if (items.Count > 0)
    182. {
    183. if (Dictionary.Count > 0)
    184. {
    185. if (items.Keys.Any((k) => Dictionary.ContainsKey(k)))
    186. throw new ArgumentException("An item with the same key has already been added.");
    187. else
    188. foreach (var item in items) Dictionary.Add(item);
    189. }
    190. else
    191. _Dictionary = new Dictionary<TKey, TValue>(items);
    193. OnCollectionChanged(NotifyCollectionChangedAction.Add, items.ToArray());
    194. }
    195. }
    197. private void Insert(TKey key, TValue value, bool add)
    198. {
    199. if (key == null) throw new ArgumentNullException("key");
    201. TValue item;
    202. if (Dictionary.TryGetValue(key, out item))
    203. {
    204. if (add) throw new ArgumentException("An item with the same key has already been added.");
    205. if (Equals(item, value)) return;
    206. Dictionary[key] = value;
    208. OnCollectionChanged(NotifyCollectionChangedAction.Replace, new KeyValuePair<TKey, TValue>(key, value), new KeyValuePair<TKey, TValue>(key, item));
    209. }
    210. else
    211. {
    212. Dictionary[key] = value;
    214. OnCollectionChanged(NotifyCollectionChangedAction.Add, new KeyValuePair<TKey, TValue>(key, value));
    215. }
    216. }
    218. private void OnPropertyChanged()
    219. {
    220. OnPropertyChanged(CountString);
    221. OnPropertyChanged(IndexerName);
    222. OnPropertyChanged(KeysName);
    223. OnPropertyChanged(ValuesName);
    224. }
    226. protected virtual void OnPropertyChanged(string propertyName)
    227. {
    228. if (PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    229. }
    231. private void OnCollectionChanged()
    232. {
    233. OnPropertyChanged();
    234. if (CollectionChanged != null) CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    235. }
    237. private void OnCollectionChanged(NotifyCollectionChangedAction action, KeyValuePair<TKey, TValue> changedItem)
    238. {
    239. OnPropertyChanged();
    240. if (CollectionChanged != null) CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, changedItem));
    241. }
    243. private void OnCollectionChanged(NotifyCollectionChangedAction action, KeyValuePair<TKey, TValue> newItem, KeyValuePair<TKey, TValue> oldItem)
    244. {
    245. OnPropertyChanged();
    246. if (CollectionChanged != null) CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, newItem, oldItem));
    247. }
    249. private void OnCollectionChanged(NotifyCollectionChangedAction action, IList newItems)
    250. {
    251. OnPropertyChanged();
    252. if (CollectionChanged != null) CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, newItems));
    253. }
    254. }
    255. }


    Hier mein Code, der die Exception auslöst:

    C#-Quellcode

    1. private void WH_EditColor_Click(object sender, RoutedEventArgs e) {
    2. KeyValuePair<string, Color?> source;
    3. source = (KeyValuePair<string, Color?>)(((ListBoxItem)((Grid)((Button)e.Source).Parent).TemplatedParent).Content);
    4. ColorPicker cp = new ColorPicker(); //Ein selbstgemachter Colorpicker, dessen ChosenColor-Eigenschaft die gewählte Farbe enthält
    5. cp.colorCanvas1.HexadecimalString = source.Value.Value.ToString();
    6. if(cp.ShowDialog() == true) {
    7. App.Wallpapers[source.Key] = cp.ChosenColor;
    8. //hier wird die Exception ausgelöst, wenn die cp.ChosenColor nen anderen Wert hat als der Wert des KeyValuePairs im Dictionary
    9. }
    10. }


    Hier die Exception:

    klingt so, als gebe es den Key nicht im Dictionary


    das ist aber auch unklar:
    hier wird die Exception ausgelöst, wenn die cp.ChosenColor nen anderen Wert hat als der Wert des KeyValuePairs im Dictionary
    Eine ChosenColor ist ja kein KeyValuePair - hat also immer "nen anderen Wert hat als der Wert des KeyValuePairs im Dictionary"

    Den Key gibt es aber. Ich den passenden Wert ja ausgeben lassen und damit arbeiten, nur neu zuweisen kann ich ihn nicht.
    Mit einem normalen Dictionary funktioniert es, aber das kann ich nicht vernünftig an ne Listbox binden.

    Edit:
    hat also immer "nen anderen Wert hat als der Wert des KeyValuePairs im Dictionary"
    Nein. :p
    App.Wallpapers[source.Key] liefert mir den Wert, also ne Color. Wenn diese Color den gleichen Wert hat wie App.Wallpapers[source.Key], passiert nichts.
    Btw: "Wallpapers" ist so deklariert:

    C#-Quellcode

    1. public static ObservableDictionary<String, Color?> Wallpapers { get; set; }
    .

    VB.NET-Quellcode

    1. Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load
    2. Dim Hullu As New Dictionary(Of String, String) From {{"Hallo", "HerrBert"}, {"Hielo", "HurBert"}, {"Hällö", "H. Bert"}}
    3. ListBox1.DataSource = Hullu.ToList
    4. ListBox1.DisplayMember = "Value"
    5. End Sub

    Dazu müsste ich die komplette Programmstruktur auf den Kopf stellen, und das würde ich lieber vermeiden. :/
    Edit: Ich hab die Click-Dinger beseitigt und durch Commands ersetzt, was im Endeffekt nichts geändert hat. Der Fehler bei Setzen des Wertes tritt immer noch auf.
    Ich vermute, dass am Dictionary irgendwas nicht stimmt, aber was?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Samus Aran“ ()

Facebook