Verwenden von Visual C# zum Implementieren benutzerdefinierter Sammlungen

Artikel
05/08/2022
3 Minuten Lesedauer

In diesem Schritt-für-Schritt-Artikel erfahren Sie, wie Sie eine benutzerdefinierte Sammlung in Visual C# implementieren. Die Basisklassenbibliotheken von Microsoft .NET Framework bieten eine formale Definition einer SammlungsschnittstelleSystem.Collections.ICollection.

Originalversion des Produkts: Visual C #
Ursprüngliche KB-Nummer: 307484

Implementieren der ICollection-Schnittstelle in einer benutzerdefinierten Klasse

Die ICollection Schnittstelle erbt von der IEnumerable Schnittstelle. Die ICollection Schnittstelle definiert eine CopyTo Methode und drei schreibgeschützte Eigenschaften: IsSynchronized, SyncRootund Count. ICollection erbt die GetEnumerator Methode von der IEnumerable Schnittstelle. Eine benutzerdefinierte Sammlungsklasse sollte die ICollection Schnittstelle implementieren.

Führen Sie die folgenden Schritte aus, um die ICollection Schnittstelle zu implementieren:

Erstellen Sie in Visual C# .NET eine Windows Anwendung.
Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, zeigen Sie auf "Hinzufügen", und klicken Sie dann auf "Klasse hinzufügen", um ein Klassenmodul namens CustomCollection hinzuzufügen.
Fügen Sie am Anfang des Klassenmoduls den folgenden Beispielcode hinzu, um den System.Collection Namespace zu importieren:
```
using System.Collections;
```
Ersetzen Sie den anderen Code im Modul durch den folgenden Beispielcode:
```
public class CustomCollection : ICollection
{
    private int[] intArr = {1,5,9};
    private int Ct;

    public CustomCollection()
    {
        Ct=3;
    }
}
```
Der Einfachheit halber enthält die CustomCollection Klasse ein Array mit drei ganzzahligen Elementen und einer Anzahlvariablen.
Implementieren Sie die CopyTo Methode, die ein ganzzahliges Array und einen Index als Parameter verwendet. Diese Methode kopiert die Elemente in einer Auflistung in das Array, beginnend mit dem übergebenen Index. Fügen Sie zum Implementieren dieser Methode den folgenden Code nach dem öffentlichen CustomCollection Konstruktor ein:
```
void ICollection.CopyTo(Array myArr, int index)
{
    foreach (int i in intArr)
    {
        myArr.SetValue(i,index);
        index = index+1;
    }
}
```
Implementieren Sie die GetEnumerator Methode, die von der ICollection Schnittstelle geerbt wird IEnumerable. Die GetEnumerator Methode gibt ein Enumerator Objekt zurück, das durch eine Auflistung durchlaufen kann. Fügen Sie den folgenden Beispielcode nach der CopyTo Methode ein:
```
IEnumerator IEnumerable.GetEnumerator()
{
    return new Enumerator(intArr);
}
```

Um die drei schreibgeschützten Eigenschaften zu implementieren, fügen Sie den folgenden Code nach der GetEnumerator Methode ein:

// The IsSynchronized Boolean property returns True if the
// collection is designed to be thread safe; otherwise, it returns False.
bool ICollection.IsSynchronized
{
    get
    {
        return false;
    }
}

// The SyncRoot property returns an object, which is used for synchronizing
// the collection. This returns the instance of the object or returns the
// SyncRoot of other collections if the collection contains other collections.
object ICollection.SyncRoot
{
    get
    {
        return this;
    }
}

// The Count read-only property returns the number
// of items in the collection.
int ICollection.Count
{
    get
    {
        return Ct;
    }
}

Implementieren eines Enumerator-Objekts für die GetEnumerator-Methode

In diesem Abschnitt wird gezeigt, wie Sie eine Enumerator Klasse erstellen, die durchlaufen kann CustomCollection.

Fügen Sie den folgenden Beispielcode nach der Endklassen-Anweisung in Ihr Klassenmodul ein:
```
public class Enumerator : IEnumerator
{
    private int[] intArr;
    private int Cursor;
}
```
Deklarieren Sie das intArr private ganzzahlige Array, um die Elemente der CustomCollection Klasse zu speichern, wenn die GetEnumerator Methode aufgerufen wird. Das Cursor Feldelement enthält die aktuelle Position beim Aufzählen.
Fügen Sie einen Konstruktor als Parameter hinzu, und legen Sie den lokalen intArr Konstruktor intArr auf diesen fest. Fügen Sie den folgenden Beispielcode nach der Deklaration des Memberfelds ein:
```
public Enumerator(int[] intarr)
{
    this.intArr = intarr;
    Cursor = -1;
}
```
Implementieren Sie die und MoveNext MethodenReset. Fügen Sie dazu den folgenden Code nach dem Konstruktor ein:
```
void IEnumerator.Reset()
{
    Cursor = -1;
}
bool IEnumerator.MoveNext()
{
    if (Cursor < intArr.Length)
        Cursor++;

    return(!(Cursor == intArr.Length));
}
```
Reset``Cursor wird auf -1 festgelegt und MoveNext zum Cursor nächsten Element verschoben. MoveNext gibt True zurück, wenn erfolgreich.
Implementieren Sie die Current schreibgeschützte Eigenschaft, die das Element zurückgibt, auf das der CursorWert verweist. Wenn dies -Cursor1 ist, wird ein InvalidOperationExceptionGeneriert. Fügen Sie den folgenden Code nach der MoveNext Methode ein:
```
object IEnumerator.Current
{
    get
    {
        if((Cursor < 0) || (Cursor == intArr.Length))
            throw new InvalidOperationException();
        return intArr[Cursor];
    }
}
```

Verwenden der einzelnen Elemente zum Durchlaufen der benutzerdefinierten Sammlung

Ziehen Sie in "Form1.cs" auf der Registerkarte " Entwurf " eine Schaltfläche auf das Formular.
Doppelklicken Sie auf die Schaltfläche, und fügen Sie dem Ereignis der Schaltfläche den Click folgenden Beispielcode hinzu:
```
CustomCollection MyCol = new CustomCollection();

foreach (object MyObj in MyCol)
    MessageBox.Show(MyObj.ToString());
```
Drücken Sie F5, um die Anwendung auszuführen, und klicken Sie dann auf die Schaltfläche.

Hinweis

In einem Meldungsfeld werden die Elemente in der benutzerdefinierten Auflistung angezeigt.

Wie funktioniert das? Für jeden Aufruf wird die GetEnumerator Methode zum Erstellen des Enumerator Objekts aufgerufen und die MoveNext Methode aufgerufen, um das Cursor erste Element festzulegen. Anschließend wird auf die aktuelle Eigenschaft zugegriffen, um das Element in MyObjabzurufen. Dies wird wiederholt, bis MoveNext False zurückgegeben wird.