ObservableDictionary para c #

Estoy intentando usar la siguiente implementación de ObservableDictionary: ObservableDictionary (C #) .

Cuando estoy usando el siguiente código mientras vinculo el diccionario a un DataGrid:

ObserveableDictionary dd=new ObserveableDictionary(); .... dd["aa"]="bb"; .... dd["aa"]="cc"; 

en dd["aa"]="cc"; Estoy recibiendo la siguiente excepción

 Index was out of range. Must be non-negative and less than the size of the collection. Parameter name: index 

Esta excepción se lanza en CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, newItem, oldItem) en el siguiente método:

 private void OnCollectionChanged(NotifyCollectionChangedAction action, KeyValuePair newItem, KeyValuePair oldItem) { OnPropertyChanged(); if (CollectionChanged != null) CollectionChanged(this, new NotifyCollectionChangedEventArgs(action, newItem, oldItem)); } 

El index param parece corresponder a KeyValuePair oldItem .

¿Cómo puede estar fuera de rango KeyValuePair , y qué debo hacer para que esto funcione?

Estructura de datos similar, para enlazar a la colección de tipos de diccionarios.

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

Proporciona una nueva estructura de datos ObservableDictionary y dispara PropertyChanged en caso de cualquier cambio en el Diccionario subyacente.

Esto es lo que hice al final:

 [Serializable] public class ObservableKeyValuePair:INotifyPropertyChanged { #region properties private TKey key; private TValue value; public TKey Key { get { return key; } set { key = value; OnPropertyChanged("Key"); } } public TValue Value { get { return value; } set { this.value = value; OnPropertyChanged("Value"); } } #endregion #region INotifyPropertyChanged Members [field:NonSerialized] public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged(string name) { PropertyChangedEventHandler handler = PropertyChanged; if (handler != null) handler(this, new PropertyChangedEventArgs(name)); } #endregion } [Serializable] public class ObservableDictionary:ObservableCollection>, IDictionary { #region IDictionary Members public void Add(TKey key, TValue value) { if (ContainsKey(key)) { throw new ArgumentException("The dictionary already contains the key"); } base.Add(new ObservableKeyValuePair() {Key = key, Value = value}); } public bool ContainsKey(TKey key) { //var m=base.FirstOrDefault((i) => i.Key == key); var r = ThisAsCollection().FirstOrDefault((i) => Equals(key, i.Key)); return !Equals(default(ObservableKeyValuePair), r); } bool Equals(TKey a, TKey b) { return EqualityComparer.Default.Equals(a, b); } private ObservableCollection> ThisAsCollection() { return this; } public ICollection Keys { get { return (from i in ThisAsCollection() select i.Key).ToList(); } } public bool Remove(TKey key) { var remove = ThisAsCollection().Where(pair => Equals(key, pair.Key)).ToList(); foreach (var pair in remove) { ThisAsCollection().Remove(pair); } return remove.Count > 0; } public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); var r = GetKvpByTheKey(key); if (!Equals(r, default(ObservableKeyValuePair))) { return false; } value = r.Value; return true; } private ObservableKeyValuePair GetKvpByTheKey(TKey key) { return ThisAsCollection().FirstOrDefault((i) => i.Key.Equals(key)); } public ICollection Values { get { return (from i in ThisAsCollection() select i.Value).ToList(); } } public TValue this[TKey key] { get { TValue result; if (!TryGetValue(key,out result)) { throw new ArgumentException("Key not found"); } return result; } set { if (ContainsKey(key)) { GetKvpByTheKey(key).Value = value; } else { Add(key, value); } } } #endregion #region ICollection> Members public void Add(KeyValuePair item) { Add(item.Key, item.Value); } public bool Contains(KeyValuePair item) { var r = GetKvpByTheKey(item.Key); if (Equals(r, default(ObservableKeyValuePair))) { return false; } return Equals(r.Value, item.Value); } public void CopyTo(KeyValuePair[] array, int arrayIndex) { throw new NotImplementedException(); } public bool IsReadOnly { get { return false; } } public bool Remove(KeyValuePair item) { var r = GetKvpByTheKey(item.Key); if (Equals(r, default(ObservableKeyValuePair))) { return false; } if (!Equals(r.Value,item.Value)) { return false ; } return ThisAsCollection().Remove(r); } #endregion #region IEnumerable> Members public new IEnumerator> GetEnumerator() { return (from i in ThisAsCollection() select new KeyValuePair(i.Key, i.Value)).ToList().GetEnumerator(); } #endregion } 

Esta implementación se ve y se siente como un diccionario para el usuario y como ObservableCollection para WPF

Incluso si uso el ObservableDictionary de github, también me enfrenté a esta excepción. Más tarde declaré la variable del diccionario a nivel de clase. Intenté crear una nueva instancia en el método donde se estaba accediendo.

OldCode que dio la excepción:

 public class CName { ObservableDictionary _classVariableDictionary = new ObservableDictionary(); } 

NewCode que funcionó:

 public void MethodName() { ObservableDictionary _localVariableDictionary = new ObservableDictionary(); }