La technologie de base de la liaison de données WPF

L'un des principaux avantages techniques de WPF est la liaison de données. La liaison de données peut mettre à jour l'interface en opérant sur les données.

Les deux classes les plus couramment utilisées pour la liaison de données sont ObservableCollection8742468051c85b06f0a0af9e3e506b5c et Dictionary6e081e925c6a2fa99508161fe1ff33ed.

ObservableCollection représente une collection de données dynamique. Cette collection fournira des notifications lorsque des éléments sont ajoutés, des éléments sont supprimés ou que la liste entière est actualisée. L'affichage de l'interface peut être mis à jour en mettant à jour les données de la collection.

Les performances de la classe de dictionnaire, de la récupération et du fonctionnement des données sont extrêmement médiocres, de sorte que certaines collections d'éléments de configuration sont enregistrées en l'utilisant.

Par conséquent, tout le monde s'est demandé s'il existait une classe combinant ObservableCollection et Dictionary, c'est pourquoi la classe ObservableDictionary a été formée.

Il existe de nombreuses versions de la classe ObservableDictionary sur Internet. Pour autant que je sache, la plus ancienne et la plus classique est ItemsControl pour un dictionnaire dans Dr.WPF. le mauvais. C’est juste que je suis ignorant).

La version que je propose aujourd'hui fait également référence à d'autres versions sur Internet et à celles du Dr.WPF.

La définition dans Dr.WPF est la suivante :

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

Si vous regardez attentivement, vous constaterez que l'interface héritée ici est la même que celle du Dictionnaired379f00f08d3d077b1dc6f4f26aea885 La majeure partie de l'héritage est la même, à l'exception de l'ajout de INotifyCollectionChanged, INotifyPropertyChanged

Par conséquent, la version que je propose aujourd'hui hérite directement de Dictionaryb6842da76bed01162354d37c4f2d3464

Je l'ai testé, il n'y a pas de BUG, ​​et les performances sont excellentes. Le code est le suivant :

    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

    }

En terme d'extension, vous pouvez. utilisez la version Dr.WPF pour le modifier. Celle-là est plus technique et évolutive !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!