Die Kerntechnologie der WPF-Datenbindung

Einer der wichtigsten technischen Vorteile von WPF ist die Datenbindung. Die Datenbindung kann die Schnittstelle durch Datenoperationen aktualisieren.

Die beiden am häufigsten für die Datenbindung verwendeten Klassen sind ObservableCollection und Dictionary.

ObservableCollection stellt eine dynamische Datensammlung dar. Diese Sammlung stellt Benachrichtigungen bereit, wenn Elemente hinzugefügt, Elemente entfernt oder die gesamte Liste aktualisiert wird. Die Schnittstellenanzeige kann durch Aktualisieren der Sammlungsdaten aktualisiert werden.

Die Leistung der Klasse, des Abrufs und der Datenoperation des Wörterbuchs ist äußerst schlecht, sodass einige Sammlungen von Konfigurationselementen damit gespeichert werden.

Daher dachte jeder darüber nach, ob es eine Klasse gibt, die ObservableCollection und Dictionary kombiniert, und so wurde die ObservableDictionary-Klasse gebildet.

Es gibt viele Versionen der ObservableDictionary-Klasse im Internet. Die früheste und klassischste Version ist ItemsControl für ein Wörterbuch in Dr.WPF. das Falsche. Es ist nur so, dass ich unwissend bin).

Die Version, die ich heute zur Verfügung stelle, bezieht sich auch auf andere Versionen im Internet und die in Dr.WPF.

Die Definition in Dr.WPF lautet wie folgt:

public class ObservableDictionary <TKey, TValue> :
        IDictionary<TKey, TValue>,
        ICollection<KeyValuePair<TKey, TValue>>,
        IEnumerable<KeyValuePair<TKey, TValue>>,
        IDictionary,
        ICollection,
        IEnumerable,
        ISerializable,
        IDeserializationCallback,
        INotifyCollectionChanged,
        INotifyPropertyChanged

Wenn Sie genau hinschauen, werden Sie feststellen, dass die hier geerbte Schnittstelle mit Dictionary< identisch ist. TKey, TValue> Der größte Teil der Vererbung ist gleich, mit Ausnahme der Hinzufügung von INotifyCollectionChanged, INotifyPropertyChanged

Daher erbt die Version, die ich heute bereitstelle, direkt von Dictionary.

Ich habe es getestet, es gibt keine Fehler und die Leistung ist ausgezeichnet. Der Code lautet wie folgt:

    public class ObservableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public ObservableDictionary()
            : base()
        { }

        private int _index;
        public event NotifyCollectionChangedEventHandler CollectionChanged;
        public event PropertyChangedEventHandler PropertyChanged;

        public new KeyCollection Keys
        {
            get { return base.Keys; }
        }

        public new ValueCollection Values
        {
            get { return base.Values; }
        }

        public new int Count 
        {
            get { return base.Count; }
        }

        public new TValue this[TKey key]
        {
            get { return this.GetValue(key); }
            set { this.SetValue(key, value); }
        }

        public TValue this[int index]
        {
            get { return this.GetIndexValue(index); }
            set { this.SetIndexValue(index, value); }
        }

        public new void Add(TKey key, TValue value)
        {
            base.Add(key, value);
            this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, this.FindPair(key), _index));
            OnPropertyChanged("Keys");
            OnPropertyChanged("Values");
            OnPropertyChanged("Count");
        }

        public new void Clear()
        {
            base.Clear();
            this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
            OnPropertyChanged("Keys");
            OnPropertyChanged("Values");
            OnPropertyChanged("Count");
        }

        public new bool Remove(TKey key)
        {
            var pair = this.FindPair(key);
            if (base.Remove(key))
            {
                this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, pair, _index));
                OnPropertyChanged("Keys");
                OnPropertyChanged("Values");
                OnPropertyChanged("Count");
                return true;
            }
            return false;
        }

        protected void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            if (this.CollectionChanged != null)
            {
                this.CollectionChanged(this, e);
            }
        }

        protected void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        #region private方法
        private TValue GetIndexValue(int index)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (i == index)
                {
                    var pair = this.ElementAt(i);
                    return pair.Value;
                }
            }

            return default(TValue);
        }

        private void SetIndexValue(int index, TValue value)
        {
            try
            {
                var pair = this.ElementAtOrDefault(index);
                SetValue(pair.Key, value);                
            }
            catch (Exception)
            {
                
            }
        }

        private TValue GetValue(TKey key)
        {
            if (base.ContainsKey(key))
            {
                return base[key];
            }
            else
            {
                return default(TValue);
            }
        }

        private void SetValue(TKey key, TValue value)
        {
            if (base.ContainsKey(key))
            {
                var pair = this.FindPair(key);
                int index = _index;
                base[key] = value;
                var newpair = this.FindPair(key);
                this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newpair, pair, index));
                OnPropertyChanged("Values");
                OnPropertyChanged("Item[]");
            }
            else
            {
                this.Add(key, value);
            }
        }

        private KeyValuePair<TKey, TValue> FindPair(TKey key)
        {
            _index = 0;
            foreach (var item in this)
            {
                if (item.Key.Equals(key))
                {
                    return item;
                }
                _index++;
            }
            return default(KeyValuePair<TKey, TValue>);
        }

        private int IndexOf(TKey key)
        {
            int index = 0;
            foreach (var item in this)
            {
                if (item.Key.Equals(key))
                {
                    return index;
                }
                index++;

            }
            return -1;
        }

        #endregion

    }

In Bezug auf die Erweiterung können Sie Verwenden Sie die Dr.WPF-Version, um es zu ändern. Diese ist technischer und skalierbarer!

Das obige ist der detaillierte Inhalt vonDie Kerntechnologie der WPF-Datenbindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!