c# - ejemplo - ¿Cuál es el uso de ObservableCollection en.net?

observablecollection xamarin

Question

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

Answer 1

De Pro C # 5.0 y .NET 4.5 Framework

La clase ObservableCollection<T> es muy útil ya que tiene la capacidad de informar a los 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) . En muchos sentidos, trabajar con ObservableCollection<T> es idéntico al trabajo con List<T> , dado que ambas clases implementan las mismas interfaces centrales. Lo que hace que la clase ObservableCollection<T> única 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 primer parámetro, y NotifyCollectionChangedEventArgs como el segundo. Considere el siguiente método Main (), que rellena una colección observable que contiene objetos Person y conecta 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 parámetro entrante NotifyCollectionChangedEventArgs define dos propiedades importantes, OldItems y NewItems , que le proporcionarán una lista de los artículos que se encontraban actualmente en la colección antes de que se NewItems 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, reubican o restablecen elementos. Para descubrir cuál de estas acciones desencadenó el evento, puede usar la propiedad Acción de NotifyCollectionChangedEventArgs. La propiedad Acción se puede probar con cualquiera de los siguientes miembros de la enumeración NotifyCollectionChangedAction :

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

Answer 2

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 más que demostrar cómo adjuntarías un controlador en una clase y luego usar los eventos args para reaccionar de alguna manera a los cambios. WPF ya tiene muchas operaciones, como refrescar la interfaz de usuario incorporada para que pueda obtenerlas de forma gratuita al usar 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 3

Para aquellos que quieran una respuesta sin ningún código detrás de ella (boom-tish), levantaré mi mano:

Colecciones normales: sin notificaciones

De vez en cuando voy a Nueva York y mi amigo me pide que compre cosas. Entonces llevo una lista de compras conmigo. La lista tiene muchas cosas como:

1. Los 7 hábitos de personas altamente efectivas
2. Majestad Imperial de Clive Christian ($ 215,000)
3. Ferrari ($ 750,000)

Bueno, no estoy comprando esas cosas. Así que las tacha y las elimino de la lista y agrego en su lugar:

1. 12 docenas de pelotas de golf Titleist.

El caso es que mi amigo no sabe qué es lo que saqué de la lista y qué agregué a él. Amigo no recibe notificaciones

The ObservableCollection - notificaciones cuando se realizan cambios

Así que generalmente vuelvo a casa sin los productos y mi amigo nunca está satisfecho.

Buuuut ahora amigo 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 un 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!

Answer 4

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

• INotifyCollectionChanged ,
• INotifyPropertyChanged

Como tal, es muy útil cuando quieres 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.

Más importante aún, son muy útiles cuando se usa el enlace de datos en un formulario.

Answer 5

Uno de los usos más importantes 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.

EDITAR: Aquí hay un código de muestra de MSDN: http://msdn.microsoft.com/en-us/library/ms748365.aspx

En C #, conectar el ListBox a la colección podría ser tan fácil como

listBox.ItemsSource = NameListData;

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

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

Answer 6

es una colección que se utiliza para notificar principalmente la IU para cambiar en la colección, admite notificaciones automáticas.

Utilizado principalmente en WPF,

Donde supongamos que tiene UI con un cuadro de lista y botón Agregar y al hacer clic en el botón un objeto de tipo suponer persona se agregará a la colección obseravable y enlazará esta colección al ItemSource de Listbox, por lo que tan pronto como haya agregado un nuevo elemento de la colección, Listbox se actualizará y agregará un elemento más en él.

Answer 7

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