Qual è l’uso di ObservableCollection in .net?

Qual è l’uso di ObservableCollection in .net?

ObservableCollection è una raccolta che consente al codice esterno alla raccolta di essere consapevole di quando si verificano modifiche alla raccolta (aggiungi, sposta, rimuovi). Viene usato pesantemente in WPF e Silverlight ma il suo uso non è limitato a lì. Il codice può aggiungere gestori di eventi per vedere quando la collezione è cambiata e quindi reactjs attraverso il gestore di eventi per eseguire ulteriori elaborazioni. Questo potrebbe cambiare un’interfaccia utente o eseguire qualche altra operazione.

Il codice qui sotto non fa davvero nulla ma dimostra come si collegherebbe un gestore in una class e poi si userà l’argomento degli eventi per reactjs in qualche modo alle modifiche. WPF ha già molte operazioni come l’aggiornamento dell’interfaccia utente integrata in modo da ottenerle gratuitamente quando si utilizza ObservableCollections

class Handler { private ObservableCollection collection; public Handler() { collection = new ObservableCollection(); 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 } } } 

Un ObservableCollection funziona essenzialmente come una collezione normale, tranne per il fatto che implementa le interfacce:

  • INotifyCollectionChanged ,
  • INotifyPropertyChanged

In quanto tale è molto utile quando vuoi sapere quando la collezione è cambiata. Viene triggersto un evento che comunica all’utente quali voci sono state aggiunte / rimosse o spostate.

Ancora più importante sono molto utili quando si usa l’associazione dati su un modulo.

Da Pro C # 5.0 e .NET Framework 4.5

La class ObservableCollection è molto utile in quanto ha la capacità di informare gli oggetti esterni quando i suoi contenuti sono cambiati in qualche modo (come si può immaginare, lavorare con ReadOnlyObservableCollection è molto simile, ma di sola lettura in natura) . In molti modi, lavorare con ObservableCollection è identico a lavorare con List , dato che entrambe le classi implementano le stesse interfacce core. Ciò che rende unica la class ObservableCollection è che questa class supporta un evento chiamato CollectionChanged . Questo evento si triggers ogni volta che viene inserito un nuovo object, un object corrente viene rimosso (o riposizionato) o se l’intera raccolta viene modificata. Come ogni evento, CollectionChanged è definito in termini di un delegato, che in questo caso è NotifyCollectionChangedEventHandler . Questo delegato può chiamare qualsiasi metodo che accetta un object come primo parametro e un NotifyCollectionChangedEventArgs come secondo. Considera il seguente metodo Main (), che popola una raccolta osservabile contenente oggetti Person e collega l’evento CollectionChanged :

 class Program { static void Main(string[] args) { // Make a collection to observe and add a few Person objects. ObservableCollection people = new ObservableCollection() { 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()); } } } } 

Il parametro NotifyCollectionChangedEventArgs arrivo definisce due proprietà importanti, OldItems e NewItems , che forniscono un elenco di elementi che erano attualmente presenti nella raccolta prima dell’evento e i nuovi elementi coinvolti nella modifica. Tuttavia, vorrai esaminare questi elenchi solo nelle circostanze corrette. Ricorda che l’evento CollectionChanged può sparare quando gli oggetti vengono aggiunti, rimossi, riposizionati o ripristinati. Per scoprire quale di queste azioni ha triggersto l’evento, è ansible utilizzare la proprietà Action di NotifyCollectionChangedEventArgs. La proprietà Action può essere verificata rispetto a uno dei seguenti membri dell’enumerazione NotifyCollectionChangedAction :

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

Membri di System.Collections.ObjectModel

Per quelli che vogliono una risposta senza alcun codice alle spalle (boom-tish), mi lancerò la mano:

Collezioni normali – Nessuna notifica

Ogni tanto vado a New York e il mio amico mi chiede di comprare qualcosa. Quindi prendo una lista della spesa con me. La lista ha un sacco di cose lì come:

  1. Le 7 abitudini di persone altamente efficaci
  2. Clive Christian’s Imperial Majesty ($ 215.000)
  3. Ferrari ($ 750.000)

Beh, non sto comprando quella roba, quindi li cancello e li rimuovo dalla lista e aggiungo invece:

  1. 12 dozzine di palline da golf.

Il fatto è che il mio amico non sa cosa faccio fuori dalla lista e cosa vi aggiungo sopra. L’amico non riceve notifiche.

ObservableCollection: notifiche quando vengono apportate modifiche

Quindi di solito torno a casa senza i beni e l’amico non è mai contento.

Buuuut ora amico ha un’app sul telefono di un amico: ogni volta che rimuovo qualcosa dalla lista: l’amico riceve una notifica sul telefono degli amici (cioè un sms o e-mail, ecc)!

La collezione osservabile funziona allo stesso modo. Se aggiungi o rimuovi qualcosa da o verso di esso: qualcuno viene avvisato. E quando vengono avvisati, beh allora ti chiamano e avrai un orecchio pieno. Ovviamente le conseguenze sono personalizzabili tramite il gestore di eventi.

Questo riassume tutto!

è una raccolta che viene utilizzata per notificare l’interfaccia utente per modificare la raccolta, supporta la notifica automatica.

Utilizzato principalmente in WPF,

Dove supponiamo di avere un’interfaccia utente con una casella di riepilogo e un pulsante di aggiunta e quando fai clic sul pulsante un object di tipo supponiamo che la persona venga aggiunta alla raccolta obseravabl e tu leghi questa raccolta all’elemento ItemSource di Listbox, quindi non appena hai aggiunto un nuovo elemento nella raccolta, Listbox si aggiornerà e aggiungerà un altro elemento in essa.

Uno degli usi principali è che è ansible associare i componenti dell’interfaccia utente a uno e risponderanno in modo appropriato se i contenuti della raccolta cambiano. Ad esempio, se si associa un object ItemsView di ListView a uno, i contenuti di ListView si aggiorneranno automaticamente se si modifica la raccolta.

EDIT: Ecco alcuni esempi di codice da MSDN: http://msdn.microsoft.com/en-us/library/ms748365.aspx

In C #, agganciare il ListBox alla raccolta potrebbe essere semplice come

 listBox.ItemsSource = NameListData; 

sebbene, se non hai agganciato l’elenco come risorsa statica e definito NameItemTemplate, potresti voler sovrascrivere ToString () di PersonName. Per esempio:

 public override ToString() { return string.Format("{0} {1}", this.FirstName, this.LastName); } 
 class FooObservableCollection : ObservableCollection { 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().First(); }