Что такое ObservableCollection в .net?
Что такое ObservableCollection в .net?
Ответ 1
ObservableCollection - это коллекция, которая позволяет коду вне коллекции знать, когда происходят изменения в коллекции (добавление, перемещение, удаление). Он активно используется в WPF и Silverlight, но его использование не ограничивается этим. Код может добавить обработчики событий, чтобы видеть, когда коллекция изменилась, и затем реагировать через обработчик событий, чтобы выполнить некоторую дополнительную обработку. Это может быть изменение пользовательского интерфейса или выполнение какой-либо другой операции.
Приведенный ниже код ничего не делает, но демонстрирует, как вы присоединяете обработчик к классу, а затем используете аргументы события, чтобы каким-то образом реагировать на изменения. В WPF уже есть много операций, таких как обновление встроенного пользовательского интерфейса, поэтому вы можете получить их бесплатно при использовании 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
}
}
}
Ответ 2
ObservableCollection работает по существу как обычная коллекция, за исключением того, что она реализует
интерфейсы:
Таким образом, это очень полезно, когда вы хотите знать, когда коллекция изменилась. Событие запускается, чтобы сообщить пользователю, какие записи были добавлены/удалены или перемещены.
Более важно, что они очень полезны при использовании привязки данных в форме.
Ответ 3
Из Pro С# 5.0 и .NET 4.5 Framework
Класс ObservableCollection<T> очень полезен тем, что он имеет возможность информировать внешние объекты
когда его содержимое каким-то образом изменилось (как вы могли догадаться, работая с
ReadOnlyObservableCollection<T> очень похож, но доступен только для чтения).
Во многих отношениях работа с
ObservableCollection<T> идентичен работе с List<T>, учитывая, что оба этих класса
реализовать те же основные интерфейсы. Что делает класс ObservableCollection<T> уникальным, так это то, что это
класс поддерживает событие с именем CollectionChanged. Это событие срабатывает всякий раз, когда вставлен новый элемент, текущий элемент удаляется (или перемещается) или изменяется вся коллекция.
Как и любое событие, CollectionChanged определяется в терминах делегата, который в этом случае
NotifyCollectionChangedEventHandler. Этот делегат может вызывать любой метод, который принимает объект в качестве первого параметра, а NotifyCollectionChangedEventArgs - как второй. Рассмотрим следующие основные()
метод, который заполняет наблюдаемую коллекцию, содержащую объекты Person и проводки
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());
}
}
}
}
Входящий параметр NotifyCollectionChangedEventArgs определяет два важных свойства,
OldItems и NewItems, который предоставит вам список элементов, которые были в данный момент в коллекции до запуска события, и новые элементы, которые были вовлечены в изменение. Тем не менее, вы захотите изучить эти списки только при правильных обстоятельствах. Напомним, что событие CollectionChanged может срабатывать, когда
элементы добавляются, удаляются, перемещаются или reset. Чтобы узнать, какое из этих действий вызвало событие,
вы можете использовать свойство Action для NotifyCollectionChangedEventArgs. Свойством Action может быть
протестирован против любого из следующих членов перечисления NotifyCollectionChangedAction:
public enum NotifyCollectionChangedAction
{
Add = 0,
Remove = 1,
Replace = 2,
Move = 3,
Reset = 4,
}
Ответ 4
Объяснение без кода
Для тех, кто хочет получить ответ без какого-либо кода (бум-тиш), я подниму руку:
Обычные Коллекции - Нет Уведомлений
Время от времени я иду в Нью-Йорк, и мой друг просит меня купить вещи. Поэтому я беру список покупок с собой. В списке есть много вещей, таких как:
- Сумочка Louis Vuitton ($ 5000)
- Духи Императорского Величества Клайва Христиана ($ 215 000)
- Солнцезащитные очки Gucci ($ 2000)
Ну, я не покупаю эти вещи. Поэтому я вычеркиваю их, удаляю из списка и добавляю:
- 12 десятков титульных мячей для гольфа.
- 12 фунтов мяч для боулинга.
Поэтому я обычно прихожу домой без товаров и она никогда не радует. Дело в том, что она не знает о том, что я исключаю из списка и что я к нему добавляю. Друг не получает уведомлений.
The ObservableCollection - уведомления о внесенных изменениях
Теперь, когда я удаляю что-то из списка: она получает уведомление на свой телефон (например, смс, электронная почта и т.д.)!
Наблюдаемая коллекция работает точно так же. Если вы добавляете или удаляете что-либо в или из него: кто-то получает уведомление. И когда они будут уведомлены, ну, тогда они позвонят вам, и вы получите полный слух. Конечно, последствия настраиваются с помощью обработчика событий.
Это подводит итог всего этого!
Ответ 5
Одним из самых больших применений является то, что вы можете связывать компоненты пользовательского интерфейса с одним, и они будут реагировать соответствующим образом, если содержимое коллекции изменится. Например, если вы привязываете ListView ItemsSource к одному, содержимое ListView будет автоматически обновляться, если вы измените коллекцию.
EDIT: Вот пример кода из MSDN: http://msdn.microsoft.com/en-us/library/ms748365.aspx
В С# подключение ListBox к коллекции может быть таким же простым, как
listBox.ItemsSource = NameListData;
хотя, если вы не зацепили список в качестве статического ресурса и не определили NameItemTemplate, вы можете переопределить PersonName ToString(). Например:
public override ToString()
{
return string.Format("{0} {1}", this.FirstName, this.LastName);
}
Ответ 6
это коллекция, которая используется для уведомления в основном пользовательского интерфейса для изменения в коллекции, поддерживает автоматическое уведомление.
В основном используется в WPF,
Где, скажем, предположим, что у вас есть пользовательский интерфейс со списком и кнопкой добавления, и когда вы нажимаете на кнопку, объект типа предполагается, что человек будет добавлен в obseravablecollection, и вы привяжете эту коллекцию к ItemSource Listbox, так что как только вы добавили новый элемент в коллекцию, Listbox обновит себя и добавит еще один элемент в нем.
Ответ 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();
}