{"id":55000522,"date":"2026-08-01T00:00:00","date_gmt":"2026-10-18T13:26:12","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=522"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"VBA_Basics_Auflistungen_mit_Collections","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/VBA_Basics_Auflistungen_mit_Collections\/","title":{"rendered":"VBA Basics: Auflistungen mit Collections"},"content":{"rendered":"

Arrays haben eine feste Grösse – oder müssen mit ReDim Preserve<\/b> umständlich vergrössert werden. Sobald wir eine Liste brauchen, die während der Laufzeit wächst und schrumpft, ist die Collection<\/b> das Mittel der Wahl. Sie gehört zur VBA-Laufzeitbibliothek, steht ohne zusätzlichen Verweis in jedem Projekt zur Verfügung und lässt sich mit For Each<\/b> durchlaufen. Dieser Beitrag zeigt, was die Collection<\/b> kann, wo ihre Grenzen liegen und wie wir sie in der Praxis einsetzen.<\/b><\/p>\n

Was ist eine Collection?<\/h2>\n

Eine Collection<\/b> ist eine geordnete Liste von Elementen. Jedes Element kann einen beliebigen Datentyp haben – Strings, Zahlen, Objekte oder sogar weitere Collections. Die Reihenfolge der Elemente bleibt erhalten, und jedes Element bekommt automatisch einen numerischen Index, der bei 1<\/b> beginnt.<\/p>\n

Eine neue Collection<\/b> legen wir so an:<\/p>\n

Dim <\/span>col As <\/span>New<\/span> Collection<\/pre>\n
Mit New<\/b> wird die Instanz automatisch beim ersten Zugriff auf die Variable erzeugt – nicht bereits in der Deklarationszeile selbst. Alternativ können wir Dim col As Collection<\/b> schreiben und später Set col = New Collection<\/b> aufrufen – das ist nützlich, wenn wir die Collection erst unter bestimmten Bedingungen brauchen.<\/p>\n
Die Member der Collection<\/h2>\n
Die Collection<\/b> ist bewusst schlank. Sie bietet genau vier Member:<\/p>\n
    \n
  • Add Item, [Key], [Before], [After]:<\/b> fügt ein Element hinzu. Item<\/b> ist der Wert, Key<\/b> ein optionaler, eindeutiger String-Schlüssel. Mit Before<\/b> oder After<\/b> steuern wir die Einfügeposition.<\/li>\n
  • Item(Index):<\/b> gibt das Element an Position Index<\/b> zurück (1-basiert) oder das Element mit dem angegebenen Schlüssel. Item<\/b> ist die Standardeigenschaft – col(3)<\/b> ist gleichbedeutend mit col.Item(3)<\/b>.<\/li>\n
  • Count:<\/b> liefert die Anzahl der Elemente.<\/li>\n
  • Remove(Index):<\/b> entfernt das Element an der angegebenen Position oder mit dem angegebenen Schlüssel. Die Indizes der nachfolgenden Elemente verschieben sich automatisch.<\/li>\n<\/ul>\n
    Was auffällt: Es gibt kein Exists<\/b>, kein Replace<\/b> und kein Clear<\/b> oder RemoveAll<\/b>.<\/p>\n
    Wer die Collection leeren will, kann zwar alle Elemente rückwärts mit Remove<\/b> löschen, schneller und sauberer ist aber eine neue Instanz: Set col = New Collection<\/b>.<\/p>\n
    Elemente hinzufügen<\/h2>\n
    Im einfachsten Fall fügen wir Elemente ohne Schlüssel hinzu. Sie landen am Ende der Liste und sind über ihren Index erreichbar (siehe Listing 1).<\/p>\n
    Public Sub <\/span>CollectionFuellen()\r\n    Dim <\/span>col As <\/span>New<\/span> Collection\r\n    col.Add \"Berlin\"\r\n    col.Add \"Hamburg\"\r\n    col.Add \"München\"\r\n    Debug.Print<\/span> col(1)       ' -> Berlin\r\n    Debug.Print<\/span> col(2)       ' -> Hamburg\r\n    Debug.Print<\/span> col.Count    ' -> 3\r\nEnd Sub<\/span><\/pre>\n
    Listing 1: Elemente hinzufügen und per Index abrufen<\/span><\/b><\/p>\n
    Arbeiten mit Schlüsseln<\/h2>\n
    Geben wir beim Add<\/b> einen Schlüssel an, können wir später über diesen Schlüssel auf das Element zugreifen – unabhängig von seiner Position. Der Schlüssel muss ein String<\/b> sein und innerhalb der Collection eindeutig. Beachte die Reihenfolge: Zuerst der Wert, dann der Schlüssel – das ist anders als beim Dictionary<\/b>, wo der Schlüssel an erster Stelle steht.<\/p>\n
    Ein wichtiges Detail: Nach dem Remove<\/b> in Listing 2 verschiebt sich der Index. col(2)<\/b> liefert jetzt “München”<\/b>, nicht mehr “Hamburg”<\/b>. Wer über den Index auf Elemente zugreift und gleichzeitig entfernt, muss die Schleife rückwärts laufen lassen – dazu gleich mehr.<\/p>\n
    Public Sub <\/span>CollectionMitKeys()\r\n    Dim <\/span>col As <\/span>New<\/span> Collection\r\n    ' Add Wert, Schluessel\r\n    col.Add \"Berlin\", \"BE\"\r\n    col.Add \"Hamburg\", \"HH\"\r\n    col.Add \"München\", \"BY\"\r\n    ' Zugriff per Schluessel\r\n    Debug.Print<\/span> col(\"HH\")   ' -> Hamburg\r\n    ' Zugriff per Index geht weiterhin\r\n    Debug.Print<\/span> col(1)       ' -> Berlin\r\n    ' Entfernen per Schluessel\r\n    col.Remove \"HH\"\r\n    Debug.Print<\/span> col.Count    ' -> 2\r\nEnd Sub<\/span><\/pre>\n
    Listing 2: Collection mit Schlüsseln<\/span><\/b><\/p>\n
    Einfügeposition steuern<\/h2>\n
    Mit den Argumenten Before<\/b> und After<\/b> können wir Elemente an einer bestimmten Position einfügen statt immer am Ende. Das ist ein Vorteil, den das Dictionary<\/b> nicht bietet:<\/p>\n
    Dim <\/span>col As <\/span>New<\/span> Collection\r\ncol.Add \"Zweiter\"\r\ncol.Add \"Erster\", Before:=1\r\ncol.Add \"Dritter\", After:=2\r\n' Ergebnis: Erster, Zweiter, Dritter<\/pre>\n
    Durchlaufen mit For Each<\/h2>\n
    Die Collection<\/b> lässt sich mit For Each<\/b> durchlaufen. Die Laufvariable muss als Variant<\/b> deklariert sein, wenn die Collection Werte enthält, oder als der jeweilige Objekttyp, wenn sie Objekte enthält:<\/p>\n
    ' Werte durchlaufen\r\nDim <\/span>varItem As Variant<\/span>\r\nFor Each varItem In col\r\n    Debug.Print<\/span> varItem\r\nNext<\/span> varItem\r\n' Objekte durchlaufen\r\nDim <\/span>frm As <\/span>Form\r\nFor Each frm In Forms\r\n    Debug.Print<\/span> frm.Name\r\nNext<\/span> frm<\/pre>\n
    Alternativ können wir eine For…Next<\/b>-Schleife mit dem numerischen Index verwenden.<\/p>\n
    Das ist nötig, wenn wir während des Durchlaufs Elemente entfernen wollen – For Each<\/b> verträgt das nicht:<\/p>\n
    ' Elemente rueckwaerts entfernen\r\nDim <\/span>lngI As Long<\/span>\r\nFor lngI = col.Count To 1 Step -1\r\n    If <\/span>col(lngI) = \"entfernen\" Then<\/span>\r\n        col.Remove lngI\r\n    End If<\/span>\r\nNext<\/span> lngI<\/pre>\n
    Die rückwärts laufende Schleife ist der Schlüssel: Weil Remove<\/b> die Indizes der nachfolgenden Elemente verschiebt, würden wir vorwärts Elemente überspringen.<\/p>\n
    Prüfen, ob ein Schlüssel existiert<\/h2>\n
    Die grösste Schwäche der Collection<\/b>: Es gibt keine Exists<\/b>-Methode. Versuchen wir, einen doppelten Schlüssel hinzuzufügen, erhalten wir Laufzeitfehler 457<\/b>. Greifen wir auf einen nicht vorhandenen Schlüssel zu, gibt es Laufzeitfehler 5<\/b>. Der übliche Workaround nutzt gezielt On Error Resume Next<\/b>.<\/p>\n
    Da das Element einen beliebigen Datentyp besitzen kann, erfolgt der Zugriff in Listing 3 über eine Variant<\/b>-Variable.<\/p>\n
    Public Function <\/span>ExistiertInCol(col As <\/span>Collection, ByVal strKey As String<\/span>) As Boolean<\/span>\r\n    Dim <\/span>varDummy As Variant<\/span>\r\n    On Error Resume Next<\/span>\r\n    varDummy = col(strKey)\r\n    ExistiertInCol = (Err.Number = 0)\r\n    Err.Clear\r\n    On Error GoTo<\/span> 0\r\nEnd Function<\/span><\/pre>\n
    Listing 3: Hilfsfunktion für die Schlüsselprüfung<\/span><\/b><\/p>\n
    Die Funktion funktioniert, ist aber umständlich. Wer häufig prüfen muss, ob ein Schlüssel existiert, sollte stattdessen das Dictionary<\/b> verwenden – dort gibt es Exists<\/b> als eingebaute Methode. Mehr dazu im Folgeartikel.<\/p>\n
    Praxis: Objekte in einer Collection verwalten<\/h2>\n
    Der stärkste Einsatzbereich der Collection<\/b> ist das Sammeln von Objektinstanzen. Ein typisches Muster: Wir erzeugen mehrere Timer-Objekte und wollen sie zentral stoppen können.<\/p>\n
    In Listing 4 ist die Laufvariable direkt als CLS_Timer<\/b> typisiert – das funktioniert, weil die Collection Objekte enthält. So haben wir IntelliSense in der Schleife. Am Ende erzeugen wir mit Set mcolTimer = New Collection<\/b> eine frische Instanz – das ist die einfachste Art, eine Collection zu leeren.<\/p>\n
    Private <\/span>colTimer As <\/span>New<\/span> Collection\r\nPublic Sub <\/span>TimerRegistrieren(ByVal strName As String<\/span>, ByVal objTimer As <\/span>CLS_Timer)\r\n    colTimer.Add objTimer, strName\r\nEnd Sub<\/span>\r\nPublic Sub <\/span>AlleTimerStoppen()\r\n    Dim <\/span>objTimer As <\/span>clsTimer\r\n    For Each objTimer In colTimer\r\n        objTimer.Stoppen\r\n    Next<\/span> objTimer\r\n    Set<\/span> colTimer = New<\/span> Collection\r\nEnd Sub<\/span><\/pre>\n
    Listing 4: Objektinstanzen zentral verwalten<\/span><\/b><\/p>\n
    Praxis: Duplikate erkennen<\/h2>\n
    Da Add<\/b> bei einem doppelten Schlüssel Fehler 457<\/b> auslöst, können wir dieses Verhalten nutzen, um Duplikate zu erkennen – ohne die Hilfsfunktion von oben.<\/p>\n
    Die Funktion aus Listing 5 versucht, das Element hinzuzufügen. Gelingt es, ist der Schlüssel neu – und das Element bleibt in der Collection erhalten. Schlägt es mit Fehler 457<\/b> fehl, war der Schlüssel bereits vorhanden und die Collection bleibt unverändert.<\/p>\n
    Public Function <\/span>IstDuplikat(col As <\/span>Collection, ByVal strKey As String<\/span>, ByVal varWert As Variant<\/span>) As Boolean<\/span>\r\n    On Error Resume Next<\/span>\r\n    col.Add varWert, strKey\r\n    IstDuplikat = (Err.Number = 457)\r\n    Err.Clear\r\n    On Error GoTo<\/span> 0\r\nEnd Function<\/span><\/pre>\n
    Listing 5: Duplikate erkennen beim Hinzufügen<\/span><\/b><\/p>\n
    Zusammenfassung und Ausblick<\/h2>\n
    Die Collection<\/b> ist das einfachste Werkzeug in VBA für dynamische Listen. Sie ist ohne Verweis verfügbar, bewahrt die Einfügereihenfolge und eignet sich besonders für Objektsammlungen. An ihre Grenzen stossen wir, sobald wir häufig prüfen müssen, ob ein Eintrag vorhanden ist, oder eine Lookup-Tabelle im Speicher brauchen – denn es gibt kein Exists<\/b>, kein Keys<\/b>-Array und primitive Werte lassen sich nicht direkt ersetzen. Objekte können dagegen weiterhin über ihre Referenz verändert werden – nur der Eintrag in der Collection selbst ist unveränderlich.<\/p>\n
    Genau dort setzt der Folgeartikel  VBA Basics: Auflistungen mit Dictionarys <\/b>(www.vbentwickler.de\/510<\/b>)an. Das Dictionary<\/b> aus der Microsoft Scripting Runtime<\/b> bietet Exists<\/b>, direktes Ändern und die Möglichkeit, Schlüssel und Werte als Array abzurufen. Wer zunächst die Grundlagen von Arrays nachlesen möchte, findet sie im Beitrag VBA Basics: Mit Arrays programmieren<\/b> (www.vbentwickler.de\/439<\/b>).<\/p>\n","protected":false},"excerpt":{"rendered":"
    Arrays haben eine feste Grösse – oder müssen mit ReDim Preserve umständlich vergrössert werden. Sobald wir eine Liste brauchen, die während der Laufzeit wächst und schrumpft, ist die Collection das Mittel der Wahl. Sie gehört zur VBA-Laufzeitbibliothek, steht ohne zusätzlichen Verweis in jedem Projekt zur Verfügung und lässt sich mit For Each durchlaufen. Dieser Beitrag zeigt, was die Collection kann, wo ihre Grenzen liegen und wie wir sie in der Praxis einsetzen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662026,66042026,44000030,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000522","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-PowerPoint_programmieren","category-VBAProgrammierung"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t