Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

KeyedCollection<TKey, TItem>-Klasse

 

Stellt die abstrakte Basisklasse für eine Auflistung bereit, deren Schlüssel in die Werte eingebettet sind.

Namespace:   System.Collections.ObjectModel
Assembly:  mscorlib (in mscorlib.dll)


[SerializableAttribute]
[ComVisibleAttribute(false)]
public abstract class KeyedCollection<TKey, TItem> : Collection<TItem>

Typparameter

TKey

Der Typ der Schlüssel in der Auflistung.

TItem

Der Typ der Elemente in der Auflistung.

NameBeschreibung
System_CAPS_protmethodKeyedCollection<TKey, TItem>()

Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem> -Klasse, die den Standardgleichheitsvergleich verwendet.

System_CAPS_protmethodKeyedCollection<TKey, TItem>(IEqualityComparer<TKey>)

Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem> -Klasse, die den angegebenen Gleichheitsvergleich verwendet.

System_CAPS_protmethodKeyedCollection<TKey, TItem>(IEqualityComparer<TKey>, Int32)

Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem> -Klasse, die den angegebenen Gleichheitsvergleich verwendet und ein Suchwörterbuch erstellt wird, wenn der angegebene Schwellenwert überschritten wird.

NameBeschreibung
System_CAPS_pubpropertyComparer

Ruft den generischen Gleichheitsvergleich ab, der verwendet wird, um die Gleichheit von Schlüsseln in der Auflistung zu bestimmen.

System_CAPS_pubpropertyCount

Ruft die Anzahl der Elemente, die tatsächlich in der Collection<T>.(Geerbt von Collection<T>.)

System_CAPS_protpropertyDictionary

Ruft das Suchwörterbuch der der KeyedCollection<TKey, TItem>.

System_CAPS_pubpropertyItem[TKey]

Ruft das Element mit dem angegebenen Schlüssel ab.

System_CAPS_pubpropertyItem[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.(Geerbt von Collection<T>.)

System_CAPS_protpropertyItems

Ruft ein IList<T> Wrapper für die Collection<T>.(Geerbt von Collection<T>.)

NameBeschreibung
System_CAPS_pubmethodAdd(T)

Fügt am Ende der Collection<T> ein Objekt hinzu.(Geerbt von Collection<T>.)

System_CAPS_protmethodChangeItemKey(TItem, TKey)

Ändert den dem angegebenen Element im Suchwörterbuch zugeordneten Schlüssel.

System_CAPS_pubmethodClear()

Entfernt alle Elemente aus der Collection<T>.(Geerbt von Collection<T>.)

System_CAPS_protmethodClearItems()

Entfernt alle Elemente aus der KeyedCollection<TKey, TItem>.(Setzt "Collection<T>.ClearItems()" außer Kraft.)

System_CAPS_pubmethodContains(T)

Bestimmt, ob sich ein Element in Collection<T> befindet.(Geerbt von Collection<T>.)

System_CAPS_pubmethodContains(TKey)

Ermittelt, ob die Auflistung ein Element mit dem angegebenen Wert enthält.

System_CAPS_pubmethodCopyTo(T[], Int32)

Kopiert die gesamte Collection<T>-Instanz in ein kompatibles eindimensionales Array, beginnend am angegebenen Index des Zielarrays.(Geerbt von Collection<T>.)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von Object.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von Object.)

System_CAPS_pubmethodGetEnumerator()

Gibt einen Enumerator zurück, der die Collection<T> durchläuft.(Geerbt von Collection<T>.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von Object.)

System_CAPS_protmethodGetKeyForItem(TItem)

Bei Implementierung in einer abgeleiteten Klasse wird der Schlüssel aus dem angegebenen Element extrahiert.

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von Object.)

System_CAPS_pubmethodIndexOf(T)

Sucht nach dem angegebenen Objekt und gibt den nullbasierten Index des ersten Vorkommens innerhalb der gesamten Collection<T> zurück.(Geerbt von Collection<T>.)

System_CAPS_pubmethodInsert(Int32, T)

Fügt am angegebenen Index ein Element in die Collection<T> ein.(Geerbt von Collection<T>.)

System_CAPS_protmethodInsertItem(Int32, TItem)

Fügt am angegebenen Index ein Element in die KeyedCollection<TKey, TItem> ein.(Setzt "Collection<T>.InsertItem(Int32, T)" außer Kraft.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von Object.)

System_CAPS_pubmethodRemove(T)

Entfernt das erste Vorkommen eines angegebenen Objekts aus der Collection<T>.(Geerbt von Collection<T>.)

System_CAPS_pubmethodRemove(TKey)

Entfernt das Element mit dem angegebenen Schlüssel aus dem KeyedCollection<TKey, TItem>.

System_CAPS_pubmethodRemoveAt(Int32)

Entfernt das Element am angegebenen Index aus der Collection<T>.(Geerbt von Collection<T>.)

System_CAPS_protmethodRemoveItem(Int32)

Entfernt das Element am angegebenen Index aus der KeyedCollection<TKey, TItem>.(Setzt "Collection<T>.RemoveItem(Int32)" außer Kraft.)

System_CAPS_protmethodSetItem(Int32, TItem)

Ersetzt das Element im angegebenen Index durch ein angegebenes Element.(Setzt "Collection<T>.SetItem(Int32, T)" außer Kraft.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von Object.)

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

Kopiert die Elemente der ICollection in ein Array, beginnend bei einem bestimmten Array-Index.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der eine Auflistung durchläuft.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Add(Object)

Fügt der IList ein Element hinzu.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Contains(Object)

Ermittelt, ob die IList einen bestimmten Wert enthält.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.IndexOf(Object)

Bestimmt den Index eines bestimmten Elements in der IList.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Insert(Int32, Object)

Fügt ein Element in der IList am angegebenen Index.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Remove(Object)

Entfernt das erste Vorkommen eines angegebenen Objekts aus der IList.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection<T>.IsReadOnly

Ruft einen Wert ab, der angibt, ob das ICollection<T> schreibgeschützt ist.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert (threadsicher) ist.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.IsFixedSize

Ruft einen Wert ab, der angibt, ob das IList eine feste Größe aufweist.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.IsReadOnly

Ruft einen Wert ab, der angibt, ob das IList schreibgeschützt ist.(Geerbt von Collection<T>.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.(Geerbt von Collection<T>.)

NameBeschreibung
System_CAPS_pubmethodAggregate<TItem>(Func<TItem, TItem, TItem>)

Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an.(Definido por Enumerable).

System_CAPS_pubmethodAggregate<TItem, TAccumulate>(TAccumulate, Func<TAccumulate, TItem, TAccumulate>)

Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Startwert wird als erster Akkumulatorwert verwendet.(Definido por Enumerable).

System_CAPS_pubmethodAggregate<TItem, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, TItem, TAccumulate>, Func<TAccumulate, TResult>)

Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Startwert wird als erster Akkumulatorwert verwendet, und der Ergebniswert wird mit der angegebenen Funktion ausgewählt.(Definido por Enumerable).

System_CAPS_pubmethodAll<TItem>(Func<TItem, Boolean>)

Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen.(Definido por Enumerable).

System_CAPS_pubmethodAny<TItem>()

Überladen. Bestimmt, ob eine Sequenz Elemente enthält.(Definido por Enumerable).

System_CAPS_pubmethodAny<TItem>(Func<TItem, Boolean>)

Überladen. Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt.(Definido por Enumerable).

System_CAPS_pubmethodAsEnumerable<TItem>()

Gibt die Eingabe als IEnumerable<T>.(Definido por Enumerable).

System_CAPS_pubmethodAsParallel()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsParallel<TItem>()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsQueryable()

Überladen. Konvertiert ein IEnumerable zu einer IQueryable.(Definido por Queryable).

System_CAPS_pubmethodAsQueryable<TItem>()

Überladen. Konvertiert ein generisches IEnumerable<T> auf einen generischen IQueryable<T>.(Definido por Queryable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Decimal>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Double>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Int32>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Int64>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Nullable<Decimal>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Nullable<Double>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Nullable<Int32>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Nullable<Int64>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Nullable<Single>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodAverage<TItem>(Func<TItem, Single>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodCast<TResult>()

Wandelt die Elemente einer IEnumerable in den angegebenen Typ.(Definido por Enumerable).

System_CAPS_pubmethodConcat<TItem>(IEnumerable<TItem>)

Verkettet zwei Sequenzen.(Definido por Enumerable).

System_CAPS_pubmethodContains<TItem>(TItem)

Überladen. Bestimmt, ob eine Sequenz ein angegebenes Element enthält, mithilfe des Standardgleichheitsvergleichs.(Definido por Enumerable).

System_CAPS_pubmethodContains<TItem>(TItem, IEqualityComparer<TItem>)

Überladen. Bestimmt, ob eine Sequenz ein angegebenes Element enthält, mit einem angegebenen IEqualityComparer<T>.(Definido por Enumerable).

System_CAPS_pubmethodCount<TItem>()

Überladen. Gibt die Anzahl der Elemente in einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodCount<TItem>(Func<TItem, Boolean>)

Überladen. Gibt eine Zahl, die darstellt, wie viele Elemente in der angegebenen Sequenz eine Bedingung erfüllen.(Definido por Enumerable).

System_CAPS_pubmethodDefaultIfEmpty<TItem>()

Überladen. Gibt die Elemente der angegebenen Sequenz oder den Standardwert des Typparameters in einer singletonauflistung zurück, wenn die Sequenz leer ist.(Definido por Enumerable).

System_CAPS_pubmethodDefaultIfEmpty<TItem>(TItem)

Überladen. Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer singletonauflistung zurück, wenn die Sequenz leer ist.(Definido por Enumerable).

System_CAPS_pubmethodDistinct<TItem>()

Überladen. Gibt Sie mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodDistinct<TItem>(IEqualityComparer<TItem>)

Überladen. Gibt unterschiedliche Elemente aus einer Sequenz mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definido por Enumerable).

System_CAPS_pubmethodElementAt<TItem>(Int32)

Gibt das Element am angegebenen Index in einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodElementAtOrDefault<TItem>(Int32)

Gibt das Element an einem angegebenen Index in einer Sequenz oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt.(Definido por Enumerable).

System_CAPS_pubmethodExcept<TItem>(IEnumerable<TItem>)

Überladen. Erzeugt die Differenzmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten.(Definido por Enumerable).

System_CAPS_pubmethodExcept<TItem>(IEnumerable<TItem>, IEqualityComparer<TItem>)

Überladen. Erzeugt die Differenzmenge von zwei Sequenzen unter Verwendung des angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definido por Enumerable).

System_CAPS_pubmethodFirst<TItem>()

Überladen. Gibt das erste Element einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodFirst<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt.(Definido por Enumerable).

System_CAPS_pubmethodFirstOrDefault<TItem>()

Überladen. Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.(Definido por Enumerable).

System_CAPS_pubmethodFirstOrDefault<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey>(Func<TItem, TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey>(Func<TItem, TKey>, IEqualityComparer<TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Schlüssel mithilfe eines angegebenen Vergleichs.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>, IEqualityComparer<TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer Schlüsselauswahlfunktion. Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TResult>(Func<TItem, TKey>, Func<TKey, IEnumerable<TItem>, TResult>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TResult>(Func<TItem, TKey>, Func<TKey, IEnumerable<TItem>, TResult>, IEqualityComparer<TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TElement, TResult>(Func<TItem, TKey>, Func<TItem, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.(Definido por Enumerable).

System_CAPS_pubmethodGroupBy<TItem, TKey, TElement, TResult>(Func<TItem, TKey>, Func<TItem, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.(Definido por Enumerable).

System_CAPS_pubmethodGroupJoin<TItem, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TItem, TKey>, Func<TInner, TKey>, Func<TItem, IEnumerable<TInner>, TResult>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.(Definido por Enumerable).

System_CAPS_pubmethodGroupJoin<TItem, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TItem, TKey>, Func<TInner, TKey>, Func<TItem, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.(Definido por Enumerable).

System_CAPS_pubmethodIntersect<TItem>(IEnumerable<TItem>)

Überladen. Erzeugt die Schnittmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten.(Definido por Enumerable).

System_CAPS_pubmethodIntersect<TItem>(IEnumerable<TItem>, IEqualityComparer<TItem>)

Überladen. Erzeugt die Schnittmenge von zwei Sequenzen unter Verwendung des angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definido por Enumerable).

System_CAPS_pubmethodJoin<TItem, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TItem, TKey>, Func<TInner, TKey>, Func<TItem, TInner, TResult>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.(Definido por Enumerable).

System_CAPS_pubmethodJoin<TItem, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TItem, TKey>, Func<TInner, TKey>, Func<TItem, TInner, TResult>, IEqualityComparer<TKey>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.(Definido por Enumerable).

System_CAPS_pubmethodLast<TItem>()

Überladen. Gibt das letzte Element einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodLast<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt.(Definido por Enumerable).

System_CAPS_pubmethodLastOrDefault<TItem>()

Überladen. Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.(Definido por Enumerable).

System_CAPS_pubmethodLastOrDefault<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das letzte Element einer Sequenz, das eine Bedingung erfüllt, oder einen Standardwert zurück, wenn ein solches Element nicht gefunden wird.(Definido por Enumerable).

System_CAPS_pubmethodLongCount<TItem>()

Überladen. Gibt eine Int64 die die Gesamtzahl der Elemente in einer Sequenz darstellt.(Definido por Enumerable).

System_CAPS_pubmethodLongCount<TItem>(Func<TItem, Boolean>)

Überladen. Gibt ein Int64 das darstellt, wie viele Elemente in einer Sequenz eine Bedingung erfüllen.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>()

Überladen. Gibt den Maximalwert in einer generischen Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Decimal>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Decimal Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Double>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Double Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Int32>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Int32 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Int64>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Int64 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Nullable<Decimal>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Decimal Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Nullable<Double>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Double Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Nullable<Int32>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Int32 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Nullable<Int64>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Int64 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Nullable<Single>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Single Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem>(Func<TItem, Single>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Single Wert.(Definido por Enumerable).

System_CAPS_pubmethodMax<TItem, TResult>(Func<TItem, TResult>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz und gibt den höchsten Ergebniswert zurück.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>()

Überladen. Gibt den Mindestwert in einer generischen Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Decimal>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Decimal Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Double>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Double Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Int32>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Int32 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Int64>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Int64 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Nullable<Decimal>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Decimal Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Nullable<Double>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Double Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Nullable<Int32>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Int32 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Nullable<Int64>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Int64 Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Nullable<Single>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Single Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem>(Func<TItem, Single>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Single Wert.(Definido por Enumerable).

System_CAPS_pubmethodMin<TItem, TResult>(Func<TItem, TResult>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz und gibt den niedrigsten Ergebniswert zurück.(Definido por Enumerable).

System_CAPS_pubmethodOfType<TResult>()

Filtert die Elemente einer IEnumerable auf Grundlage eines angegebenen Typs.(Definido por Enumerable).

System_CAPS_pubmethodOrderBy<TItem, TKey>(Func<TItem, TKey>)

Überladen. Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel.(Definido por Enumerable).

System_CAPS_pubmethodOrderBy<TItem, TKey>(Func<TItem, TKey>, IComparer<TKey>)

Überladen. Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge mithilfe eines angegebenen Vergleichs.(Definido por Enumerable).

System_CAPS_pubmethodOrderByDescending<TItem, TKey>(Func<TItem, TKey>)

Überladen. Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel.(Definido por Enumerable).

System_CAPS_pubmethodOrderByDescending<TItem, TKey>(Func<TItem, TKey>, IComparer<TKey>)

Überladen. Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge.(Definido por Enumerable).

System_CAPS_pubmethodReverse<TItem>()

Kehrt die Reihenfolge der Elemente in einer Sequenz.(Definido por Enumerable).

System_CAPS_pubmethodSelect<TItem, TResult>(Func<TItem, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein neues Format.(Definido por Enumerable).

System_CAPS_pubmethodSelect<TItem, TResult>(Func<TItem, Int32, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein neues Formular durch den Index des Elements integriert wird.(Definido por Enumerable).

System_CAPS_pubmethodSelectMany<TItem, TResult>(Func<TItem, IEnumerable<TResult>>)

Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T> und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen.(Definido por Enumerable).

System_CAPS_pubmethodSelectMany<TItem, TResult>(Func<TItem, Int32, IEnumerable<TResult>>)

Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen. Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet.(Definido por Enumerable).

System_CAPS_pubmethodSelectMany<TItem, TCollection, TResult>(Func<TItem, IEnumerable<TCollection>>, Func<TItem, TCollection, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf.(Definido por Enumerable).

System_CAPS_pubmethodSelectMany<TItem, TCollection, TResult>(Func<TItem, Int32, IEnumerable<TCollection>>, Func<TItem, TCollection, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf. Der Index jedes Quellelements wird im projizierten Zwischenformat des jeweiligen Elements verwendet.(Definido por Enumerable).

System_CAPS_pubmethodSequenceEqual<TItem>(IEnumerable<TItem>)

Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden.(Definido por Enumerable).

System_CAPS_pubmethodSequenceEqual<TItem>(IEnumerable<TItem>, IEqualityComparer<TItem>)

Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen verglichen IEqualityComparer<T>.(Definido por Enumerable).

System_CAPS_pubmethodSingle<TItem>()

Überladen. Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist.(Definido por Enumerable).

System_CAPS_pubmethodSingle<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehrere solche Elemente vorhanden sind.(Definido por Enumerable).

System_CAPS_pubmethodSingleOrDefault<TItem>()

Überladen. Gibt das einzige Element einer Sequenz bzw. einen Standardwert zurück, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehr als ein Element in der Sequenz vorhanden ist.(Definido por Enumerable).

System_CAPS_pubmethodSingleOrDefault<TItem>(Func<TItem, Boolean>)

Überladen. Gibt das einzige Element einer Sequenz, das eine angegebene Bedingung erfüllt, oder einen Standardwert zurück, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.(Definido por Enumerable).

System_CAPS_pubmethodSkip<TItem>(Int32)

Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück.(Definido por Enumerable).

System_CAPS_pubmethodSkipWhile<TItem>(Func<TItem, Boolean>)

Überladen. Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück.(Definido por Enumerable).

System_CAPS_pubmethodSkipWhile<TItem>(Func<TItem, Int32, Boolean>)

Überladen. Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück. In der Logik der Prädikatfunktion wird der Index des Elements verwendet.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Decimal>)

Überladen. Berechnet die Summe einer Sequenz von Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Double>)

Überladen. Berechnet die Summe einer Sequenz von Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Int32>)

Überladen. Berechnet die Summe einer Sequenz von Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Int64>)

Überladen. Berechnet die Summe einer Sequenz von Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Nullable<Decimal>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Nullable<Double>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Nullable<Int32>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Nullable<Int64>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Nullable<Single>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodSum<TItem>(Func<TItem, Single>)

Überladen. Berechnet die Summe einer Sequenz von Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definido por Enumerable).

System_CAPS_pubmethodTake<TItem>(Int32)

Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück.(Definido por Enumerable).

System_CAPS_pubmethodTakeWhile<TItem>(Func<TItem, Boolean>)

Überladen. Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung true ist.(Definido por Enumerable).

System_CAPS_pubmethodTakeWhile<TItem>(Func<TItem, Int32, Boolean>)

Überladen. Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung true ist. In der Logik der Prädikatfunktion wird der Index des Elements verwendet.(Definido por Enumerable).

System_CAPS_pubmethodToArray<TItem>()

Erstellt ein Array aus einem IEnumerable<T>.(Definido por Enumerable).

System_CAPS_pubmethodToDictionary<TItem, TKey>(Func<TItem, TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodToDictionary<TItem, TKey>(Func<TItem, TKey>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs.(Definido por Enumerable).

System_CAPS_pubmethodToDictionary<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodToDictionary<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodToList<TItem>()

Erstellt ein List<T> aus einem IEnumerable<T>.(Definido por Enumerable).

System_CAPS_pubmethodToLookup<TItem, TKey>(Func<TItem, TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodToLookup<TItem, TKey>(Func<TItem, TKey>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs.(Definido por Enumerable).

System_CAPS_pubmethodToLookup<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodToLookup<TItem, TKey, TElement>(Func<TItem, TKey>, Func<TItem, TElement>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion.(Definido por Enumerable).

System_CAPS_pubmethodUnion<TItem>(IEnumerable<TItem>)

Überladen. Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs.(Definido por Enumerable).

System_CAPS_pubmethodUnion<TItem>(IEnumerable<TItem>, IEqualityComparer<TItem>)

Überladen. Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe eines angegebenen IEqualityComparer<T>.(Definido por Enumerable).

System_CAPS_pubmethodWhere<TItem>(Func<TItem, Boolean>)

Überladen. Filtert eine Sequenz von Werten basierend auf einem Prädikat.(Definido por Enumerable).

System_CAPS_pubmethodWhere<TItem>(Func<TItem, Int32, Boolean>)

Überladen. Filtert eine Sequenz von Werten basierend auf einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet.(Definido por Enumerable).

System_CAPS_pubmethodZip<TItem, TSecond, TResult>(IEnumerable<TSecond>, Func<TItem, TSecond, TResult>)

Wendet eine angegebene Funktion auf die entsprechenden Elemente zweier Sequenzen, die eine Sequenz der Ergebnisse.(Definido por Enumerable).

Die KeyedCollection<TKey, TItem> -Klasse stellt sowohl O(1) Abruf und schlüsselgebundenen Abruf, der sich O(1) annähert. Es ist ein abstrakter Typ, oder genauer gesagt um eine unendliche Menge von abstrakten Typen, da jeder der konstruierten generischen Typen eine abstrakte Basisklasse darstellt. Mit KeyedCollection<TKey, TItem>, leiten Sie den Auflistungstyp vom entsprechenden konstruierten Typ.

Die KeyedCollection<TKey, TItem> -Klasse ist eine Mischung aus einer Sammlung auf Grundlage der IList<T> generische Schnittstelle und eine Sammlung auf Grundlage der IDictionary<TKey, TValue> generische Schnittstelle. Wie Auflistungen anhand der IList<T> generische Schnittstelle KeyedCollection<TKey, TItem> ist eine indizierte Liste von Elementen. Wie Auflistungen anhand der IDictionary<TKey, TValue> generische Schnittstelle KeyedCollection<TKey, TItem> verfügt über einen zugeordneten Schlüssel für jedes Element.

Im Gegensatz zu Wörterbüchern ist ein Element der KeyedCollection<TKey, TItem> ist ein Schlüssel/Wert-Paar; stattdessen das gesamte Element ist der Wert und der Schlüssel ist im Wert eingebettet. Angenommen, ein Element einer Auflistung abgeleitet KeyedCollection<String,String> (KeyedCollection(Of String, String) in Visual Basic) ist möglicherweise "John Doe Jr." Dabei ist der Wert "John Doe Jr." und der Schlüssel "Doe"; oder eine Auflistung von Mitarbeiterdatensätzen, die Ganzzahlschlüssel konnte von KeyedCollection<int,Employee>. Die abstrakte GetKeyForItem -Methode den Schlüssel aus dem Element extrahiert.

In der Standardeinstellung die KeyedCollection<TKey, TItem> umfasst ein Suchwörterbuch, das Sie erhalten können, mit der Dictionary Eigenschaft. Wenn ein Element hinzugefügt wird, um die KeyedCollection<TKey, TItem>, der Schlüssel des Elements einmal extrahiert und im Suchwörterbuch für schnellere Suchvorgänge gespeichert ist. Dieses Verhalten wird überschrieben, indem Wörterbuch Erstellung Schwellenwert festlegen, bei der Erstellung der KeyedCollection<TKey, TItem>. Das Suchwörterbuch wird erstmalig erstellt, die Anzahl der Elemente diesen Schwellenwert überschreitet. Wenn Sie – 1 als Schwellenwert angeben, wird das Suchwörterbuch nie erstellt.

System_CAPS_noteHinweis

Wenn das interne Suchwörterbuch verwendet wird, enthält es Verweise auf alle Elemente in der Auflistung, wenn TItem ein Verweistyp ist, oder aller Elemente in der Auflistung kopiert werden, wenn TItem ein Werttyp ist. Daher verwenden das Suchwörterbuch geeignet sein wenn TItem ein Werttyp ist.

Sie können ein Element über seinen Index oder Schlüssel zugreifen, mit der ItemEigenschaft. Sie können Elemente ohne Schlüssel hinzufügen, aber diese Elemente können anschließend nur über den Index zugegriffen werden.

Dieser Abschnitt enthält zwei Codebeispiele. Das erste Beispiel zeigt den mindestens erforderlichen Code zu Ableitung KeyedCollection<TKey, TItem>, und viele der geerbten Methoden veranschaulicht. Im zweiten Beispiel wird veranschaulicht, wie die geschützten Methoden überschreiben KeyedCollection<TKey, TItem> um benutzerdefiniertes Verhalten bereitzustellen.

Beispiel 1

Dieses Codebeispiel zeigt den minimalen Code erforderlich, leiten Sie eine Auflistungsklasse aus KeyedCollection<TKey, TItem>: Überschreiben der GetKeyForItem -Methode und über einen öffentlichen Konstruktor delegiert, die an einen Basisklassenkonstruktor. Im Codebeispiel wird außerdem veranschaulicht viele der Eigenschaften und Methoden geerbt von KeyedCollection<TKey, TItem> und Collection<T> Klassen.

Die SimpleOrder -Klasse ist eine sehr einfache Bestellliste, enthält OrderItem Objekte, von denen jeder eine Position in der Reihenfolge darstellt. Der Schlüssel des OrderItem unveränderlich ist, ist ein wichtiger Aspekt für abgeleitete Klassen KeyedCollection<TKey, TItem>. Ein Codebeispiel, das veränderbare Schlüssel verwendet, finden Sie unter ChangeItemKey.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

// This class represents a very simple keyed list of OrderItems,
// inheriting most of its behavior from the KeyedCollection and 
// Collection classes. The immediate base class is the constructed
// type KeyedCollection<int, OrderItem>. When you inherit
// from KeyedCollection, the second generic type argument is the 
// type that you want to store in the collection -- in this case
// OrderItem. The first type argument is the type that you want
// to use as a key. Its values must be calculated from OrderItem; 
// in this case it is the int field PartNumber, so SimpleOrder
// inherits KeyedCollection<int, OrderItem>.
//
public class SimpleOrder : KeyedCollection<int, OrderItem>
{

    // This is the only method that absolutely must be overridden,
    // because without it the KeyedCollection cannot extract the
    // keys from the items. The input parameter type is the 
    // second generic type argument, in this case OrderItem, and 
    // the return value type is the first generic type argument,
    // in this case int.
    //
    protected override int GetKeyForItem(OrderItem item)
    {
        // In this example, the key is the part number.
        return item.PartNumber;
    }
}

public class Demo
{    
    public static void Main()
    {
        SimpleOrder weekly = new SimpleOrder();

        // The Add method, inherited from Collection, takes OrderItem.
        //
        weekly.Add(new OrderItem(110072674, "Widget", 400, 45.17));
        weekly.Add(new OrderItem(110072675, "Sprocket", 27, 5.3));
        weekly.Add(new OrderItem(101030411, "Motor", 10, 237.5));
        weekly.Add(new OrderItem(110072684, "Gear", 175, 5.17));

        Display(weekly);

        // The Contains method of KeyedCollection takes the key, 
        // type, in this case int.
        //
        Console.WriteLine("\nContains(101030411): {0}", 
            weekly.Contains(101030411));

        // The default Item property of KeyedCollection takes a key.
        //
        Console.WriteLine("\nweekly[101030411].Description: {0}", 
            weekly[101030411].Description);

        // The Remove method of KeyedCollection takes a key.
        //
        Console.WriteLine("\nRemove(101030411)");
        weekly.Remove(101030411);
        Display(weekly);

        // The Insert method, inherited from Collection, takes an 
        // index and an OrderItem.
        //
        Console.WriteLine("\nInsert(2, New OrderItem(...))");
        weekly.Insert(2, new OrderItem(111033401, "Nut", 10, .5));
        Display(weekly);

        // The default Item property is overloaded. One overload comes
        // from KeyedCollection<int, OrderItem>; that overload
        // is read-only, and takes Integer because it retrieves by key. 
        // The other overload comes from Collection<OrderItem>, the 
        // base class of KeyedCollection<int, OrderItem>; it 
        // retrieves by index, so it also takes an Integer. The compiler
        // uses the most-derived overload, from KeyedCollection, so the
        // only way to access SimpleOrder by index is to cast it to
        // Collection<OrderItem>. Otherwise the index is interpreted
        // as a key, and KeyNotFoundException is thrown.
        //
        Collection<OrderItem> coweekly = weekly;
        Console.WriteLine("\ncoweekly[2].Description: {0}", 
            coweekly[2].Description);

        Console.WriteLine("\ncoweekly[2] = new OrderItem(...)");
        coweekly[2] = new OrderItem(127700026, "Crank", 27, 5.98);

        OrderItem temp = coweekly[2];

        // The IndexOf method inherited from Collection<OrderItem> 
        // takes an OrderItem instead of a key
        // 
        Console.WriteLine("\nIndexOf(temp): {0}", weekly.IndexOf(temp));

        // The inherited Remove method also takes an OrderItem.
        //
        Console.WriteLine("\nRemove(temp)");
        weekly.Remove(temp);
        Display(weekly);

        Console.WriteLine("\nRemoveAt(0)");
        weekly.RemoveAt(0);
        Display(weekly);

    }

    private static void Display(SimpleOrder order)
    {
        Console.WriteLine();
        foreach( OrderItem item in order )
        {
            Console.WriteLine(item);
        }
    }
}

// This class represents a simple line item in an order. All the 
// values are immutable except quantity.
// 
public class OrderItem
{
    public readonly int PartNumber;
    public readonly string Description;
    public readonly double UnitPrice;

    private int _quantity = 0;

    public OrderItem(int partNumber, string description, 
        int quantity, double unitPrice)
    {
        this.PartNumber = partNumber;
        this.Description = description;
        this.Quantity = quantity;
        this.UnitPrice = unitPrice;
    } 

    public int Quantity    
    {
        get { return _quantity; }
        set
        {
            if (value<0)
                throw new ArgumentException("Quantity cannot be negative.");

            _quantity = value;
        }
    }

    public override string ToString()
    {
        return String.Format(
            "{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}", 
            PartNumber, _quantity, Description, UnitPrice, 
            UnitPrice * _quantity);
    }
}

/* This code example produces the following output:

110072674    400 Widget       at    45.17 =  18,068.00
110072675     27 Sprocket     at     5.30 =     143.10
101030411     10 Motor        at   237.50 =   2,375.00
110072684    175 Gear         at     5.17 =     904.75

Contains(101030411): True

weekly[101030411].Description: Motor

Remove(101030411)

110072674    400 Widget       at    45.17 =  18,068.00
110072675     27 Sprocket     at     5.30 =     143.10
110072684    175 Gear         at     5.17 =     904.75

Insert(2, New OrderItem(...))

110072674    400 Widget       at    45.17 =  18,068.00
110072675     27 Sprocket     at     5.30 =     143.10
111033401     10 Nut          at      .50 =       5.00
110072684    175 Gear         at     5.17 =     904.75

coweekly[2].Description: Nut

coweekly[2] = new OrderItem(...)

IndexOf(temp): 2

Remove(temp)

110072674    400 Widget       at    45.17 =  18,068.00
110072675     27 Sprocket     at     5.30 =     143.10
110072684    175 Gear         at     5.17 =     904.75

RemoveAt(0)

110072675     27 Sprocket     at     5.30 =     143.10
110072684    175 Gear         at     5.17 =     904.75
 */

Beispiel 2

Im folgenden Codebeispiel wird veranschaulicht, wie die geschützte überschreiben InsertItem, RemoveItem, ClearItems, und SetItem Methoden, um benutzerdefiniertes Verhalten für die Add, Remove, und Clear Methoden und zum Festlegen der standardmäßigen Item -Eigenschaft (Indexer in c#). In diesem Beispiel bereitgestellte benutzerdefinierte Verhalten wird ein Benachrichtigungsereignis mit dem Namen Changed, das am Ende jeder der überschriebenen Methoden ausgelöst wird.

Der Code erstellt die SimpleOrder -Klasse, abgeleitet von KeyedCollection<TKey, TItem> und ein einfaches Bestellformular darstellt. Das Bestellformular enthält OrderItem Objekte, die bestellte Artikel darstellen. Das Codebeispiel erstellt außerdem eine SimpleOrderChangedEventArgs Klasse, um die Ereignisinformationen und eine Enumeration, mit der Art der Änderung enthalten.

Im Codebeispiel wird das benutzerdefinierte Verhalten veranschaulicht, durch Aufrufen der Eigenschaften und Methoden der abgeleiteten Klasse in der Main Methode der Demo Klasse.

In diesem Codebeispiel werden Objekte mit unveränderlichen Schlüsseln verwendet. Ein Codebeispiel, das veränderbare Schlüssel verwendet, finden Sie unter ChangeItemKey.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

// This class derives from KeyedCollection and shows how to override
// the protected ClearItems, InsertItem, RemoveItem, and SetItem 
// methods in order to change the behavior of the default Item 
// property and the Add, Clear, Insert, and Remove methods. The
// class implements a Changed event, which is raised by all the
// protected methods.
//
// SimpleOrder is a collection of OrderItem objects, and its key
// is the PartNumber field of OrderItem. PartNumber is an Integer,
// so SimpleOrder inherits KeyedCollection<int, OrderItem>.
// (Note that the key of OrderItem cannot be changed; if it could 
// be changed, SimpleOrder would have to override ChangeItemKey.)
//
public class SimpleOrder : KeyedCollection<int, OrderItem>
{
    public event EventHandler<SimpleOrderChangedEventArgs> Changed;

    // This parameterless constructor calls the base class constructor
    // that specifies a dictionary threshold of 0, so that the internal
    // dictionary is created as soon as an item is added to the 
    // collection.
    //
    public SimpleOrder() : base(null, 0) {}

    // This is the only method that absolutely must be overridden,
    // because without it the KeyedCollection cannot extract the
    // keys from the items. 
    //
    protected override int GetKeyForItem(OrderItem item)
    {
        // In this example, the key is the part number.
        return item.PartNumber;
    }

    protected override void InsertItem(int index, OrderItem newItem)
    {
        base.InsertItem(index, newItem);

        EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new SimpleOrderChangedEventArgs(
                ChangeType.Added, newItem, null));
        }
    }

    protected override void SetItem(int index, OrderItem newItem)
    {
        OrderItem replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new SimpleOrderChangedEventArgs(
                ChangeType.Replaced, replaced, newItem));
        }
    }

    protected override void RemoveItem(int index)
    {
        OrderItem removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new SimpleOrderChangedEventArgs(
                ChangeType.Removed, removedItem, null));
        }
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<SimpleOrderChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new SimpleOrderChangedEventArgs(
                ChangeType.Cleared, null, null));
        }
    }
}

// Event argument for the Changed event.
//
public class SimpleOrderChangedEventArgs : EventArgs
{
    private OrderItem _changedItem;
    private ChangeType _changeType;
    private OrderItem _replacedWith;

    public OrderItem ChangedItem { get { return _changedItem; }}
    public ChangeType ChangeType { get { return _changeType; }}
    public OrderItem ReplacedWith { get { return _replacedWith; }}

    public SimpleOrderChangedEventArgs(ChangeType change, 
        OrderItem item, OrderItem replacement)
    {
        _changeType = change;
        _changedItem = item;
        _replacedWith = replacement;
    }
}

public enum ChangeType
{
    Added, 
    Removed, 
    Replaced, 
    Cleared
};

public class Demo
{    
    public static void Main()
    {
        SimpleOrder weekly = new SimpleOrder();
        weekly.Changed += new 
            EventHandler<SimpleOrderChangedEventArgs>(ChangedHandler);

        // The Add method, inherited from Collection, takes OrderItem.
        //
        weekly.Add(new OrderItem(110072674, "Widget", 400, 45.17));
        weekly.Add(new OrderItem(110072675, "Sprocket", 27, 5.3));
        weekly.Add(new OrderItem(101030411, "Motor", 10, 237.5));
        weekly.Add(new OrderItem(110072684, "Gear", 175, 5.17));

        Display(weekly);

        // The Contains method of KeyedCollection takes TKey.
        //
        Console.WriteLine("\nContains(101030411): {0}", 
            weekly.Contains(101030411));

        // The default Item property of KeyedCollection takes the key
        // type, Integer. The property is read-only.
        //
        Console.WriteLine("\nweekly[101030411].Description: {0}", 
            weekly[101030411].Description);

        // The Remove method of KeyedCollection takes a key.
        //
        Console.WriteLine("\nRemove(101030411)");
        weekly.Remove(101030411);

        // The Insert method, inherited from Collection, takes an 
        // index and an OrderItem.
        //
        Console.WriteLine("\nInsert(2, new OrderItem(...))");
        weekly.Insert(2, new OrderItem(111033401, "Nut", 10, .5));

        // The default Item property is overloaded. One overload comes
        // from KeyedCollection<int, OrderItem>; that overload
        // is read-only, and takes Integer because it retrieves by key. 
        // The other overload comes from Collection<OrderItem>, the 
        // base class of KeyedCollection<int, OrderItem>; it 
        // retrieves by index, so it also takes an Integer. The compiler
        // uses the most-derived overload, from KeyedCollection, so the
        // only way to access SimpleOrder by index is to cast it to
        // Collection<OrderItem>. Otherwise the index is interpreted
        // as a key, and KeyNotFoundException is thrown.
        //
        Collection<OrderItem> coweekly = weekly;
        Console.WriteLine("\ncoweekly[2].Description: {0}", 
            coweekly[2].Description);

        Console.WriteLine("\ncoweekly[2] = new OrderItem(...)");
        coweekly[2] = new OrderItem(127700026, "Crank", 27, 5.98);

        OrderItem temp = coweekly[2];

        // The IndexOf method, inherited from Collection<OrderItem>, 
        // takes an OrderItem instead of a key.
        // 
        Console.WriteLine("\nIndexOf(temp): {0}", weekly.IndexOf(temp));

        // The inherited Remove method also takes an OrderItem.
        //
        Console.WriteLine("\nRemove(temp)");
        weekly.Remove(temp);

        Console.WriteLine("\nRemoveAt(0)");
        weekly.RemoveAt(0);

        // Increase the quantity for a line item.
        Console.WriteLine("\ncoweekly(1) = New OrderItem(...)");
        coweekly[1] = new OrderItem(coweekly[1].PartNumber, 
            coweekly[1].Description, coweekly[1].Quantity + 1000, 
            coweekly[1].UnitPrice);

        Display(weekly);

        Console.WriteLine();
        weekly.Clear();
    }

    private static void Display(SimpleOrder order)
    {
        Console.WriteLine();
        foreach( OrderItem item in order )
        {
            Console.WriteLine(item);
        }
    }

    private static void ChangedHandler(object source, 
        SimpleOrderChangedEventArgs e)
    {

        OrderItem item = e.ChangedItem;

        if (e.ChangeType==ChangeType.Replaced)
        {
            OrderItem replacement = e.ReplacedWith;

            Console.WriteLine("{0} (quantity {1}) was replaced " +
                "by {2}, (quantity {3}).", item.Description, 
                item.Quantity, replacement.Description, 
                replacement.Quantity);
        }
        else if(e.ChangeType == ChangeType.Cleared)
        {
            Console.WriteLine("The order list was cleared.");
        }
        else
        {
            Console.WriteLine("{0} (quantity {1}) was {2}.", 
                item.Description, item.Quantity, e.ChangeType);
        }
    }
}

// This class represents a simple line item in an order. All the 
// values are immutable except quantity.
// 
public class OrderItem
{
    private int _partNumber;
    private string _description;
    private double _unitPrice;
    private int _quantity;

    public int PartNumber { get { return _partNumber; }}
    public string Description { get { return _description; }}
    public double UnitPrice { get { return _unitPrice; }}
    public int Quantity { get { return _quantity; }}

    public OrderItem(int partNumber, string description, int quantity, 
        double unitPrice)
    {
        _partNumber = partNumber;
        _description = description;
        _quantity = quantity;
        _unitPrice = unitPrice;
    }

    public override string ToString()
    {
        return String.Format(
            "{0,9} {1,6} {2,-12} at {3,8:#,###.00} = {4,10:###,###.00}", 
            PartNumber, _quantity, Description, UnitPrice, 
            UnitPrice * _quantity);
    }
}

/* This code example produces the following output:

Widget (quantity 400) was Added.
Sprocket (quantity 27) was Added.
Motor (quantity 10) was Added.
Gear (quantity 175) was Added.

110072674    400 Widget       at    45.17 =  18,068.00
110072675     27 Sprocket     at     5.30 =     143.10
101030411     10 Motor        at   237.50 =   2,375.00
110072684    175 Gear         at     5.17 =     904.75

Contains(101030411): True

weekly[101030411].Description: Motor

Remove(101030411)
Motor (quantity 10) was Removed.

Insert(2, new OrderItem(...))
Nut (quantity 10) was Added.

coweekly[2].Description: Nut

coweekly[2] = new OrderItem(...)
Nut (quantity 10) was replaced by Crank, (quantity 27).

IndexOf(temp): 2

Remove(temp)
Crank (quantity 27) was Removed.

RemoveAt(0)
Widget (quantity 400) was Removed.

coweekly(1) = New OrderItem(...)
Gear (quantity 175) was replaced by Gear, (quantity 1175).

110072675     27 Sprocket     at     5.30 =     143.10
110072684   1175 Gear         at     5.17 =   6,074.75

The order list was cleared.
 */

Universal Windows Platform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portable Class Library
Unterstützt in: portable .NET platforms
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Öffentliche statische (in Visual Basic freigegebene) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Zurück zum Anfang
Anzeigen: