Wenn man mit Variablen arbeitet, hat man in VBA eine Reihe Mglichkeiten, Variablen zu speichern - zum Beispiel modulglobal, applikationsglobal, lokal, statisch usw.
Aber oft braucht man auch eine Reihe von Werten als Liste, fr die es mehr als umstndlich wre, je eine eigene Variable zu definieren.

Schon seit (mindestens) C64-Zeiten bietet Basic dafr die Arrays an. Sozusagen eine durchnumerierte Variablenliste mit einem einzigen Variablennamen.

Fr den Anfang also bentigt man nur den Variablennamen, die bentigte Menge und den Variablentypen.

[code]Public Sub Demo1_Array()
    Dim i As Long
    Dim x(8) As String
    
    x(0) = "Dies"
    x(1) = "ist"
    x(2) = "ein"
    x(3) = "Beispiel"
    x(4) = "fr"
    x(5) = "ein"
    x(6) = "sehr"
    x(7) = "simples"
    x(8) = "Array"
    
    For i = 0 To 8
        Debug.Print x(i) & " ";
    Next
End Sub[/code]

Der Variablenname ist "x", die Menge ist "8" und der Typ ist "String". Eigentlich ist die Menge 9, denn in Basic fangen Arrays immer mit 0 an, solange man nichts anderes definiert. Man kann in VBA auch so definieren: "Dim x(1 To 8)", dann erhlt man wirklich nur 8. Ebenso geht auch "Dim x(3 to 14)" - dann hat man die Indizes 3 bis 14. Alternativ gibt es auch noch die Mglichkeit, mit "Option Base 1" am Beginn eines Moduls alle Arrays immer mit 1 beginnen zu lassen - da das aber zum Beispiel nicht auf den Array-Befehl zutrifft, ist das eher verwirrend als hilfreich.

Der groe Vorteil von Arrays ist, da man auf jedes Element der Liste mit seiner jeweiligen Nummer (dem Index) zugreifen kann. Mit x(7) erhlt man sofort den Wert "simples" in dem Beispiel oben. Schnell und effektiv. Arrays knnen sogar halbwegs flexibel gestaltet werden. Im Gegensatz zu den C64-Arrays knnen in VBA Arrays auch dynamisch definiert werden. So knnte man die Zeile, die das Array oben fest und unabnderlich mit 9 Elementen (0 bis 8) definiert, auch so definieren:

[code]    Dim x() As String
    ReDim x(8)[/code]
	
Hierbei wird nur gesagt "ich brauche ein String-Array" und wieviele Elemente, steht dann im ReDim. Das wre auch noch nicht so wirklich interessant, aber ReDim kann eben Dinge, die Dim nicht kann. So kann die Anzahl aus einer anderen Variable kommen, ebenso kann man mit dem Zusatz "Preserve" die bereits definierten Elemente eines Arrays beibehalten, wohingegen ein einfaches ReDim erst alle Elemente lscht. So kann man das gleiche Array fr verschiedene Zwecke nutzen, und das Array kann beliebig kurz oder lang werden, ohne es eingangs festlegen zu mssen.

Fr die meisten einfachen Aufgaben gengt das vllig. Wenn man damit leben kann, da der Variablentyp des Arrays sofort definiert werden mu - im Zweifelsfall "Variant", was dann verschiedene Typen aufnehmen kann, aber auch eigene Sorgfalt beim Auslesen der Werte erfordert.

Ein weiterer Vorteil von Arrays ist, da sie zwei- und mehrdimensional sein knnen. Sie knnen so ganze Tabellen aufnehmen oder mehrere Tabellen oder mehrere Datenbanken von Tabellen, mit jeder zustzlicher Dimension eine Ebene weiter. Problem aber bleibt, da Arrays nun einmal nur ber ihre Indizes angesprochen werden knnen, also in welchem Element meines fnfdimensionalen Arrays war noch gleich die Variable, die ich suche...?

VBA bietet aber noch eine viel praktischere Methode, um Variablen zu sammeln, ein kleines, unscheinbares Objekt, dem man seine Mglichkeiten zu Beginn gar nicht ansieht, das aber zu den mchtigsten gehrt: Die Collection.

Die Collection verhlt sich wie ein Behlter: Man kann wirklich alles hineinkippen, und das beste ist, der Datentyp ist dabei vllig egal. Das Beispiel oben knnte man fr eine Collection folgendermaen umschreiben. Zunchst braucht es mal eine Collection-Variable:

[code]Dim colTest As Collection[/code]

Da fllt auf, da es hier keine Klammern gibt, auch keine Mengendefinition wie im Array-Beispiel. Die Collection ist ein "Behlter", der immer nur genauso gro ist, da alles reinpat. Sie kann 1, 10, 100 oder 1.000.000 Dinge aufnehmen, je nachdem, wieviel Hauptspeicher der Rechner hat. Dabei sind die Elemente in der Collection genauso einfach zugreifbar wie die Elemente eines Arrays: Einfach den Index des Elementes angeben, dann bekommt man das richtige Objekt wieder zurck. Das kann ein String sein, oder ein Long oder was auch immer.

Da eine Collection ein Klassenobjekt ist, gengt die Zeile oben noch nicht, um mit ihr zu arbeiten. Wie bei jeder anderen Klasse mu man aus der Klasse (der "Blaupause") erst ein Objekt erzeugen (das "fertige Produkt"). Das geht einfach mit "New":

[code]Set colTest = New Collection[/code]

Man sollte diese beiden Zeilen immer voneinander trennen, schon alleine, um die reine Deklaration von der Objekterstellung zu trennen. Man knnte ansonsten auch schreiben "Dim colTest As New Collection".

Da die Collection automatisch mit jedem Element "mitwchst", bentigt man kein umstndliches ReDim (bei dem man immer noch auf das "Preserve" achten mte und die neue Gesamtanzahl Indizes immer explizit angeben mte), man schreibt einfach "Add":

[code]colTest.Add "MeinElement"[/code]

Damit ist der String "MeinElement" jetzt automatisch das erste Element in der Collection. Eine Collection beginnt im Gegensatz zum Array immer mit 1 und das kann auch nicht gendert werden. Indizes wie "2 To 14" sind also nicht mglich. Aber die Collection kann ja noch mehr. Sie kann nmlich jedem Element einen Key zuordnen (der allerdings ein String sein mu), und so knnte man dem Element "MeinElement" nun einen Key "2" zuordnen (wichtig: "2", nicht 2, also String). Auf diese Weise knnte man jedem Element also nun doch wieder die Indizes 2 bis 14 zuweisen, nur eben als String - dank der vielfachen Konvertierungsmglichkeiten in VBA ist das ja kein Problem.

Jetzt kann das Array-Beispiel oben zum Beispiel so in eine Collection bertragen werden:

[code]Public Sub Demo3_Collection()
    Dim i As Long
    Dim colTest As Collection
    Set colTest = New Collection
    
    colTest.Add "Dies", "0"
    colTest.Add "ist", "1"
    colTest.Add "ein", "2"
    colTest.Add "Beispiel", "3"
    colTest.Add "fr", "4"
    colTest.Add "ein", "5"
    colTest.Add "sehr", "6"
    colTest.Add "simples", "7"
    colTest.Add "Array", "8"
    
    For i = 1 To 9
        Debug.Print colTest(i) & " ";
    Next
    Debug.Print
    
    For i = 0 To 8
        Debug.Print colTest(CStr(i)) & " ";
    Next
End Sub[/code]

Die beiden Schleifen unten zeigen zwei Mglichkeiten, die Elemente der Collection auszulesen. Dabei mu man bei der numerischen Methode mit 1 beginnen, also 1 to 9, bei der Methode Zugriff ber den selbstdefinierten Schlssel kann man wieder mit 0 to 8 arbeiten.

Moment...selbstdefiniert...String als Schlssel - da kommt man doch auf die Idee, da man seine Elemente einfach benennen knnte (in anderen Programmiersprachen auch "benannte Arrays" genannt). Da eine Collection ein Objekt ist, kann man auch "With" verwenden, um den Code bersichtlicher zu machen:

[code]Public Sub Demo4_Collection()
    Dim i As Long
    Dim colTest As Collection
    Set colTest = New Collection
    
    With colTest
        .Add "Isaac", "Vorname"
        .Add "Asimov", "Nachname"
        .Add "Mnchen", "Ort"
        .Add "Teststrae", "Strasse"
        .Add "1a", "Hausnummer"
    End With
    
    For i = 1 To colTest.Count
        Debug.Print colTest(i) & " ";
    Next
    Debug.Print
End Sub[/code]

Wie man hier sieht, hat man nun sozusagen eine Tabelle mit einem Datensatz: Jedes Element hat als Key den Feldnamen und als Wert den Feldinhalt. Wenn man also wissen mchte, wo Isaac wohnt, kann man einfach mit "colTest("Ort")" direkt auf das Element zugreifen - oder nach wie vor mit seinem Index 3 (weil als drittes hinzugefgt). Da es in jeder Collection die Eigenschaft "Count" gibt, kann man auch ganz simpel sehen, wieviel in unserem "Behlter" gerade drin ist, hervorragend fr bersichtliche Schleifen geeignet, die sich einem gleich beim Lesen erschlieen.

Die Collection kann aber noch viel mehr. Wenn die Hausnummer zum Beispiel immer numerisch sein soll, dann htte man ebenso auch schreiben knnen:

[code]	.Add 1,"Hausnummer"[/code]

Womit man sieht, da die Collection wirklich alles schluckt, an beliebiger Position. Da "Add" aber auch noch die optionalen Parameter "Before" und "After" anbietet, kann man ein neues Element auch gezielt an einer bestimmten Position in der Collection einfgen - das macht aber nur Sinn, wenn man ber den numerischen Index auf die Elemente zugreifen mchte, aber man kann so eine einfache Sortierung durchfhren, indem man ber den String-Key das Element bestimmt, bei dem eingefgt werden soll. Grundstzlich gibt es dafr aber einfachere Methoden - einerseits ein Objekt "Dictionary", das man sich aus VBScript "ausleihen" kann (aber eben eine externe Refernzierung bentigt, whrend die Collection immer da ist) und eine Art erweiterte Collection mit Sortiermglichkeit ist, andererseits kann man fr solche Operationen besser eine Access-Tabelle verwenden, was dann auch performanter ist.
Die Collection soll ja auch nicht den Sinn einer Tabelle oder von SQL ersetzen, sondern viele neue Mglichkeiten auf der Programmierebene ermglichen. In der Praxis ist daher "Before" und "After" eher nicht so bedeutend, aber vielleicht findet ja jemand sinnvolle Anwendungsmglichkeiten.

Doch die Collection ist lngst noch nicht am Ende. Ein Array kann mehrdimensional sein - aber das kann eine Collection auch. Bei einem mehrdimensionalen Array (mal 2 Dimensionen angenommen) hat man im Prinzip eine einfache Tabelle: Jedes Element kann durch Angabe von "Zeile" und "Spalte" wiedergefunden werden. Das kann man mit einer Collection ebenfalls! Wie? Ganz einfach: Da eine Collection, wie gesagt, ALLES aufnehmen kann, ist die Verwendung fr primitive Datentypen wie String, Long, Double eigentlich eine Verschwendung ihrer Mglichkeiten. ALLES schliet eben auch eine Collection ein. Also kann eine Collection auch eine andere Collection aufnehmen und schon hat man die Entsprechung zu einem zweidimensionalen Array. In einem Array hat man z.B. 10 Elemente in der 1. Dimension, hier als "Zeile" der Tabelle angenommen und 5 Elemente in der 2. Dimension, als "Spalte". Damit gibt es 50 Elemente im Array.
In der Collection erstellt man eine Collection, die 5 Spaltenelemente enthlt und legt dann davon 10 Collections an, die man nacheinander in die bergeordnete Collection einfgt - schon kann man mit "colTest(2)(3)" auf das 3. Element (die 3. "Spalte") der 2. Collection (der 2. "Zeile") zugreifen (bei einem Array wre es "x(2,3)".

[code]Public Sub Demo5_Collection()
    Dim i As Long
    Dim colTabelle As Collection
    Dim colZeile As Collection
    Set colTabelle = New Collection
    
    
    Set colZeile = New Collection
    With colZeile
        .Add "Isaac", "Vorname"
        .Add "Asimov", "Nachname"
        .Add "Mnchen", "Ort"
        .Add "Teststrae", "Strasse"
        .Add "1a", "Hausnummer"
    End With
    
    colTabelle.Add colZeile
    
    Set colZeile = New Collection
    With colZeile
        .Add "Robert A.", "Vorname"
        .Add "Heinlein", "Nachname"
        .Add "Berlin", "Ort"
        .Add "Testplatz", "Strasse"
        .Add 2, "Hausnummer"
    End With
    
    colTabelle.Add colZeile
    Debug.Print colTabelle(2)(3)
End Sub[/code]

Der Grund fr diese "komische" Schreibweise ist, da man mit der Angabe des ersten Indizes (2) die zweite Collection zurckerhlt und mit der (3) gibt man dann das 3. Element dieser Collection an - das ist die Objektverkettung. So ergibt "colTabelle(2).Count" die Anzahl Elemente der 2. Collection colZeile. Die Anzahl Elemente in der ersten Collection bekommt man, wenn man "colTabelle.Count" schreibt. Auerdem wird man hier feststellen, da man fr die erste "Count"-Variante keine Hilfe von IntelliSense bekommt. Das liegt daran, da die Collection eben alles schluckt und IntelliSense nicht wei, um was fr ein Objekt es sich bei der zweiten Collection handelt (knnte ja auch ein String oder was immer sein) und daher einfach gar nichts ausgibt.

Um ein in eine Collection eingefgtes Objekt wieder korrekt aus der Collection herauszuholen, mu man einfach eine passende Objektvariable definieren und das Element dieser zuweisen, also z.B. so:

[code]Dim colAuslesen As Collection
Set colAuslesen = colTabelle(2)
Debug.Print colAuslesen.Count		' Und hier funktioniert auch wieder IntelliSense[/code]

Statt "colAuslesen" knnte man hier auch "colZeile" verwenden, denn das Objekt wird ja nur zum Befllen der ersten Collection bentigt und danach verworfen.

Ein Zuweisen mit "New" ist hier auch nicht notwendig, denn man will ja keine neue Collection aufmachen (eine neue Instanz der Klasse Collection), sondern einfach nur das schon vorhandene Collection-Objekt wieder aus der bergeordneten Collection herausholen, damit man wieder ordentlich auf alle Elemente zugreifen kann.

Wenn man das Beispiel aber genau betrachtet, kann die Collection in Sachen "mehr Dimensionen" sogar noch mehr als ein Array: Whrend dieses immer 50 Elemente im Beispiel haben mu, wenn man es mit 5 und 10 dimensioniert, kann jede hinzugefgte Collection in der bergeordneten Collection ohne weiteres auch mehr oder weniger Elemente enthalten. Es wre also kein Problem, da Zeile 1 der "Tabelle" nur 3 Elemente, Zeile 2 dann 5 und Zeile 3 18 Elemente enthlt. Fr eine Collection kein Problem. Ebenso knnte Zeile 4 ein einfacher String sein, Zeile 5 ein Formularobjekt enthalten oder, oder, oder... der Aufbau kann beliebig komplex werden.

Ja, richtig gelesen - Formularobjekt. Da ein Formular auch wie ein Objekt instantiiert werden kann, kann man das erzeugte Formular ebenfalls einer Collection hinzufgen. So kann man ein und dasselbe Formular z.B. 20mal ffnen, und alle 20 Instanzen der Collection hinzufgen. Damit kann man gezielt jede der 20 Instanzen ansprechen - und da die Collection einen String als Key entgegennehmen kann, kann jedes Formular sogar einen eigenen Namen bekommen, wenn man will.

Will man die Formulare auf einen Schlag loswerden, killt man einfach die Collection - schon sind 20 Formulare zum Teufel und verschwinden vom Bildschirm. Das geht einfach mit "Set colTest = Nothing". Jedes Formular erledigt dabei noch alles, was notwendig ist, alle ausstehenden Events, etwa Form Unload.

Noch mehr Mglichkeiten? Kein Problem: Eine Collection kann natrlich auch Recordset-Objekte aufnehmen, so kann man eine Reihe geffneter Recordsets der Collection hinzufgen und mit Namen versehen und direkt darauf zugreifen. Das Prinzip zum Herausholen funktioniert genauso wie bei dem Beispiel mit der Untercollection oben: Man erstellt fr den einfacheren Zugriff eine Recordset-Objektvariable und weist die dem gewnschten Recordset-Objekt der Collection zu:

[code]Dim rs As DAO.Recordset
Set rs = colRecordsets("MeinRecordsetname")[/code]

Auerdem gibt es noch eine spezielle "For-Next"-Schleife, die schneller ist als die bliche "For i = 1 to 100" Methode: For Each.
Damit kann man sagen "Fr jedes Element meiner Collection fhre die folgenden Befehle aus". Dabei entfllt das umstndliche Zuweisen einer Objektvariablen mit Set wie in den beiden Beispielen oben, man mu nur wissen, welcher Objekttyp in der Collection ist und jedes Element der Collection mu in diesem Fall vom gleichen Typ sein.
Htte man also eine Collection, die nur Recordset-Objekte enthlt, knnte man diese z.B. so alle schlieen:

[code]Dim rs As DAO.Recordset
For Each rs in colRecordsets
   rs.Close
Next[/code]

Eigentlich doch schn einfach und bersichtlich, oder?
In jedem Schleifendurchlauf wird damit automatisch die "Set"-Zeile oben ausgefhrt, daher mu natrlich sichergestellt sein, da die Collection fr diese Art Schleife nur Recordset-Objekte enthlt - sonst wrde eine Fehlermeldung ausgegeben.
Ebenso mu man beim Zugriff auf Collection-Elemente beachten, da es zu einem Error kommt, wenn man auf ein Element zugreift, das nicht in der Collection ist. Wenn man also nicht wei, ob das gewnschte Element vorhanden ist, kann man einfach so abfangen:

[code]On Error Resume Next
Set rs = colRecordsets("MeinRecordsetname")
If Err.Number = 0 Then
   ' Alles OK, rs kann verwendet werden
Else
   ' Fehlermeldung ausgeben
End If[/code]

Statt "On Error Resume Next" kann man natrlich auch eine Fehlerbehandlungsroutine verwenden, hat aber ein wenig den Nachteil, da es die Fehlerbehandlung auseinanderreit und man den Code nicht so ohne weiteres lesen kann.

Mehr? Bitteschn:
Selbstverstndlich kann man eine Collection auch als Parameter in einer Sub oder Function bergeben - und nach den vorstehenden Ausfhrungen ahnt man gerade mal, was das bedeutet. Da man massenweise und unterschiedlichste Dinge in einer Collection ablegen kann, kann man auch die komplexesten Variablenkonstrukte, Objektinstanzen, was auch immer, mit EINEM Parameter an eine Sub bergeben! Nie wieder ellenlange Parameterkonstruktionen.

Hier mu man beachten: Eine normale Variable kann "ByVal" oder "ByRef" bergeben werden - eine Collection kann ebenso als Parameter definiert werden, tatschlich ignoriert Access aber "ByVal" und erzeugt immer nur "ByRef". Das ist wohl auch gut so, denn wenn man sich eine Megabyte-Collection vorstellt, die mit "ByVal" bergeben wrde, wrden ja alle enthaltenen Elemente dupliziert werden mssen, das knnte ein ziemlich heftiger Aufwand sein. Wenn man also in der aufgerufenen Prozedur, die die Collection als Parameter bekommt, etwas in der Collection ndert, dann ndert man es auch fr die bergeordnete Prozedur.

Und noch ein Highlight der Collection:
Wie gesagt, sie frit ALLES. Also warum nicht ganz einfach ein eigenes Datenobjekt verwenden? Nein - verget die "Type"-Definitionen. Theoretisch schne Idee, um ein paar Variablen zu einem Typobjekt zusammenzufassen, wird man mit Type nicht glcklich, da es an allen mglichen Stellen Fehlermeldungen auswirft, man knne den Typ hier nicht verwenden und dort nicht - man knnte es auch gleich entfernen, da mehr oder minder nutzlos.

Das gleiche kann man genauso erreichen, indem man einfach ein neues Klassenmodul schreibt. Das ist nicht so schwer, wie es sich anhrt. Im VBA-Editor einfach "Einfgen" - "Neues Klassenmodul" (statt "Modul") verwenden und schon steht das Klassenmodul. Im einfachsten Fall kann man nun einfach ein paar Public-Variablen definieren und schon hat man ein lauffhiges Klassenmodul. Also statt:

[code]Public Type typMeineDaten
	strX As String
	lngY As Long
End Type[/code]

schreibt man einfach in das neue Klassenmodul (mit den natrlich obligatorischen beiden "Option"-Befehlen):

[code]Option Compare Database
Option Explicit

Public strX As String
Public lngY As Long[/code]

Das ist schon alles. Die "Type"-Definition ist damit vollstndig ersetzt, das Klassenmodul funktioniert genauso, aber mit dem daraus erstellten Objekt kann man beliebig arbeiten, ohne Fehlermeldungen. Die Klasse benennt man nun in z.B. "clsMeineDaten".

Wrde man bei "Type" so schreiben:
[code]Dim objDaten As typMeineDaten[/code]

schreibt man beim Klassenmodul nun:
[code]Dim objDaten As clsMeineDaten[/code]

Kein Unterschied bis hierhin. Nur bei "Type" mu man kein "New" verwenden, beim Klassenmodul schon:
[code]Set objDaten = New clsMeineDaten[/code]

Das ist aber auch schon das Einzige, was Type interessanter macht als Objekte - also einfach vergessen.

Nun kann das neue Objekt mit Daten befllt werden:
[code]    With objMeinObjekt
        .strX = "Test 1"
        .lngY = 1
    End With[/code]

Da kommen wir wieder zur Collection zurck: Diese kann nun wieder einfach mit "Add" das neue eigene Datenobjekt entgegennehmen, damit kann die Collection also ganz komplexe eigene Datenstrukturen beinhalten. Schade ist lediglich, da es keine Mglichkeit gibt, den erstellten Key zu dem Element einer Collection auszulesen, wie das zum Beispiel bei einer TreeView geht (die auch darauf basiert). Aber man kann sich einfach damit behelfen, da man in eigenen Datenobjekten eben eine zustzliche Variable fr den Key einfgt und diesen dann hier speichert. Ansonsten mu man eben selbst wissen, welche Objekte hinter welchen Keys stehen und welche in der Collection enthalten sind.

brigens, nicht wundern: Das "Lokal"- und "berwachungs"-Fenster aus dem VBA-Editor zeigt nur die ersten 256 Elemente einer Collection an, die anderen danach sind aber trotzdem enthalten. Mit diesen beiden Hilfen kann man bequem durch alle Collections browsen und deren Inhalte ausgeben und damit bekommt man auch komplexe Collections schnell in den Griff.

Alles Neuland? Von wegen. Die meisten haben schon lngst mit Collections gearbeitet. Ein paar "prominente" Beispiele: Die "Forms"-Collection beinhaltet alle gerade geladenen Formulare (so sie denn mit DoCmd.OpenForm geffnet wurden). Die "Reports"-Collection analog fr Reporte. Die "Controls"-Collection eines Formulars enthlt alle Controls dieses Formulars. Die "Fields"-Collection des Recordsets enthlt alle Feldnamen als Key und den Feldinhalt als Element. Die "TempVars"-Collection (ab Access 2007) enthlt beliebige, einfache Variablentypen (eine Sonderform der Collection). Die Programmierer von Access haben uns VBA-Programmierern etwas voraus: Sie knnen mit einer echten objektorientierten Programmiersprache arbeiten und damit Objekte vererben - daher kann man aus einer "simplen" Collection mehr machen.

Naja, wir haben zwar keine Vererbung, aber das heit nicht, da wir keine Mglichkeit htten, etwas hnliches selbst zu machen. Man kann nicht nur Objekte in Collections einfgen - man kann natrlich auch Collections in Objekten verwenden. Statt also nur "strX" zu definieren, kann man ebensogut eine Collection in so ein Klassenmodul schreiben, natrlich auch xbeliebig viele. Damit kann man eine Collection auch "erweitern" - indem die Collection Teil eines Objektes wird, das weitere Parameter oder natrlich auch weitere Funktionen/Subs enthlt, die etwa nach einem bestimmten Key suchen knnten, so da man im Hauptprogramm keine extra Fehlerbehandlung implementieren mu. Das bergeordnete Objekt wird so zum "Behlter" fr Collections, Variablen, Properties, Functions und Subs - und da jedes Objekt eine Eventfunktion "Class_Initialize" und "Class_Terminate" besitzt, kann man dort praktischerweise auch gleich die Collections instantiieren und am Ende wieder terminieren, so da sich das Hauptprogramm auch darum nicht kmmern mu. Im einfachen Beispiel she das etwa so aus:

[code]Option Compare Database
Option Explicit

Private clsvar_colTest As Collection

'---------------------------------------------------------------------------------------
' Property    : Test
' Returns     :  - Collection
'---------------------------------------------------------------------------------------
'
Public Property Get Test() As Collection
    Set Test = clsvar_colTest
End Property
Public Property Set Test(colTest As Collection)
    Set clsvar_colTest = colTest
End Property

'---------------------------------------------------------------------------------------
' Property    : ColElement
' Returns     :  - Collection
'---------------------------------------------------------------------------------------
'
Public Property Get ColElement(strName As String) As String
    Dim strReturn As String
    On Error Resume Next
    strReturn = clsvar_colTest(strName)
    If Err.Number = 0 Then
        ColElement = strReturn
    Else
        ColElement = ""
    End If
End Property

Private Sub Class_Initialize()
    Set clsvar_colTest = New Collection
End Sub

Private Sub Class_Terminate()
    Set clsvar_colTest = Nothing
End Sub[/code]

Diese einfache Klasse bietet den Direktzugriff auf die Collection ber die Eigenschaft "Test" - mit allen Fehlerproblemen, die eine Collection hat - oder den Zugriff ber die Eigenschaft "ColElement", die die Fehlerbehandlung selbst bernimmt. Wieder einmal ein Vorteil, den Objekte gegenber einfachen Variablen haben: Man kann gezielt programmtechnisch steuern, welche Werte zurckgegeben werden und wie auf Fehler reagiert werden soll.

Der Aufruf she so aus:

[code]Public Sub Demo7_Collection()
    Dim objDemo As clsDemo
    Set objDemo = New clsDemo
    
    objDemo.Test.Add "MeineVariable", "MeinKey"
    Debug.Print objDemo.ColElement("MeinKey")
End Sub[/code]

Wrde man unten jetzt "MeinKey2" eingeben, der nicht existiert, wrde die Collection selbst mit einem Fehler reagieren, aber da die Eigenschaft "ColElement" verwendet wird, die den Fehler abfngt, kommt einfach nur ein leerer String zurck.

Fazit:
Wer also noch nie mit eigenen Collections gearbeitet hat und bisher immer nur Arrays verwendet hat, findet hier nun ein weites Feld zum Austoben, womit Anwendungen ein ganzes Stck flexibler werden knnen. Die Collection sieht am Anfang so simpel aus - Behlter fr die Aufnahme beliebiger Objekte - wenn man aber nher hinsieht, ist das wahrscheinlich das mchtigste Instrument in VBA, weswegen Access selbst ja auch reichlich Gebrauch davon macht.

In der angehngten Datenbank befinden sich die Beispiele, es sind keine Tabellen etc. vorhanden, nur die Module "modDemo" und "clsDemo".

Viel Spa beim Experimentieren und sammeln...

Christian
