Quelle est l'utilité de ObservableCollection en .net ?

Question

Quelle est l'utilité de ObservableCollection en .net ?

Answer 1

ObservableCollection est une collection qui permet au code extérieur à la collection d'être informé des modifications apportées à la collection (ajout, déplacement, suppression). Elle est très utilisée dans WPF et Silverlight, mais son utilisation ne s'y limite pas. Le code peut ajouter des gestionnaires d'événements pour savoir quand la collection a changé, puis réagir par le biais du gestionnaire d'événements pour effectuer un traitement supplémentaire. Il peut s'agir de modifier une interface utilisateur ou d'effectuer une autre opération.

Le code ci-dessous ne fait pas vraiment quelque chose mais démontre comment attacher un gestionnaire dans une classe et ensuite utiliser les arguments de l'événement pour réagir d'une certaine manière aux changements. WPF intègre déjà de nombreuses opérations, comme le rafraîchissement de l'interface utilisateur, et vous les obtenez gratuitement en utilisant 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
        }
    }
}

Answer 2

Un site ObservableCollection fonctionne essentiellement comme une collection ordinaire, sauf qu'elle implémente les interfaces :

• INotifyCollectionChanged ,
• INotifyPropertyChanged

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

Plus important encore, ils sont très utiles lorsqu'on utilise la liaison de données sur un formulaire.

Answer 3

De Pro C# 5.0 et le framework .NET 4.5

El ObservableCollection<T> est très utile dans la mesure où elle a la capacité d'informer des objets externes lorsque son contenu a été modifié d'une manière ou d'une autre (comme vous pouvez le deviner, travailler avec les classes ReadOnlyObservableCollection<T> est très similaire, mais en lecture seule). À bien des égards, le travail avec le site ObservableCollection<T> est identique au travail avec List<T> étant donné que ces deux classes implémentent les mêmes interfaces de base. Ce qui fait que le ObservableCollection<T> unique est que cette classe supporte 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 que la collection entière est modifiée. 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 le second. Considérons la méthode Main() suivante suivante, qui remplit une collection d'observables contenant des objets Personne et qui connecte la méthode CollectionChanged événement :

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());
            }
        }
   }
}

L'arrivée NotifyCollectionChangedEventArgs définit deux propriétés importantes, OldItems y NewItems qui vous donnera une liste des éléments qui se trouvaient dans la collection avant le déclenchement de l'événement, ainsi que les nouveaux éléments qui ont été impliqués dans le changement. Cependant, vous ne voudrez examiner ces listes que dans les bonnes circonstances. 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 par rapport à l'un des membres suivants de la classe NotifyCollectionChangedAction l'énumération :

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

Answer 4

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

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

En C#, l'accrochage de la ListBox à la collection pourrait être aussi simple que

listBox.ItemsSource = NameListData;

Cependant, si vous n'avez pas fait de la liste une ressource statique et défini NameItemTemplate, vous voudrez peut-être remplacer la fonction ToString() de PersonName. Par exemple :

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

Answer 5

Il s'agit d'une collection qui est utilisée pour notifier la plupart du temps à l'interface utilisateur les changements dans la collection, elle supporte la notification automatique.

Principalement utilisé dans WPF ,

Supposons que vous ayez une interface utilisateur avec une boîte de liste et un bouton d'ajout. Lorsque vous cliquez sur le bouton, un objet de type personne sera ajouté à la collection obseravable et vous liez cette collection à l'ItemSource de la boîte de liste, de sorte que dès que vous ajoutez un nouvel élément dans la collection, la boîte de liste se met à jour et ajoute un élément supplémentaire.