web-dev-qa-db-fra.com

Quelle est l'utilisation de ObservableCollection dans .net?

Quelle est l'utilisation de ObservableCollection dans .net?

c#.netobservablecollection
216
santosh singh

ObservableCollection est une collection qui permet au code en dehors de la collection de savoir quand des modifications sont apportées à la collection (ajout, déplacement, suppression). Il est fortement utilisé dans WPF et Silverlight, mais son utilisation n’est pas limitée à cela. Le code peut ajouter des gestionnaires d'événements pour voir quand la collection a été modifiée, puis réagir via le gestionnaire d'événements pour effectuer un traitement supplémentaire. Cela peut être changer une interface utilisateur ou effectuer une autre opération.

Le code ci-dessous ne fait vraiment rien mais montre comment attacher un gestionnaire dans une classe puis utiliser les arguments d'événement pour réagir d'une manière ou d'une autre aux changements. WPF a déjà de nombreuses opérations telles que l'actualisation de l'interface utilisateur intégrée afin que vous puissiez les obtenir gratuitement lorsque vous utilisez ObservableCollections.

class Handler
{
    private ObservableCollection<string> collection;

    public Handler()
    {
        collection = new ObservableCollection<string>();
        collection.CollectionChanged += HandleChange;
    }

    private void HandleChange(object sender, NotifyCollectionChangedEventArgs e)
    {
        foreach (var x in e.NewItems)
        {
            // do something
        }

        foreach (var y in e.OldItems)
        {
            //do something
        }
        if (e.Action == NotifyCollectionChangedAction.Move)
        {
            //do something
        }
    }
}
208
Craig Suchanec

Un ObservableCollection fonctionne essentiellement comme une collection normale, à la différence près qu'il implémente les interfaces:

En tant que tel, il est très utile de savoir quand la collection a été modifiée. Un événement est déclenché qui indiquera à l'utilisateur quelles entrées ont été ajoutées/supprimées ou déplacées.

Plus important encore, ils sont très utiles lorsque vous utilisez la liaison de données sur un formulaire.

151
Liz

De Pro C # 5.0 et .NET 4.5 Framework

La classe ObservableCollection<T> est très utile car elle permet d’informer des objets externes lorsque son contenu a changé (comme vous pouvez le deviner, travailler avec ReadOnlyObservableCollection<T> est très similaire, mais en lecture seule. la nature). À bien des égards, travailler avec ObservableCollection<T> est identique à travailler avec List<T>, étant donné que ces deux classes implémentent les mêmes interfaces principales. Ce qui rend la classe ObservableCollection<T> unique, c'est que cette classe prend en charge un événement nommé CollectionChanged. Cet événement se déclenche chaque fois qu'un nouvel élément est inséré, qu'un élément actuel est supprimé (ou déplacé) ou si l'ensemble de la collection est modifié. Comme tout événement, CollectionChanged est défini en termes de délégué, qui dans ce cas est NotifyCollectionChangedEventHandler. Ce délégué peut appeler n'importe quelle méthode qui prend un objet comme premier paramètre et un NotifyCollectionChangedEventArgs comme second. Considérez la méthode Main () suivante, qui remplit une collection observable contenant des objets Personne et connecte l'événement CollectionChanged:

class Program
{
   static void Main(string[] args)
   {
     // Make a collection to observe and add a few Person objects.
     ObservableCollection<Person> people = new ObservableCollection<Person>()
     {
        new Person{ FirstName = "Peter", LastName = "Murphy", Age = 52 },
        new Person{ FirstName = "Kevin", LastName = "Key", Age = 48 },
     };
     // Wire up the CollectionChanged event.
     people.CollectionChanged += people_CollectionChanged;
     // Now add a new item.
     people.Add(new Person("Fred", "Smith", 32));

     // Remove an item.
     people.RemoveAt(0);

     Console.ReadLine();
   }
   static void people_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
   {
       // What was the action that caused the event?
        Console.WriteLine("Action for this event: {0}", e.Action);

        // They removed something. 
        if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
        {
            Console.WriteLine("Here are the OLD items:");
            foreach (Person p in e.OldItems)
            {
                Console.WriteLine(p.ToString());
            }
            Console.WriteLine();
        }

        // They added something. 
        if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
        {
            // Now show the NEW items that were inserted.
            Console.WriteLine("Here are the NEW items:");
            foreach (Person p in e.NewItems)
            {
                Console.WriteLine(p.ToString());
            }
        }
   }
}

Le paramètre incoming NotifyCollectionChangedEventArgs définit deux propriétés importantes, OldItems et NewItems, qui vous donneront une liste des éléments qui étaient actuellement dans la collection avant le déclenchement de l'événement, ainsi que les nouveaux éléments impliqué dans le changement. Cependant, vous souhaiterez examiner ces listes uniquement dans les circonstances appropriées. Rappelez-vous que l'événement CollectionChanged peut se déclencher lorsque des éléments sont ajoutés, supprimés, déplacés ou réinitialisés. Pour découvrir laquelle de ces actions a déclenché l'événement, vous pouvez utiliser la propriété Action de NotifyCollectionChangedEventArgs. La propriété Action peut être testée avec l'un des membres suivants de l'énumération NotifyCollectionChangedAction:

public enum NotifyCollectionChangedAction
{
Add = 0,
Remove = 1,
Replace = 2,
Move = 3,
Reset = 4,
}

Members of System.Collections.ObjectModel

50
Jahan

Explication sans code

Pour ceux qui veulent une réponse sans code derrière (boom-tish), je lève la main:

Collections normales - Pas de notifications

De temps en temps, je vais à New York et ma femme me demande d’acheter des choses. Alors je prends une liste de courses avec moi. La liste contient beaucoup de choses comme:

  1. Sac à main Louis Vuitton (5000 $)
  2. Parfum de la majesté impériale de Clive Christian (215 000 $)
  3. Lunettes de soleil Gucci (2000 $)

hahaha ben je n’achète pas ce genre de choses. Je les ai donc rayés et enlevés de la liste et j’ajoute à la place:

  1. 12 douzaines de balles de golf Titleist.
  2. Boule de bowling de 12 lb.

Donc, d'habitude, je rentre à la maison sans les marchandises et elle n'est jamais ravie. Le fait est qu’elle ne sait pas ce que j’enlève de la liste et ce que j’ajoute dessus; elle ne reçoit aucune notification.

The ObservableCollection - notifications lorsque des modifications sont apportées

Maintenant, chaque fois que je supprime quelque chose de la liste: elle reçoit une notification sur son téléphone (sms/email, etc.)!

La collection observable fonctionne de la même manière. Si vous ajoutez ou supprimez quelque chose, vous en êtes averti. Et quand ils sont prévenus, alors ils vous appellent et vous aurez une oreille pleine. Bien entendu, les conséquences sont personnalisables via le gestionnaire d’événements.

Cela résume tout!

19
BKSpurgeon

L'une des utilisations les plus importantes est que vous pouvez lier des composants d'interface utilisateur à un seul et qu'ils réagiront de manière appropriée si le contenu de la collection change. Par exemple, si vous liez un ItemsSource d'un ListView à un, le contenu du ListView sera automatiquement mis à jour si vous modifiez la collection.

EDIT: Voici un exemple de code provenant de MSDN: http://msdn.Microsoft.com/en-us/library/ms748365.aspx

En C #, accrocher le ListBox à la collection peut être aussi simple que

listBox.ItemsSource = NameListData;

cependant, si vous n'avez pas connecté la liste en tant que ressource statique et que vous avez défini NameItemTemplate, vous pouvez remplacer le ToString () de PersonName. Par exemple:

public override ToString()
{
    return string.Format("{0} {1}", this.FirstName, this.LastName);
}
7
Sean U

c'est une collection qui est utilisée pour notifier principalement l'interface utilisateur pour changer dans la collection, il supporte la notification automatique.

Principalement utilisé dans WPF,

Où supposons que vous avez une interface utilisateur avec une zone de liste et un bouton Ajouter; lorsque vous cliquez sur le bouton, un objet de type suppose que la personne sera ajoutée à la collection obseravabl et que vous liez cette collection à la source ItemSource de la zone de liste. Nouvel élément de la collection, Listbox se mettra à jour et y ajoutera un élément supplémentaire.

6
TalentTuner
class FooObservableCollection : ObservableCollection<Foo>
{
    protected override void InsertItem(int index, Foo item)
    {
        base.Add(index, Foo);

        if (this.CollectionChanged != null)
            this.CollectionChanged(this, new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Add, item, index);
    }
}

var collection = new FooObservableCollection();
collection.CollectionChanged += CollectionChanged;

collection.Add(new Foo());

void CollectionChanged (object sender, NotifyCollectionChangedEventArgs e)
{
    Foo newItem = e.NewItems.OfType<Foo>().First();
}
5
abatishchev