Provides some extensions for arrays.

Implements an collection of ascending integers, that are stored in a list of ranges.

Manages a bunch of cached objects. The cached object are accessed by a key. In this instance more than one object with the same key can be stored, but it is presumed that all objects which are stored under the same key are considered equal. Usage: Try to take out a cached object with CachedObjectManagerByMaximumNumberOfItems.TryTake. If no such object exists, create a new one. After usage of the object, put it back with CachedObjectManagerByMaximumNumberOfItems.Add. If after adding an object more than the allowed number of objects exists, the object which is used the least will be removed from that instance. The methods in this instance are thread safe.

Implements a heap based priority queue that hold only keys. The key with the minimum value can then retrieved from the queue. This class is not thread safe.

Concurrent linked list with the restriction that its members are unique, i.e. an item identified by a key can appear only once in the list.

Represents an tokenized concurrent priority queue. Inserted items are associated with a token that can later be used to modify the item in the queue. There are two function sets to add queue items, depending on whether or not the queue is generating tokens by itself. Use Enqueue... functions, if the tokens are generated by the queue itself, or use Add.. functions if you provide the token.

Represents a range of consecutive integers. The range can be empty (in this case both ContiguousIntegerRange.Start as well as ContiguousIntegerRange.Count are zero).

Represents a range of consecutive non-negative integers.

Extensions to the IEnumerable interface.

Extends the operations for Flag Enumerations with setting and clearing of individual flags.

Sorted collection of integers, sorted so that the smallest integers come first.

Represents a contiguous range of integers.

Direction in which list elements will be handled.

Defines an interface of a node, with has a parent node.

Extends the IList interface by a function that allows to swap two items by index.

Defines a tree node, where the childs can be accessed by index. There is no reference to the node's parent.

Defines a tree node with parent. The child nodes can be accessed by index.

Defines a simple tree node, where the child nodes are enumerable. There is no reference to the node's parent.

Defines a simple tree node with parent.

Defines a tree node, where the childs can be accessed by index. There is no reference to the node's parent.

Supports movement of selected items up/down in a list.

Generic list that implements the INotifyCollectionChanged interface to notify changed. Does additionally implement ObservableList.MoveToLowerIndex and ObservableList.MoveToHigherIndex as well as ObservableList.AddRange.

List of items of class T. From this list partitions can be created, which basically are views inside this list, which have certain selection criterions. See remarks for details.

Determines the behavior when an item is inserted in the PartitionableList

Implements a heap based priority queue that hold only keys. The key with the minimum value can then retrieved from the queue. This class is not thread safe.

Implements algorithms common for all trees.

A collection that allows its elements to be garbage-collected (unless there are other references to the elements). Elements will disappear from the collection when they are garbage-collected. The WeakCollection is not thread-safe, not even for read-only access! No methods may be called on the WeakCollection while it is enumerated, not even a Contains or creating a second enumerator. The WeakCollection does not preserve any order among its contents; the ordering may be different each time the collection is enumerated. Since items may disappear at any time when they are garbage collected, this class cannot provide a useful implementation for Count and thus cannot implement the ICollection interface.