CircularSortedListTKey, TValue Class

[SerializableAttribute]
public class CircularSortedList<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, IList<KeyValuePair<TKey, TValue>>, IDictionary, 
	ICollection, IList, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, 
	IReadOnlyList<KeyValuePair<TKey, TValue>>

<SerializableAttribute>
Public Class CircularSortedList(Of TKey, TValue)
	Implements IDictionary(Of TKey, TValue), ICollection(Of KeyValuePair(Of TKey, TValue)), 
	IEnumerable(Of KeyValuePair(Of TKey, TValue)), IEnumerable, 
	IList(Of KeyValuePair(Of TKey, TValue)), IDictionary, 
	ICollection, IList, IReadOnlyDictionary(Of TKey, TValue), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), 
	IReadOnlyList(Of KeyValuePair(Of TKey, TValue))

[SerializableAttribute]
generic<typename TKey, typename TValue>
public ref class CircularSortedList : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, IList<KeyValuePair<TKey, TValue>>, IDictionary, 
	ICollection, IList, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, 
	IReadOnlyList<KeyValuePair<TKey, TValue>>

[<SerializableAttribute>]
type CircularSortedList<'TKey, 'TValue> = 
    class
        interface IDictionary<'TKey, 'TValue>
        interface ICollection<KeyValuePair<'TKey, 'TValue>>
        interface IEnumerable<KeyValuePair<'TKey, 'TValue>>
        interface IEnumerable
        interface IList<KeyValuePair<'TKey, 'TValue>>
        interface IDictionary
        interface ICollection
        interface IList
        interface IReadOnlyDictionary<'TKey, 'TValue>
        interface IReadOnlyCollection<KeyValuePair<'TKey, 'TValue>>
        interface IReadOnlyList<KeyValuePair<'TKey, 'TValue>>
    end

Inheritance

Object    CircularSortedListTKey, TValue

Implements

ICollectionKeyValuePairTKey, TValue, IDictionaryTKey, TValue, IEnumerableKeyValuePairTKey, TValue, IListKeyValuePairTKey, TValue, IReadOnlyCollectionKeyValuePairTKey, TValue, IReadOnlyDictionaryTKey, TValue, IReadOnlyListKeyValuePairTKey, TValue, ICollection, IDictionary, IEnumerable, IList

Type Parameters

TKey

Type of the keys stored in the sorted list.

TValue

Type of the values stored in the sorted list.

The CircularSortedListTKey, TValue generic class is an array of key/value pairs with O(log n) retrieval, where n is the number of elements in the dictionary.

Similarly to SortedListTKey, TValue, CircularSortedListTKey, TValue supports efficient indexed retrieval of keys and values through the collections returned by the Keys and Values properties. It is not necessary to regenerate the lists when the properties are accessed, because the lists are just wrappers for the internal arrays of keys and values.

CircularSortedListTKey, TValue is implemented as a pair of CircularListT of key/value pairs, sorted by the key. Each element can be retrieved as a KeyValuePairTKey, TValue object.

Key objects must be immutable as long as they are used as keys in the CircularSortedListTKey, TValue. Every key in a CircularSortedListTKey, TValue must be unique. A key cannot be , but a value can be, if the type of values in the list, TValue, is a reference type, or is a NullableT type.

CircularSortedListTKey, TValue requires a comparer implementation to sort and to perform comparisons. If comparer is not defined when CircularSortedListTKey, TValue is instantiated by one of the constructors, the comparer will be chosen automatically. Only when targeting the .NET Framework, if TKey is an enum type, then the comparer will be the EnumComparer<TEnum>.Comparer. Otherwise, the default comparer Comparer<T>.Default will be chosen. The default comparer checks whether the key type TKey implements IComparableT and uses that implementation, if available. If not, Comparer<T>.Default checks whether the key type TKey implements IComparable. If the key type TKey does not implement either interface, you can specify an IComparableT implementation in a constructor overload that accepts a comparer parameter.

The capacity of a CircularSortedListTKey, TValue is the number of elements the CircularSortedListTKey, TValue can hold. As elements are added to a CircularSortedListTKey, TValue, the capacity is automatically increased as required by reallocating the internal array. The capacity can be decreased by calling TrimExcess or by setting the Capacity property explicitly. Decreasing the capacity reallocates memory and copies all the elements in the CircularSortedListTKey, TValue.

CircularSortedListTKey, TValue implements IListT as well, so it can be indexed directly when cast to IListT or though the AsList property:

KeyValuePair<int, string> firstItem = myCircularSortedList.AsList[0];

Comparison with SortedList and SortedDictionary classes

Reference