ObservableBindingListT Class

[SerializableAttribute]
public class ObservableBindingList<T> : Collection<T>, 
	IDisposable, INotifyCollectionChanged, INotifyPropertyChanged, IBindingList, ICollection, 
	IEnumerable, IList, ICancelAddNew, IRaiseItemChangedEvents

<SerializableAttribute>
Public Class ObservableBindingList(Of T)
	Inherits Collection(Of T)
	Implements IDisposable, INotifyCollectionChanged, INotifyPropertyChanged, IBindingList, 
	ICollection, IEnumerable, IList, ICancelAddNew, IRaiseItemChangedEvents

[SerializableAttribute]
generic<typename T>
public ref class ObservableBindingList : public Collection<T>, 
	IDisposable, INotifyCollectionChanged, INotifyPropertyChanged, IBindingList, ICollection, 
	IEnumerable, IList, ICancelAddNew, IRaiseItemChangedEvents

[<SerializableAttribute>]
type ObservableBindingList<'T> = 
    class
        inherit Collection<'T>
        interface IDisposable
        interface INotifyCollectionChanged
        interface INotifyPropertyChanged
        interface IBindingList
        interface ICollection
        interface IEnumerable
        interface IList
        interface ICancelAddNew
        interface IRaiseItemChangedEvents
    end

Inheritance

Object    CollectionT    ObservableBindingListT

Implements

ICollection, IEnumerable, IList, INotifyCollectionChanged, IBindingList, ICancelAddNew, INotifyPropertyChanged, IRaiseItemChangedEvents, IDisposable

Type Parameters

T

The type of elements in the collection.

The ObservableBindingListT can be used in any environment where either IBindingList or INotifyCollectionChanged (mainly ObservableCollectionT) types are supported.

If initialized by another IBindingList or INotifyCollectionChanged implementations, the ObservableBindingListT will capture and delegate also the events of the inner collections.

If the ObservableBindingListT is initialized by the default constructor it will use a SortableBindingListT inside.

Differences to the ObservableCollectionT class:

• The PropertyChanged event is raised also for a sort of additional properties, such as AllowNew, AllowEdit, AllowRemove, RaiseCollectionChangedEvents, RaiseItemChangedEvents and RaiseListChangedEvents.
• If T implements INotifyPropertyChanged, then the CollectionChanged event can be raised even for property changes of the contained elements. This behavior can be adjusted by the RaiseItemChangedEvents property.
• There is no constructor that accepts an IEnumerableT instance. Instead, an instance of IListT must be provided.
• When the ObservableBindingListT is initialized by another IListT, then the passed instance will be wrapped rather than just copying the elements. Therefore the changes performed on the ObservableBindingListT will be reflected also in the wrapped list.
  In contrast, passing any collection to an ObservableCollectionT will copy the items in a new ListT to be used inside the ObservableCollectionT.
• In ObservableBindingListT the OnCollectionChanged method simply raises the CollectionChanged event without calling BlockReentrancy, which is rather called explicitly whenever it is needed.
• In ObservableBindingListT the Add, Insert, Remove, RemoveAt, Clear and Move methods, and the setter of the Items property can throw a NotSupportedException if the wrapped collection is read-only.

Differences to the BindingListT class:

• In case of multiple subscribers of the CollectionChanged and ListChanged events reentrant changes during the event invocation is protected similarly to the ObservableCollectionT class. However, the BlockReentrancy method is not called from the OnListChanged and OnCollectionChanged methods. Instead, it should be called explicitly when raising any or both of these events.
• If the initializer collection that is passed to the constructor is an IBindingList or INotifyCollectionChanged implementation, then changes performed directly on the wrapped collection are also captured and delegated to the self events.
• Accessing the ObservableBindingListT through the IBindingList, ICancelAddNew and IRaiseItemChangedEvents interfaces are in some aspects different from a regular BindingListT. Their implementation is as follows:

  IBindingList

  • AddNew:
    • If AllowNew returns , then an InvalidOperationException will be thrown.
    • Otherwise, if the underlying list implements IBindingList, then its AddNew implementation will be called.
    • Otherwise, if T is a value type or has a parameterless constructor, then a new item of T is created and added to the list.
    • Otherwise, an InvalidOperationException will be thrown.
  • AllowNew:
    • Returns if the underlying list implements IBindingList, and its AllowNew returns .
    • Otherwise, returns the lastly set value. Or, if was never set, returns if T is a value type or has a parameterless constructor, and the underlying collection is not read-only.
  • AllowEdit and AllowRemove:
    • Both return if the underlying list implements IBindingList, and its AllowEdit/AllowRemove return .
    • Otherwise, they return the lastly set value. Or, if they were never set, they return if the underlying collection is not read-only.
  • SupportsChangeNotification: returns always .
  • SupportsSearching, SupportsSorting and IsSorted: If the underlying list implements IBindingList, then the values of the underlying properties are returned; otherwise, they all return .
  • SortProperty: If the underlying list implements IBindingList, then the value of the underlying property is returned; otherwise, returns .
  • SortDirection: If the underlying list implements IBindingList, then the value of the underlying property is returned; otherwise, returns Ascending.
  • Find, ApplySort and RemoveSort: If the underlying list implements IBindingList, then their underlying implementation is called; otherwise, they all throw NotSupportedException.
  • AddIndex and RemoveIndex: If the underlying list implements IBindingList, then their underlying implementation is called; otherwise, they do nothing.

  ICancelAddNew

  • EndNew: If the underlying list implements ICancelAddNew, then the underlying implementation is called; otherwise, commits the last pending new item added by the AddNew method.
  • CancelNew: If the underlying list implements ICancelAddNew, then the underlying implementation is called; otherwise, discards the last pending new item added by the AddNew method.

  IRaiseItemChangedEvents

  Returns the value of the RaiseItemChangedEvents, which is a settable property. See the RaiseItemChangedEvents property for more details.

IDisposable support:
The ObservableBindingListT implements the IDisposable interface. When an instance is disposed, then both incoming and outgoing event subscriptions (self events and PropertyChanged event of the elements) are removed. If the wrapped collection passed to the constructor is disposable, then it will also be disposed. After disposing accessing the public members may throw ObjectDisposedException.

Reference