Updated: July 2008
Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed.
<SerializableAttribute> _ Public Class ObservableCollection(Of T) _ Inherits Collection(Of T) _ Implements INotifyCollectionChanged, INotifyPropertyChanged
Dim instance As ObservableCollection(Of T)
[SerializableAttribute] public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged
[SerializableAttribute] generic<typename T> public ref class ObservableCollection : public Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged
JScript does not support generic types or methods.
See Remarks.
The type of elements in the collection.
In many cases the data that you work with is a collection of objects. For example, a common scenario in data binding is to use an ItemsControl such as a ListBox, ListView, or TreeView to display a collection of records.
You can enumerate over any collection that implements the IEnumerable interface. However, to set up dynamic bindings so that insertions or deletions in the collection update the UI automatically, the collection must implement the INotifyCollectionChanged interface. This interface exposes the CollectionChanged event, an event that should be raised whenever the underlying collection changes.
WPF provides the ObservableCollection<(Of <(T>)>) class, which is a built-in implementation of a data collection that implements the INotifyCollectionChanged interface.
Before implementing your own collection, consider using ObservableCollection<(Of <(T>)>) or one of the existing collection classes, such as List<(Of <(T>)>), Collection<(Of <(T>)>), and BindingList<(Of <(T>)>), among many others. If you have an advanced scenario and want to implement your own collection, consider using IList, which provides a non-generic collection of objects that can be individually accessed by index. Implementing IList provides the best performance with the data binding engine.
To fully support transferring data values from binding source objects to binding targets, each object in your collection that supports bindable properties must implement an appropriate property changed notification mechanism such as the INotifyPropertyChanged interface.
For more information, see "Binding to Collections" in Data Binding Overview.
ObservableCollection<(Of <(T>)>) can be used as a XAML object element in Windows Presentation Foundation (WPF), in versions 3.0 and 3.5. However, the usage has substantial limitations.
ObservableCollection<(Of <(T>)>) must be the root element, because the x:TypeArguments attribute that must be used to specify the constrained type of the generic ObservableCollection<(Of <(T>)>) is only supported on the object element for the root element.
You must declare an x:Class attribute (which entails that the build action for this XAML file must be Page or some other build action that compiles the XAML).
ObservableCollection<(Of <(T>)>) is in a namespace and assembly that are not initially mapped to the default XML namespace. You must map a prefix for the namespace and assembly, and then use that prefix on the object element tag for ObservableCollection<(Of <(T>)>).
A more straightforward way to use ObservableCollection<(Of <(T>)>) capabilities from XAML in an application is to declare your own non-generic custom collection class that derives from ObservableCollection<(Of <(T>)>), and constrains it to a specific type. Then map the assembly that contains this class, and reference it as an object element in your XAML.
This example shows how to create and bind to a collection that derives from the ObservableCollection<(Of <(T>)>) class, which is a collection class that provides notifications when items get added or removed.
The following example shows the implementation of a NameList collection:
Public Class NameList Inherits ObservableCollection(Of PersonName) ' Methods Public Sub New() MyBase.Add(New PersonName("Willa", "Cather")) MyBase.Add(New PersonName("Isak", "Dinesen")) MyBase.Add(New PersonName("Victor", "Hugo")) MyBase.Add(New PersonName("Jules", "Verne")) End Sub End Class Public Class PersonName ' Methods Public Sub New(ByVal first As String, ByVal last As String) Me._firstName = first Me._lastName = last End Sub ' Properties Public Property FirstName() As String Get Return Me._firstName End Get Set(ByVal value As String) Me._firstName = value End Set End Property Public Property LastName() As String Get Return Me._lastName End Get Set(ByVal value As String) Me._lastName = value End Set End Property ' Fields Private _firstName As String Private _lastName As String End Class
public class NameList : ObservableCollection<PersonName> { public NameList() : base() { Add(new PersonName("Willa", "Cather")); Add(new PersonName("Isak", "Dinesen")); Add(new PersonName("Victor", "Hugo")); Add(new PersonName("Jules", "Verne")); } } public class PersonName { private string firstName; private string lastName; public PersonName(string first, string last) { this.firstName = first; this.lastName = last; } public string FirstName { get { return firstName; } set { firstName = value; } } public string LastName { get { return lastName; } set { lastName = value; } } }
You can make the collection available for binding the same way you would with other common language runtime (CLR) objects, as described in How to: Make Data Available for Binding in XAML. For example, you can instantiate the collection in XAML and specify the collection as a resource, as shown here:
<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:c="clr-namespace:SDKSample" x:Class="SDKSample.Window1" Width="400" Height="280" Title="MultiBinding Sample"> <Window.Resources> <c:NameList x:Key="NameListData"/> ... </Window.Resources>
You can then bind to the collection:
<ListBox Width="200" ItemsSource="{Binding Source={StaticResource NameListData}}" ItemTemplate="{StaticResource NameItemTemplate}" IsSynchronizedWithCurrentItem="True"/>
The definition of NameItemTemplate is not shown here. For the complete sample, see Implementing Parameterized MultiBinding Sample.
The objects in your collection must satisfy the requirements described in the Binding Sources Overview. In particular, if you are using OneWay or TwoWay (for example, you want your UI to update when the source properties change dynamically), you must implement a suitable property changed notification mechanism such as the INotifyPropertyChanged interface.
For more information, see the Binding to Collections section in the Data Binding Overview.
Windows 7, Windows Vista, Windows XP SP2, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003
Date
History
Reason
July 2008
Added new member: ObservableCollection<(Of <(T>)>) constructor.
SP1 feature change.
You need to add a reference to an unorthodox sounding MS assembly. And WindowsBase.dll does not always show up in the Add Reference dialog so you may have to browse for it on your HDD (which I've heard reports of being in different folders on different systems).