Jakie jest zastosowanie ObservableCollection w .net?
Jakie jest zastosowanie ObservableCollection w .net?
Odpowiedzi:
ObservableCollection to kolekcja, która pozwala kodowi spoza kolekcji być świadomym tego, kiedy nastąpią zmiany w kolekcji (dodawanie, przenoszenie, usuwanie). Jest intensywnie używany w WPF i Silverlight, ale jego użycie nie ogranicza się do tego. Kod może dodawać procedury obsługi zdarzeń, aby zobaczyć, kiedy zmieniła się kolekcja, a następnie reagować za pośrednictwem procedury obsługi zdarzeń, aby wykonać dodatkowe przetwarzanie. Może to być zmiana interfejsu użytkownika lub wykonanie innej operacji.
Poniższy kod tak naprawdę nic nie robi, ale pokazuje, jak dołączyć moduł obsługi do klasy, a następnie użyć argumentów zdarzeń, aby w jakiś sposób zareagować na zmiany. WPF ma już wiele operacji, takich jak odświeżanie wbudowanego interfejsu użytkownika, dzięki czemu można je uzyskać bezpłatnie podczas korzystania z 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
}
}
}
e.NewItems
i e.OldsItems
może być zerowy w zależności od akcji. Może rzucić NullReferenceException
.
ObservableCollection
Działa w zasadzie jak zwykły kolekcji poza tym, że implementuje interfejsy:
Jako taki jest bardzo przydatny, gdy chcesz wiedzieć, kiedy zmieniła się kolekcja. Wyzwalane jest zdarzenie, które poinformuje użytkownika, które wpisy zostały dodane / usunięte lub przeniesione.
Co ważniejsze, są one bardzo przydatne podczas korzystania z wiązania danych w formularzu.
Od Pro C # 5.0 i .NET 4.5 Framework
ObservableCollection<T>
Klasa jest bardzo przydatna tym, że posiada zdolność do informowania zewnętrznych obiektów, gdy jej zawartość zostały zmienione w jakiś sposób (jak można się domyślać, praca z
ReadOnlyObservableCollection<T>
jest bardzo podobny, ale tylko do odczytu w naturze). Pod wieloma względami praca z nią ObservableCollection<T>
jest identyczna z pracą z tym List<T>
, że obie te klasy implementują te same podstawowe interfejsy. Tym, co czyni tę ObservableCollection<T>
klasę wyjątkową, jest to, że ta klasa obsługuje zdarzenie o nazwie CollectionChanged
. To zdarzenie będzie uruchamiane za każdym razem, gdy zostanie wstawiony nowy element, bieżący element zostanie usunięty (lub przeniesiony) lub jeśli cała kolekcja zostanie zmodyfikowana. Jak każde zdarzenie, CollectionChanged jest zdefiniowane w kategoriach delegata, którym w tym przypadku jest
NotifyCollectionChangedEventHandler
. Ten delegat może wywołać dowolną metodę, która przyjmuje obiekt jako pierwszy parametr, orazNotifyCollectionChangedEventArgs
jako drugi. Rozważ następującą metodę Main (), która zapełnia obserwowalną kolekcję zawierającą obiekty Person i łączy
CollectionChanged
zdarzenie:
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());
}
}
}
}
Przychodzące NotifyCollectionChangedEventArgs
parametr definiuje dwie ważne właściwości,
OldItems
a NewItems
, co daje listę elementów, które są obecnie w zbiorach przed wydarzeniem zwolniony, a nowe elementy, które były zaangażowane w zmiany. Będziesz jednak chciał sprawdzić te listy tylko w odpowiednich okolicznościach. Przypomnij sobie, że zdarzenie CollectionChanged może zostać uruchomione, gdy elementy zostaną dodane, usunięte, przeniesione lub zresetowane. Aby dowiedzieć się, które z tych działań wywołały zdarzenie, możesz użyć właściwości Action NotifyCollectionChangedEventArgs. Właściwość Action można przetestować pod kątem dowolnego z następujących elementów NotifyCollectionChangedAction
wyliczenia:
public enum NotifyCollectionChangedAction
{
Add = 0,
Remove = 1,
Replace = 2,
Move = 3,
Reset = 4,
}
Dla tych, którzy chcą odpowiedzi bez żadnego kodu (boom-tish) podniosę rękę:
Normalne kolekcje - brak powiadomień
Co jakiś czas jeżdżę do Nowego Jorku, a moja żona prosi mnie o kupienie rzeczy. Więc biorę ze sobą listę zakupów. Lista zawiera wiele rzeczy, takich jak:
hahaha cóż, nie kupuję tych rzeczy. Skreślam je i usuwam z listy, a zamiast tego dodaje:
Więc zwykle wracam do domu bez towarów, a ona nigdy nie jest zadowolona. Chodzi o to, że nie wie o tym, co usuwam z listy i co dodam do niej; nie otrzymuje powiadomień.
The ObservableCollection - powiadomienia o dokonanych zmianach
Teraz, ilekroć coś usuwam z listy: dostaje powiadomienie na swój telefon (np. Sms / email itp.)!
Obserwowalna kolekcja działa w ten sam sposób. Jeśli dodasz lub usuniesz coś do niego lub z niego: ktoś zostanie powiadomiony. A kiedy zostaną powiadomieni, to zadzwonią do ciebie, a dostaniesz pełne ucho. Oczywiście konsekwencje można dostosować za pomocą modułu obsługi zdarzeń.
To wszystko podsumowuje!
Jednym z największych zastosowań jest to, że możesz powiązać komponenty interfejsu użytkownika z jednym i będą odpowiednio reagować, jeśli zawartość kolekcji się zmieni. Na przykład, jeśli powiążesz element Items ListView z jednym, zawartość ListView zostanie automatycznie zaktualizowana po zmodyfikowaniu kolekcji.
EDYCJA: Oto przykładowy kod z MSDN: http://msdn.microsoft.com/en-us/library/ms748365.aspx
W języku C # podpięcie ListBox do kolekcji może być tak proste, jak
listBox.ItemsSource = NameListData;
chociaż jeśli nie podłączyłeś listy jako zasobu statycznego i nie zdefiniowałeś NameItemTemplate, możesz zastąpić ToString () PersonName. Na przykład:
public override ToString()
{
return string.Format("{0} {1}", this.FirstName, this.LastName);
}
jest to kolekcja służąca do powiadamiania głównie interfejsu użytkownika o zmianie kolekcji, obsługuje automatyczne powiadamianie.
Używany głównie w WPF,
Załóżmy, że załóżmy, że masz interfejs użytkownika z listą i przyciskiem dodawania, a po kliknięciu tego przycisku obiekt typu przypuszcza, że osoba zostanie dodana do zbioru obseravablecollection, a ty połączysz tę kolekcję z ItemSource of Listbox, tak szybko jak tylko dodasz nowy element w kolekcji, Listbox zaktualizuje się i doda jeszcze jeden element.
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();
}