Epiforge.Extensions.Collections 4.0.0

• net10.0

  • Epiforge.Extensions.Components (>= 4.1.1)

• net6.0

  • Epiforge.Extensions.Components (>= 4.1.1)
  • System.Collections.Immutable (>= 8.0.0)

• net7.0

  • Epiforge.Extensions.Components (>= 4.1.1)
  • System.Collections.Immutable (>= 8.0.0)

• net8.0

  • Epiforge.Extensions.Components (>= 4.1.1)

• net9.0

  • Epiforge.Extensions.Components (>= 4.1.1)

An ObservableRangeCollection which raises a single event for a range operation now also announces that its indexer has changed, as it already did when raising an event for each element and as the collection it derives from has always done. Only the count was announced before, so anything bound to an indexed position refreshed under one setting of RaiseCollectionChangedEventsForIndividualElements and not the other, decided by a constructor argument. MoveRange, which announced nothing at all in that mode, now announces the indexer; a replacement of the same length announces the indexer without announcing the count, which has not changed.
NotifyDictionaryChangedEventArgs now throws ArgumentNullException when the items it is handed are null. That parameter was already declared as never null, and a null produced an event carrying nothing rather than an error, which is a wrong notification instead of a lenient one. The constructor which takes new and old items separately still accepts null for either side, where null means that side has no items.
RemoveAll, GetAndRemoveAll and the two RemoveRange overloads which take items on an ObservableRangeCollection now honour RaiseCollectionChangedEventsForIndividualElements, which they had ignored. That flag exists so a collection can be bound to a consumer which cannot process an event carrying more than one item, and none of these methods ever emitted one, so no collection which set the flag is affected. A collection which did not set it now receives one event for each run of adjacent items removed rather than one for each item, so removing a contiguous block raises a single event; removing alternating items raises the same number of events as before. RemoveRange also visits the collection once instead of searching it for each item supplied, which removes a cost that grew with the size of the collection multiplied by the number of items to remove; it now removes items in the order they occur in the collection rather than the order they were supplied, which changes the order events are raised in but not which items are removed.
Every range operation on an ObservableRangeCollection which raises a single event now announces its changed properties before that event rather than after, matching the collection it derives from and the order it already used when raising an event for each element.
An ObservableDictionary, ObservableSortedDictionary or ObservableConcurrentDictionary now announces that its indexer has changed whenever its contents change, as the observable collection in this package already did and as anything bound to a particular key needs in order to refresh. Only the count was announced before, so replacing the value stored under a key announced nothing at all.
Adding or removing a single element from any of those three dictionaries builds the event describing it once rather than twice. The single key and value were placed in a collection, and that collection was then copied into another, on every such change whether or not anything was listening.
ReplaceAll and ReplaceRange on an ObservableRangeCollection no longer describe a replacement of one number of items by a different number as a single Replace event. A consumer reading such an event pairwise, taking the first new item to stand for the first old one, ran out of items on one side with no way to know which. Such a replacement now replaces as many items as both sides have and then adds or removes the surplus, so replacing four items with three is a Replace of three followed by a Remove of one, and replacing two with four is a Replace of two followed by an Add of two. A replacement of equal length is still a single Replace, replacing everything with nothing remains a single Remove, replacing nothing with something is now a single Add, and replacing nothing with nothing announces nothing at all rather than an empty event.
ObservableRangeCollection gains ResetRemovingAll, which removes every item satisfying a predicate and announces it with one Reset event. The cost of RemoveAll grows with the size of the collection multiplied by the number of items removed, because it shifts the remainder down for each one; the cost of the new method is a single pass, which for a sixteen thousand element collection with three quarters of it matching is 56 microseconds and 62.6 kilobytes. RemoveAll remains the one to use when consumers need to be told which items left and from where, and it allocates less when the predicate matches under about four percent of the collection.
None of the three dictionaries builds the event describing a change unless something is listening for it. The event was constructed at each call site before the method which raises it could check, so a dictionary nothing was subscribed to still paid to describe changes no one received; a removal from one now allocates nothing whatsoever. A derivation which overrides OnChanged in order to observe changes rather than to raise them will no longer be called when nothing is subscribed, and should subscribe to DictionaryChanged instead.
An ObservableRangeCollection whose elements are themselves lists now describes the removal of one of them as a single item rather than as that item's contents. The event arguments have separate constructors for one changed item and for a list of them, and an element which implements IList selected the second, so removing one two-element array from such a collection announced that two elements had been removed.