¿Cuál es el uso de ObservableCollection en .net?

Question

¿Cuál es el uso de ObservableCollection en .net?

Answer 1

ObservableCollection es una colección que permite que el código fuera de la colección tenga en cuenta cuándo se producen cambios en la colección (agregar, mover, eliminar). Se usa mucho en WPF y Silverlight, pero su uso no se limita a allí. El código puede agregar controladores de eventos para ver cuándo ha cambiado la colección y luego reaccionar a través del controlador de eventos para hacer un procesamiento adicional. Esto puede estar cambiando una UI o realizando alguna otra operación.

El código siguiente en realidad no hace nada pero demuestra cómo adjuntaría un controlador en una clase y luego usaría los eventos args para reaccionar de alguna forma a los cambios.WPF ya tiene muchas operaciones como la actualización de la UI construida en lo que obtener de forma gratuita utilizando las 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

Uno de los mayores usos es que puede vincular los componentes de la interfaz de usuario a uno, y responderán adecuadamente si el contenido de la colección cambia. Por ejemplo, si vincula un ItemsSource de ListView a uno, los contenidos de ListView se actualizarán automáticamente si modifica la colección.

EDIT: He aquí algunos ejemplos de código de MSDN: http://msdn.microsoft.com/en-us/library/ms748365.aspx

En C#, enganchando el cuadro de lista a la colección podría ser tan fácil como

listBox.ItemsSource = NameListData; 

aunque si no lo ha enganchado la lista como recurso estático y NameItemTemplate definido, es posible que desee sobrescribir ToString de PersonName(). Por ejemplo:

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

Answer 3

Un ObservableCollection funciona esencialmente como una colección normal, excepto que implementa las interfaces:

• INotifyCollectionChanged,
• INotifyPropertyChanged

Como tal, es muy útil cuando quieras saber cuándo ha cambiado la colección. Se desencadena un evento que le indicará al usuario qué entradas se han agregado/eliminado o movido.

Lo que es más importante aún, son muy útiles cuando utiliza un enlace de datos en un formulario.

Answer 4

es una colección que se utiliza para notificar sobre todo a la interfaz de usuario para cambiar en la colección, es compatible con la notificación automática.

Se utiliza principalmente en WPF,

Donde dice suponga que tiene la interfaz de usuario con un cuadro de lista y el botón de añadir y cuando se hace clic en el botón que un objeto de tipo será añadido persona suponen a la obseravablecollection y que ates esta colección al ItemSource de Listbox, por lo que tan pronto como haya agregado un nuevo elemento en la colección, Listbox se actualizará y agregará un elemento más en él.

Answer 5

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

Answer 6

De Pro C# 5.0 and the .NET 4.5 Framework

La clase ObservableCollection<T> es muy útil, ya que tiene la capacidad de informar objetos externos cuando su contenido ha cambiado de alguna manera (como se puede adivinar, trabajar con ReadOnlyObservableCollection<T> es muy similar, pero de solo lectura en la naturaleza). De muchas formas, trabajar con es igual que trabajar con List<T>, ya que ambas clases implementan las mismas interfaces de núcleo. Lo que hace única a la clase ObservableCollection<T> es que esta clase admite un evento llamado CollectionChanged. Este evento se activará siempre que se inserte un nuevo elemento, se elimine (o reubique) un elemento actual o si se modifica toda la colección. Como cualquier evento, CollectionChanged se define en términos de un delegado, que en este caso es NotifyCollectionChangedEventHandler. Este delegado puede llamar a cualquier método que tome un objeto como el primer parámetro, y un NotifyCollectionChangedEventArgs como el segundo. Consideremos el siguiente Principal() método, que rellena una colección observable que contiene objetos Person y alambres el evento 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()); 
      } 
     } 
    } 
} 

El NotifyCollectionChangedEventArgs parámetro entrante define dos propiedades importantes, OldItems y NewItems, que le dará una lista de elementos que se encontraban actualmente en la colección antes de que se disparara el evento, y los nuevos elementos que participaron en el cambio. Sin embargo, querrá examinar estas listas solo bajo las circunstancias correctas. Recuerde que el evento CollectionChanged puede activarse cuando se agregan, eliminan, cambian o restablecen los artículos . Para descubrir cuál de estas acciones desencadenó el evento, , puede usar la propiedad Acción de NotifyCollectionChangedEventArgs. La acción de propiedad puede ser probados contra cualquiera de los siguientes miembros de la NotifyCollectionChangedAction enumeración:

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

Answer 7

Para aquellos que quieran una respuesta sin ningún código detrás de él (de auge y Tish) Voy a tirar mi mano hasta:

normales Colecciones - No hay Notificaciones

de vez en cuando voy a Nueva York y mi amigo me pregunta para comprar cosas Entonces llevo una lista de compras conmigo. La lista tiene un montón de cosas en allí como:

1. Los 7 hábitos de la gente altamente efectiva
2. de Clive Christian Majestad Imperial ($ 215.000)
3. Ferrari ($ 750.000)

Bueno, yo" No estoy comprando esas cosas. Así que las tachado y las elimino de la lista y agrego en su lugar:

1. 12 docenas de pelotas de golf Titleist.

Lo que pasa es que mi amigo no sabe lo que saco de la lista y lo que agrego. Amigo no recibe notificaciones

El ObservableCollection - notificaciones cuando los cambios realizados

Así que por lo general vienen a casa sin la mercancía y amigo de Nunca satisfechos.

Buuuut now friend tiene una aplicación en el teléfono de un amigo: cada vez que elimino algo de la lista: ¡un amigo recibe una notificación en el teléfono de sus amigos (es decir, un sms o correo electrónico, etc.)!

La colección observable funciona de la misma manera. Si agrega o quita algo desde o hacia él: alguien recibe una notificación. Y cuando se les notifica, bueno, entonces te llaman y te darán un oído completo. Por supuesto, las consecuencias se pueden personalizar a través del controlador de eventos.

¡Eso lo resume todo!