Overloaded. Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.(Defined by Enumerable.)

Overloaded. Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.(Defined by Enumerable.)

Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer.(Defined by Enumerable.)

Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.(Defined by Enumerable.)

Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.(Defined by Enumerable.)

Overloaded. Projects each element of a sequence to an IEnumerable<'T>, and flattens the resulting sequences into one sequence. The index of each source element is used in the projected form of that element.(Defined by Enumerable.)

Overloaded. Projects each element of a sequence to an IEnumerable<'T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.(Defined by Enumerable.)

Overloaded. Projects each element of a sequence to an IEnumerable<'T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element.(Defined by Enumerable.)

Overloaded. Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.(Defined by Enumerable.)

Overloaded. Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.(Defined by Enumerable.)

Overloaded. Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.(Defined by Enumerable.)

The KeyedCollection<'TKey, 'TItem> class provides both O(1) indexed retrieval and keyed retrieval that approaches O(1). It is an abstract type, or more accurately an infinite set of abstract types, because each of its constructed generic types is an abstract base class. To use KeyedCollection<'TKey, 'TItem>, derive your collection type from the appropriate constructed type.

The KeyedCollection<'TKey, 'TItem> class is a hybrid between a collection based on the IList<'T> generic interface and a collection based on the IDictionary<'TKey, 'TValue> generic interface. Like collections based on the IList<'T> generic interface, KeyedCollection<'TKey, 'TItem> is an indexed list of items. Like collections based on the IDictionary<'TKey, 'TValue> generic interface, KeyedCollection<'TKey, 'TItem> has a key associated with each element.

Unlike dictionaries, an element of KeyedCollection<'TKey, 'TItem> is not a key/value pair; instead, the entire element is the value and the key is embedded within the value. For example, an element of a collection derived from KeyedCollection<String,String> (KeyedCollection(Of String, String) in Visual Basic) might be "John Doe Jr." where the value is "John Doe Jr." and the key is "Doe"; or a collection of employee records containing integer keys could be derived from KeyedCollection<int,Employee>. The abstract GetKeyForItem method extracts the key from the element.

By default, the KeyedCollection<'TKey, 'TItem> includes a lookup dictionary that you can obtain with the Dictionary property. When an item is added to the KeyedCollection<'TKey, 'TItem>, the item's key is extracted once and saved in the lookup dictionary for faster searches. This behavior is overridden by specifying a dictionary creation threshold when you create the KeyedCollection<'TKey, 'TItem>. The lookup dictionary is created the first time the number of elements exceeds that threshold. If you specify –1 as the threshold, the lookup dictionary is never created.

Note

When the internal lookup dictionary is used, it contains references to all the items in the collection if TItem is a reference type, or copies of all the items in the collection if TItem is a value type. Thus, using the lookup dictionary may not be appropriate if TItem is a value type.

You can access an item by its index or key by using the Itemproperty. You can add items without a key, but these items can subsequently be accessed only by index.

This section contains two code examples. The first example shows the minimum code required to derive from KeyedCollection<'TKey, 'TItem>, and demonstrates many of the inherited methods. The second example shows how to override the protected methods of KeyedCollection<'TKey, 'TItem> to provide custom behavior.

Example 1

This code example shows the minimum code necessary to derive a collection class from KeyedCollection<'TKey, 'TItem>: overriding the GetKeyForItem method and providing a public constructor that delegates to a base class constructor. The code example also demonstrates many of the properties and methods inherited from KeyedCollection<'TKey, 'TItem> and Collection<'T> classes.

The SimpleOrder class is a very simple requisition list that contains OrderItem objects, each of which represents a line item in the order. The key of OrderItem is immutable, an important consideration for classes that derive from KeyedCollection<'TKey, 'TItem>. For a code example that uses mutable keys, see ChangeItemKey.

No code example is currently available or this language may not be supported.

Example 2

The following code example shows how to override the protected InsertItem, RemoveItem, ClearItems, and SetItem methods, to provide custom behavior for the Add, Remove, and Clear methods, and for setting the default Item property (the indexer in C#). The custom behavior provided in this example is a notification event named Changed, which is raised at the end of each of the overridden methods.

The code example creates the SimpleOrder class, which derives from KeyedCollection<'TKey, 'TItem> and represents a simple order form. The order form contains OrderItem objects representing items ordered. The code example also creates a SimpleOrderChangedEventArgs class to contain the event information, and an enumeration to identify the type of change.

The code example demonstrates the custom behavior by calling the properties and methods of the derived class, in the Main method of the Demo class.

This code example uses objects with immutable keys. For a code example that uses mutable keys, see ChangeItemKey.