(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

KeyedCollection<TKey, TItem>-Klasse

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

System.Object
  System.Collections.ObjectModel.Collection<TItem>
    System.Collections.ObjectModel.KeyedCollection<TKey, TItem>
      Weitere Informationen...

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.

Der KeyedCollection<TKey, TItem>-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsKeyedCollection<TKey, TItem>()Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem>-Klasse, die einen Standardgleichheitsvergleich verwendet.
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsKeyedCollection<TKey, TItem>(IEqualityComparer<TKey>)Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem>-Klasse, die den angegebenen Gleichheitsvergleich verwendet.
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsKeyedCollection<TKey, TItem>(IEqualityComparer<TKey>, Int32)Initialisiert eine neue Instanz der KeyedCollection<TKey, TItem>-Klasse, bei der der angegebene Gleichheitsvergleich verwendet und beim Überschreiten des angegebenen Schwellenwerts ein Suchwörterbuch erstellt wird.
Zum Seitenanfang
  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsComparerRuft den generischen Gleichheitsvergleich ab, der verwendet wird, um die Gleichheit von Schlüsseln in der Auflistung zu bestimmen.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCountRuft die Anzahl der Elemente ab, die tatsächlich in der Collection<T> enthalten sind. (Von Collection<T> geerbt.)
Geschützte EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDictionaryRuft das Suchwörterbuch der KeyedCollection<TKey, TItem> ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsItem[TKey]Ruft das Element mit dem angegebenen Schlüssel ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsItem[Int32]Ruft das Element am angegebenen Index ab oder legt dieses fest. (Von Collection<T> geerbt.)
Geschützte EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsItemsRuft den Collection<T>-Wrapper ab, der IList<T> einbindet. (Von Collection<T> geerbt.)
Zum Seitenanfang
  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAddFügt am Ende der Collection<T> ein Objekt hinzu. (Von Collection<T> geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsChangeItemKeyÄndert den dem angegebenen Element im Suchwörterbuch zugeordneten Schlüssel.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsClearEntfernt alle Elemente aus der Collection<T>. (Von Collection<T> geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsClearItemsEntfernt alle Elemente aus der KeyedCollection<TKey, TItem>. (Überschreibt Collection<T>.ClearItems().)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsContains(T)Bestimmt, ob sich ein Element in Collection<T> befindet. (Von Collection<T> geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsContains(TKey)Bestimmt, ob die Auflistung ein Element mit dem angegebenen Schlüssel enthält.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCopyToKopiert die gesamte Collection<T> in ein kompatibles eindimensionales Array, beginnend am angegebenen Index des Zielarrays. (Von Collection<T> geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetEnumeratorGibt einen Enumerator zurück, der die Collection<T> durchläuft. (Von Collection<T> geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetKeyForItemBei Implementierung in einer abgeleiteten Klasse wird der Schlüssel aus dem angegebenen Element extrahiert.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOfSucht nach dem angegebenen Objekt und gibt den nullbasierten Index des ersten Vorkommens innerhalb der gesamten Collection<T> zurück. (Von Collection<T> geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInsertFügt am angegebenen Index ein Element in die Collection<T> ein. (Von Collection<T> geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInsertItemFügt am angegebenen Index ein Element in die KeyedCollection<TKey, TItem> ein. (Überschreibt Collection<T>.InsertItem(Int32, T).)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemove(T)Entfernt das erste Vorkommen eines bestimmten Objekts aus der Collection<T>. (Von Collection<T> geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemove(TKey)Entfernt das Element mit dem angegebenen Schlüssel aus der KeyedCollection<TKey, TItem>.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemoveAtEntfernt das Element am angegebenen Index aus der Collection<T>. (Von Collection<T> geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemoveItemEntfernt das Element am angegebenen Index aus der KeyedCollection<TKey, TItem>. (Überschreibt Collection<T>.RemoveItem(Int32).)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSetItemErsetzt das Element an der angegebenen Position durch ein angegebenes Element. (Überschreibt Collection<T>.SetItem(Int32, T).)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang
  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsICollection.CopyToKopiert die Elemente der ICollection in ein Array, beginnend bei einem bestimmten Array-Index. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsICollection<T>.IsReadOnlyRuft einen Wert ab, der angibt, ob das ICollection<T> schreibgeschützt ist. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsICollection.IsSynchronizedRuft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert (threadsicher) ist. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsICollection.SyncRootRuft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIEnumerable.GetEnumeratorGibt einen Enumerator zurück, der eine Auflistung durchläuft. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.AddFügt der IList ein Element hinzu. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.ContainsBestimmt, ob die IList einen bestimmten Wert enthält. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.IndexOfBestimmt den Index eines bestimmten Elements in der IList. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.InsertFügt ein Element am angegebenen Index in die IList ein. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.IsFixedSizeRuft einen Wert ab, der angibt, ob IList eine feste Größe hat. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.IsReadOnlyRuft einen Wert ab, der angibt, ob die IList schreibgeschützt ist. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.ItemRuft das Element am angegebenen Index ab oder legt dieses fest. (Von Collection<T> geerbt.)
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIList.RemoveEntfernt das erste Vorkommen eines bestimmten Objekts aus IList. (Von Collection<T> geerbt.)
Zum Seitenanfang

Die KeyedCollection<TKey, TItem>-Klasse stellt sowohl einen indexgebundenen Abruf mit O(1) als auch einen schlüsselgebundenen Abruf bereit, der sich O(1) annähert. Es handelt sich hierbei um einen abstrakten Typ, genauer gesagt um eine unendliche Menge von abstrakten Typen, da jeder der konstruierten generischen Typen eine abstrakte Basisklasse darstellt. Wenn Sie KeyedCollection<TKey, TItem> verwenden möchten, leiten Sie den Auflistungstyp vom entsprechenden konstruierten Typ ab.

Die KeyedCollection<TKey, TItem>-Klasse stellt eine Mischung aus einer auf der generischen IList<T>-Schnittstelle basierenden Auflistung und einer auf der generischen IDictionary<TKey, TValue>-Schnittstelle basierenden Auflistung dar. Bei KeyedCollection<TKey, TItem> handelt es sich ebenso wie bei auf der generischen IList<T>-Schnittstelle basierenden Auflistungen um eine indizierte Liste von Elementen. Ebenso wie die auf der generischen IDictionary<TKey, TValue>-Schnittstelle basierenden Auflistungen verfügt auch jedes Element von KeyedCollection<TKey, TItem> über einen zugeordneten Schlüssel.

Im Gegensatz zu Wörterbüchern ist ein Element von KeyedCollection<TKey, TItem> jedoch kein Schlüssel-Wert-Paar. Stattdessen stellt der Wert das gesamte Element dar, und der Schlüssel ist im Wert eingebettet. So könnte z. B. ein Element aus einer von KeyedCollection<String,String> (KeyedCollection(Of String, String) in Visual Basic) abgeleiteten Auflistung "John Doe Jr." lauten, wobei der Wert "John Doe Jr." und der Schlüssel "Doe" wäre. Es könnte auch eine Auflistung von Mitarbeiterdatensätzen, die Ganzzahlschlüssel enthalten, von KeyedCollection<int,Employee> abgeleitet sein. Mit der abstrakten GetKeyForItem-Methode wird der Schlüssel aus dem Element extrahiert.

Standardmäßig schließt der KeyedCollection<TKey, TItem> ein Suchwörterbuch ein, das Sie mit der Dictionary-Eigenschaft erhalten können. Wenn der KeyedCollection<TKey, TItem> ein Element hinzugefügt wird, wird der Schlüssel des Elements zur Beschleunigung von Suchvorgängen einmal extrahiert und im Suchwörterbuch gespeichert. Dieses Verhalten wird durch Angeben eines Schwellenwerts für die Wörterbucherstellung überschrieben, wenn Sie die KeyedCollection<TKey, TItem> erstellen. Das Suchwörterbuch wird erstellt, wenn die Anzahl der Elemente erstmalig diesen Schwellenwert übersteigt. Wenn Sie als Schwellenwert -1 angeben, wird das Suchwörterbuch nie erstellt.

HinweisHinweis

Sofern das interne Suchwörterbuch verwendet wird, enthält es Verweise auf alle Elemente in der Auflistung, wenn TItem ein Referenztyp ist, oder Kopien aller Elemente in der Auflistung, wenn TItem ein Werttyp ist. Die Verwendung des Suchwörterbuchs ist daher möglicherweise nicht geeignet, wenn TItem ein Werttyp ist.

Sie greifen auf ein Element über seinen Index oder Schlüssel zu, indem Sie die Item-Eigenschaft verwenden. Sie können Elemente ohne Schlüssel hinzufügen, aber auf diese Elemente kann anschließend nur über den Index zugegriffen werden.

Dieser Abschnitt enthält zwei Codebeispiele. Im ersten Beispiel wird der minimale Code gezeigt, der für das Ableiten von KeyedCollection<TKey, TItem> erforderlich ist, und es werden viele der geerbten Methoden veranschaulicht. Im zweiten Beispiel wird gezeigt, wie die geschützten Methoden von KeyedCollection<TKey, TItem> überschrieben werden, um benutzerdefiniertes Verhalten bereitzustellen.

Beispiel 1

In diesem Codebeispiel wird der minimale Code gezeigt, der erforderlich ist, um eine Auflistungsklasse von KeyedCollection<TKey, TItem> abzuleiten: hierfür muss die GetKeyForItem-Methode überschrieben und ein öffentlicher Konstruktor bereitgestellt werden, der an einen Basisklassenkonstruktor delegiert. Im Codebeispiel werden zudem viele der Eigenschaften und Methoden veranschaulicht, die von der KeyedCollection<TKey, TItem>-Klasse und von der Collection<T>-Klasse geerbt sind.

Bei der SimpleOrder-Klasse handelt es sich um eine sehr einfache Bestellliste, die OrderItem-Objekte enthält, die jeweils einen Posten in der Bestellung darstellen. Der Schlüssel von OrderItem ist unveränderlich, eine wichtiger Aspekt bei Klassen, die von KeyedCollection<TKey, TItem> abgeleitet sind. Ein Codebeispiel, in dem veränderbare Schlüssel verwendet werden, 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>
{
    // The parameterless constructor of the base class creates a 
    // KeyedCollection with an internal dictionary. For this code 
    // example, no other constructors are exposed.
    //
    public SimpleOrder() : base() {}

    // 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 gezeigt, wie die geschützten Methoden InsertItem, RemoveItem, ClearItems und SetItem überschrieben werden können, um benutzerdefiniertes Verhalten für die Methoden Add, Remove und Clear bereitzustellen und die Item-Standardeigenschaft (Indexer in C#) festzulegen. Bei dem in diesem Beispiel bereitgestellten benutzerdefinierten Verhalten handelt es sich um ein Benachrichtigungsereignis mit dem Namen Changed, das am Ende jeder der überschriebenen Methoden ausgelöst wird.

Im Codebeispiel wird die SimpleOrder-Klasse erstellt, die von KeyedCollection<TKey, TItem> abgeleitet ist und ein einfaches Bestellformular darstellt. Das Bestellformular enthält OrderItem-Objekte, die bestellte Artikel darstellen. Im Codebeispiel werden außerdem eine SimpleOrderChangedEventArgs-Klasse erstellt, die die Ereignisinformationen enthält, sowie eine Enumeration, mit der die Art der Änderung angegeben werden kann.

Im Codebeispiel wird das benutzerdefinierte Verhalten veranschaulicht, indem die Eigenschaften und Methoden der abgeleiteten Klasse in der Main-Methode der Demo-Klasse aufgerufen werden.

In diesem Codebeispiel werden Objekte mit unveränderlichen Schlüsseln verwendet. Ein Codebeispiel, in dem veränderbare Schlüssel verwendet werden, 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.
 */


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.
Alle öffentlichen static (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.