FastBindingListT Class

[SerializableAttribute]
public class FastBindingList<T> : FastLookupCollection<T>, 
	IBindingList, ICollection, IEnumerable, IList, ICancelAddNew, 
	IRaiseItemChangedEvents, IDisposable

<SerializableAttribute>
Public Class FastBindingList(Of T)
	Inherits FastLookupCollection(Of T)
	Implements IBindingList, ICollection, IEnumerable, IList, 
	ICancelAddNew, IRaiseItemChangedEvents, IDisposable

[SerializableAttribute]
generic<typename T>
public ref class FastBindingList : public FastLookupCollection<T>, 
	IBindingList, ICollection, IEnumerable, IList, ICancelAddNew, 
	IRaiseItemChangedEvents, IDisposable

[<SerializableAttribute>]
type FastBindingList<'T> = 
    class
        inherit FastLookupCollection<'T>
        interface IBindingList
        interface ICollection
        interface IEnumerable
        interface IList
        interface ICancelAddNew
        interface IRaiseItemChangedEvents
        interface IDisposable
    end

Inheritance

Object    VirtualCollectionT    FastLookupCollectionT    FastBindingListT

Derived

KGySoft.ComponentModelSortableBindingListT

Implements

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

Type Parameters

T

The type of elements in the list.

This section provides some examples for feature comparisons with BindingListT.

Incompatibility with BindingListT:

• BindingListT is derived from CollectionT, whereas FastBindingListT is derived from FastLookupCollectionT, which is derived from VirtualCollectionT. Both types implement the IListT interface though.
• BindingList<T>.AddingNew event has AddingNewEventHandler type, which uses AddingNewEventArgs, whereas in FastBindingListT the AddingNew event has EventHandlerTEventArgs type where TEventArgs is AddingNewEventArgsT. The main difference between the two event arguments that the latter is generic.
• In FastBindingListT the AllowRemove property is initialized to if the wrapped list is read-only.
  In contrast, in BindingListT this property is by default.
• In FastBindingListT the AllowNew property is initialized to if the wrapped list is read-only, or when T is not a value type and has no parameterless constructor. The return value of AllowNew does not change when AddingNew event is subscribed and setting AllowNew does not reset the list.
  In contrast, in BindingListT this property is if T is not a primitive type and has no public parameterless constructor. However, return value of BindingList<T>.AllowNew can change when BindingList<T>.AddingNew event is subscribed, and setting the BindingList<T>.AllowNew property resets the list.
• Calling AddNew throws InvalidOperationException if AllowNew is .
• Calling Remove or Clear throws InvalidOperationException if AllowRemove is .
• AddNewCore returns T instead of object.
• If AddNewCore is called for a T type, which cannot be instantiated automatically and the AddingNew event is not subscribed or returns , then an InvalidOperationException will be thrown. In contrast, BindingList<T>.AddNewCore can throw an InvalidCastException or NotSupportedException.
• FastBindingListT might not work properly if items can change their hash code while they are added to the collection.

New features and improvements compared to BindingListT:

• Disposable – The FastBindingListT 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. The DisposeBehavior property determines how to handle the possibly disposable wrapped collection and the items when disposing this FastBindingListT instance. After disposing accessing the public members may throw ObjectDisposedException.
• Overridable properties – In FastBindingListT the AllowNew, AllowRemove, AllowEdit and RaiseListChangedEvents properties are virtual.
• Find support – In FastBindingListT the IBindingList.Find method is supported. In BindingListT this throws a NotSupportedException.
• Public members for finding and sorting – FastBindingListT offers several public Find and ApplySort overloads. RemoveSort method and IsSorted/SortProperty properties are also public instead of explicit interface implementations.
• New virtual members – AddIndexCore and RemoveIndexCore methods can be overridden to implement IBindingList.AddIndex and IBindingList.RemoveIndex calls.

Reference