WPF - Comment puis-je mettre en œuvre une ObservableCollection<K,T> avec une clé (comme un Dictionnaire)?

J'ai utilisé une ObservableCollection avec WPF pour la liaison et cela fonctionne bien. Ce que je veux vraiment en ce moment est un Dictionnaire comme un, qui a une clé que je peux utiliser, donc effectivement comme "ObservableCollection".

Pouvez-vous suggérer le code qui peut être utilisé pour fournir une ObservableCollection? L'objectif est de disposer d'un Dictionnaire comme la structure que je peux lier à partir de WPF.

Grâce

OriginalL'auteur Greg | 2010-09-29

  1. 5

    Quelqu'un l'a déjà fait. Je n'ai pas essayer encore mais rien à perdre.

    OriginalL'auteur ktutnik

  2. 1

    Créer une classe qui implémente l'IDictionary, INotifyCollectionChanged & INotifyPropertyChanged interfaces. La classe aurait un exemple de Dictionnaire qui serait utilisé pour la mise en œuvre de IDictionary (l'un des compléments de méthodes est codée ci-dessous à titre d'exemple). Les deux INotifyCollectionChanged et INotifyProperyChanged exiger la présence d'événements, ces événements devraient être mis le feu à des points appropriés dans les fonctions wrapper (encore une fois, consulter la méthode Add ci-dessous pour un exemple)

    class ObservableDictionary<TKey, TValue> : IDictionary, INotifyCollectionChanged, INotifyPropertyChanged
{
    private Dictionary<TKey, TValue> mDictionary;
    //Methods & Properties for IDictionary implementation would defer to mDictionary:
    public void Add(TKey key, TValue value){
        mDictionary.Add(key, value);
        OnCollectionChanged(NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, value)
        return;
    }
    //Implementation of INotifyCollectionChanged:
    public event NotifyCollectionChangedEventHandler CollectionChanged;
    protected void OnCollectionChanged(NotifyCollectionChangedEventArgs args){
        //event fire implementation
    }
    //Implementation of INotifyProperyChanged:
    public event ProperyChangedEventHandler ProperyChanged;
    protected void OnPropertyChanged(PropertyChangedEventArgs args){
        //event fire implementation
    }
}

    Edit:

    Noter que la mise en œuvre de la IDictionary interface, directement ou indirectement, exigerait que les trois autres interfaces être mises en œuvre: 

    ICollection<KeyValuePair<TKey,TValue>>
IEnumerable<KeyValuePair<TKey,TValue>>
IEnumerable.

    Selon vos besoins, vous pourriez ne pas avoir à mettre en œuvre l'ensemble de la IDictionary de l'interface, si vous allez seulement d'appeler un couple de méthodes puis il suffit de mettre en œuvre ces méthodes et la IDictionary interface devient un luxe. Vous devez mettre en œuvre la INotifyCollectionChanged et INotifyPropertyChanged interfaces pour la liaison à un travail cependant.Blockquote

    la mise en VS je note il y a beaucoup plus de méthodes d'interface qui aurait nécessité la mise en place - est-ce correct?
    Oui, si vos besoins nécessitent de mettre en œuvre l'ensemble de la IDictionary interface, voir mes modifications

    OriginalL'auteur Steve Ellinger

  3. 1

    public class ObservableDictonary : Dictionnaire, INotifyCollectionChanged, INotifyPropertyChanged
    {
    événement public NotifyCollectionChangedEventHandler CollectionChanged;

        public event PropertyChangedEventHandler PropertyChanged;
public new void Add(TKey key, TValue value)
{
base.Add(key, value);
if (!TryGetValue(key, out _)) return;
var index = Keys.Count;
OnPropertyChanged(nameof(Count));
OnPropertyChanged(nameof(Values));
OnCollectionChanged(NotifyCollectionChangedAction.Add, value, index);
}
public new void Remove(TKey key)
{
if (!TryGetValue(key, out var value)) return;
var index = IndexOf(Keys, key);
OnPropertyChanged(nameof(Count));
OnPropertyChanged(nameof(Values));
OnCollectionChanged(NotifyCollectionChangedAction.Remove, value, index);
base.Remove(key);
}
public new void Clear()
{
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
PropertyChanged?.Invoke(this, e);
}
protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
CollectionChanged?.Invoke(this, e);
}
private void OnPropertyChanged(string propertyName)
{
OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
private void OnCollectionChanged(NotifyCollectionChangedAction action, object item)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item));
}
private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index)
{
OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index));
}
private int IndexOf(KeyCollection keys, TKey key)
{
var index = 0;
foreach (var k in keys)
{
if (Equals(k, key))
return index;
index++;
}
return -1;
}
}

    Je ovveride Ajouter, de Supprimer et d'Effacer. Vous devez comprendre, si vous utilisez la méthode d'extension ou de méthode simple, qui prennent Dictonary paramètre, vous ne verrez pas de changement, parce que dans cette situation, d'Ajouter ou de Supprimer la méthode va utiliser des Dictonary (pas ObservableDictonary). Donc, vous devez méthodes directes (Ajouter ou Supprimer) des ObservableDictonary

    OriginalL'auteur Smagin Alexey

  4. 0

    Que penser de quelque chose comme :

    ObservableCollection<Tuple<string, object>>()

    où la chaîne et de l'objet et les types d'échantillons de cours

    En fonction de l'utilisation, qui peuvent travailler. Cependant, considérez comment vous "trouver" un élément clé lors de l'utilisation de n-uplets de ce genre. Un Dictionnaire peut rechercher une valeur par clé à l'aide de fonctions de hachage et peut être un peu plus rapide que la recherche dans une liste pour une clé correspondante.
    Vous avez fait un point. Toutefois, l'utilisation d'une collection observable pour de grands ensembles de données est probablement pas une bonne idée.

    OriginalL'auteur eka808