Namespace Ecng.Collections
Classes
- BackwardComparer<T>
Provides a comparer that compares objects in reverse order.
- BaseBlockingQueue<T, TF>
Abstract base class for a blocking queue implementation with a generic type and an inner collection.
- BaseCollection<TItem, TCollection>
Represents a base class for a generic collection with event notifications and inner collection management.
- BaseEnumerator<TEnumerable, TItem>
Represents an abstract base class for an enumerator over a generic enumerable source.
- BaseList<TItem>
Represents a base class for a strongly-typed list of items.
- BaseOrderedBlockingQueue<TSort, TValue, TCollection>
Represents a base class for an ordered blocking queue that sorts elements based on a specified key.
- BitArrayReader
Provides a reader for bit-level data from a stream.
- BitArrayWriter
Provides a writer for bit-level data to a stream.
- BlockingQueue<T>
Represents a thread-safe blocking queue implementation for storing and retrieving items of type
T.
- CachedSynchronizedDictionary<TKey, TValue>
Represents a thread-safe dictionary with cached keys, values, and key-value pairs for improved performance.
- CachedSynchronizedList<T>
Represents a thread-safe list with a cached array of its elements for improved performance.
- CachedSynchronizedOrderedDictionary<TKey, TValue>
Represents a thread-safe ordered dictionary with cached keys, values, and key-value pairs for improved performance.
- CachedSynchronizedPairSet<TKey, TValue>
Represents a thread-safe set of key-value pairs with cached keys, values, and pairs for improved performance.
- CachedSynchronizedSet<T>
Represents a thread-safe set with a cached array of its elements for improved performance.
- CircularBufferEx<TItem>
CircularBuffer{TItem} with additional features.
- CircularBuffer<T>
Circular buffer.
When writing to a full buffer: PushBack -> removes this[0] / Front() PushFront -> removes this[Size-1] / Back()
this implementation is inspired by http://www.boost.org/doc/libs/1_53_0/libs/circular_buffer/doc/circular_buffer.html because I liked their interface.
- CollectionHelper
Provides extension methods and helper utilities for working with collections.
- DynamicTuple
Represents a dynamic tuple that holds a collection of objects and provides equality comparison.
- KeyedCollection<TKey, TValue>
Represents an abstract dictionary-backed collection that manages key-value pairs with customizable behavior.
- OrderedPriorityQueue<TPriority, TValue>
Represents a priority queue that sorts elements based on a specified key.
- PairSet<TKey, TValue>
Represents a collection of key-value pairs that supports bidirectional lookup by key or value.
- PriorityQueue<TPriority, TElement>
Represents a min priority queue.
- QueueEx<T>
Extends the Queue<T> class to explicitly implement the ICollection<T> interface.
- SimpleEnumerable<T>
Represents a simple implementation of an enumerable that uses a factory function to create its enumerator.
- SimpleEnumerator<T>
Provides an abstract base class for implementing a simple enumerator with disposable functionality.
- StackEx<T>
Extends the Stack<T> class to explicitly implement the ICollection<T> interface.
- SynchronizedCollection<TItem, TCollection>
Represents a thread-safe collection that provides synchronization for its operations.
- SynchronizedDictionary<TKey, TValue>
Represents a thread-safe dictionary that provides synchronization for its operations.
- SynchronizedKeyedCollection<TKey, TValue>
Represents a thread-safe keyed collection that provides synchronization for its operations.
- SynchronizedLinkedList<T>
Represents a thread-safe linked list that provides synchronization for its operations.
- SynchronizedList<T>
Represents a thread-safe list that supports range operations and notification events.
- SynchronizedOrderedDictionary<TKey, TValue>
Provides a thread-safe dictionary with keys ordered by a specified comparer.
- SynchronizedPairSet<TKey, TValue>
Represents a thread-safe collection that maintains key/value pairs and allows bidirectional lookups.
- SynchronizedQueue<T>
Provides a thread-safe queue based on the QueueEx<T> collection.
- SynchronizedSet<T>
Represents a thread-safe set that supports optional indexing and range-based operations.
- SynchronizedStack<T>
Represents a synchronized stack of items.
Interfaces
- IBlockingQueue<T>
Represents a blocking queue interface for managing items in a thread-safe manner.
- ICollectionEx<T>
Provides an extended set of methods and events for collections of a specified type.
- IEnumerableEx
Extended version of IEnumerable that provides the total number of elements.
- IEnumerableEx<T>
Extended version of IEnumerable<T> that provides the total number of elements.
- IListEx<T>
Provides an extended set of methods and events for lists of a specified type.
- INotifyCollection<TItem>
Represents a collection that notifies about its changes.
- INotifyListEx<TItem>
Represents an extended list that notifies about its changes.
- INotifyList<TItem>
Represents a list that notifies about its changes.
- IQueue<T>
Defines a generic queue interface for enqueueing, dequeueing, and peeking at items.
- ISynchronizedCollection
Represents a collection that can be synchronized using a SyncObject.
- ISynchronizedCollection<T>
Represents a generic synchronized collection.