Class which limits calls to a method by using a timer which effectively calls the method instead. To limit calls to a given method, pass it as a lambda to the method Call(Action, Double, ISynchronizeInvoke). The first time Call(Action, Double, ISynchronizeInvoke) is called, a timer is started and the lambda is stored. When the timer elapses after the specified number of milliseconds, the stored lambda is called and the timer is reset, though not started again. When Call(Action, Double, ISynchronizeInvoke) is called while the timer is running (so between the first call and the moment the timer elapses) the call is ignored. This way you can limit calls to a given method to 1 per interval. This is useful for situation where you have a lot of events coming from different sources which all result in a single call to a given method.

Class which extends KeyedCommandifiedList so that it picks up detailed changes in elements in this list and propagates them to subscribers in a single event. Subscribers therefore don't have to subscribe to all detailed change events of all the elements in the list.

Generic list class which is command-aware: it performs its actions through commands, so all actions on this list are undoable.

Class which represents a member variable which is commandified, so setting the value occurs through commands.

Class which is used to implement IEditableObject on objects. It tracks state and performs actions.

Simple class which is used as a container for error information for IDataErrorInfo implementations.

Class which throttles an event pipeline. It offers unique event raising during a fixed interval. Instances collect events and with each interval only the unique events (last event first) from that batch are raised. Every event found in the batch which is equal to an already raised event (which has equal event arguments) is ignored. Use this class to limit a large amount of events which are equal and lead to e.g. repainting a UI, to act like a event instead. This can greatly increase performance in scenarios where events are used to manipulate UI objects or other objects and repetitive changes lead to the same situation (e.g. 100 times the event that an element has changed in a short time (e.g. 100ms) where each time a TreeNode is repainted because 'the element has changed' is redundant: the last event in the batch is enough, it already repaints the node completely).

Events are compared based on the event args, which are compared to event arguments already processed. Use one throttler per event handler.

Extension methods for classes defined in the GeneralDataStructures namespace

Class which implements the IGrouping interface to return grouped results in a query

Special commandified list which can create an index based on a key.

Simple doubly linked list which doesn't suffer from the problem that one can't concat two linked lists in O(1). The .NET LinkedList class can't be used to fast connect two LinkedLists together without traversing all nodes of one of them (as each node has a reference to its containing list)

Simple class which can be used as a bucket in a linked list. The .NET LinkedList class has a downside that you can't concatenate two linked lists in O(1) time: a LinkedListNode is part of a LinkedList object and to connect two lists, one has to traverse one of them in full.

Extension to the normal Dictionary. This class can store more than one value for every key. It keeps a HashSet for every Key value. Calling Add with the same Key and multiple values will store each value under the same Key in the Dictionary. Obtaining the values for a Key will return the HashSet with the Values of the Key. It can also merge with other instances of MultiValueDictionary, as long as the TKey and TValue types are equal.

Special version of the bindinglist, where the generic elements have to implement IEventBasedObserver to get their events managed.

Simple class which represents a pair of values which can be of different types. It's not a struct so it can be modified in-place inside other constructs.

Simple class which represents a pair of values which can be of different types, and which is readonly.