Im Artikel “VBA Basics: Auflistungen mit Collections” (www.vbentwickler.de\/514) haben wir die Collection<\/b> kennengelernt – eine einfache, geordnete Liste ohne Verweis. Ihr grösstes Manko: Es gibt keine Möglichkeit zu prüfen, ob ein Schlüssel existiert. Genau hier setzt das Dictionary<\/b> aus der Microsoft Scripting Runtime<\/b> an. Es bietet Exists<\/b>, erlaubt das direkte Ändern von Werten und liefert Schlüssel und Werte als Array – damit ist es die erste Wahl für Duplikatprüfungen, Häufigkeitszählungen und Lookup-Tabellen im Speicher. Wie wir es einrichten, was es kann und wo Stolpersteine lauern, zeigt dieser Beitrag.<\/b><\/p>\n
Das Dictionary einrichten<\/h2>\n
Das Dictionary<\/b> steckt in der Bibliothek Microsoft Scripting Runtime<\/b> (scrrun.dll<\/b>). Bevor wir es per Early Binding nutzen können, müssen wir im VBA-Editor über Extras|Verweise<\/b> den Eintrag Microsoft Scripting Runtime<\/b> aktivieren (siehe Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2026_03\/pic_510_001.png\")
<\/p>\n
Bild 1: Verweis auf die Bibliothek Microsoft Scripting Runtime<\/span><\/b><\/p>\n Alternativ funktioniert Late Binding – dann entfällt der Verweis, aber auch IntelliSense:<\/p>\n Für die Entwicklung empfehlen wir Early Binding wegen IntelliSense und Kompilierungsprüfung.<\/p>\n Das Dictionary<\/b> ist reichhaltiger als die Collection<\/b>. Die wichtigsten Member:<\/p>\n Ein erstes Beispiel – wir speichern Bundesländer-Kürzel und greifen gezielt darauf zu.<\/p>\n In Listing 1 sehen wir gleich drei Vorteile gegenüber der Collection<\/b>: Exists<\/b> statt Fehler-Workaround, direktes Ändern eines Werts per Zuweisung und dic.Keys<\/b> als Array für die Schleife.<\/p>\n Listing 1: Dictionary mit Exists, Wertänderung und Keys<\/span><\/b><\/p>\n Standardmässig vergleicht das Dictionary<\/b> Schlüssel binär – “hh”<\/b> und “HH”<\/b> wären also zwei verschiedene Einträge. In den meisten Access-Szenarien wollen wir das nicht.<\/p>\n Deshalb setzen wir CompareMode<\/b> auf vbTextCompare<\/b>, damit Schlüssel ohne Berücksichtigung der Gross-\/Kleinschreibung verglichen werden.<\/p>\n Wichtig: CompareMode<\/b> lässt sich nur setzen, solange das Dictionary leer ist. Enthält es bereits Einträge, gibt es Laufzeitfehler 5<\/b>. Also immer direkt nach dem Erzeugen setzen.<\/p>\n Das Dictionary<\/b> hat ein Verhalten, das regelmässig für Überraschungen sorgt: Greift man per dic(“XY”)<\/b> auf einen Schlüssel zu, der nicht existiert, gibt es keinen Fehler.<\/p>\n Stattdessen legt das Dictionary<\/b> den Schlüssel stillschweigend an – mit dem Wert Empty<\/b>. Das ist beim Zählen nützlich (dazu gleich mehr), kann aber auch Geistereinträge erzeugen, wenn wir unvorsichtig sind.<\/p>\n Faustregel: Vor dem lesenden Zugriff immer Exists<\/b> prüfen – oder die stille Anlage bewusst nutzen.<\/p>\n Aus einer Tabelle mit Kundendaten wollen wir eine Liste aller eindeutigen Orte gewinnen. Exists<\/b> macht die Duplikatprüfung trivial:<\/p>\n Die Funktion aus Listing 2 liefert ein Array aller eindeutigen Orte.<\/p>\n Listing 2: Eindeutige Orte aus einer Tabelle sammeln<\/span><\/b><\/p>\n Der Wert im Dictionary ist True<\/b> – er interessiert uns nicht, wir nutzen das Dictionary hier nur als Schlüsselspeicher.<\/p>\n Das Array aus dic.Keys<\/b> können wir anschliessend in ein Listenfeld übergeben oder mit Join<\/b> zu einer Zeichenkette zusammenfügen – zum Beispiel im Direktbereich:<\/p>\n Wir wollen zählen, wie oft jeder Wert in einer Spalte vorkommt – eine Häufigkeitstabelle im Speicher. Hier nutzen wir bewusst die stille Anlage:<\/p>\n Die Schlüsselzeile in Listing 3 ist dic(strKat) = Nz(dic(strKat), 0) + 1<\/b>. Beim ersten Zugriff auf einen unbekannten Schlüssel legt das Dictionary ihn mit Empty<\/b> an.#<\/p>\n Listing 3: Häufigkeitstabelle mit dem Dictionary<\/span><\/b><\/p>\n Nz<\/b> wandelt Empty<\/b> in 0<\/b> um, wir addieren 1<\/b> und schreiben das Ergebnis zurück. Somit ist weder eine Exists<\/b>-Prüfung nötig noch eine If<\/b>-Verzweigung – kompakter geht es nicht.<\/p>\n Wenn wir in einer Schleife wiederholt Nachschlagewerte brauchen – etwa den Kategorienamen zu einer KategorieID<\/b> -, ist ein Datenbankzugriff pro Durchlauf viel zu langsam. Die Lösung: Wir laden die Nachschlagetabelle einmal in ein Dictionary<\/b> und greifen danach nur noch auf den Speicher zu.<\/p>\n Die Funktion aus Listing 4 ist universell einsetzbar. Da Dictionary<\/b>-Schlüssel unterschiedliche Datentypen besitzen können, wandeln wir sie mit CStr<\/b> bewusst in Strings um – so vermeiden wir Typkonflikte beim späteren Zugriff. Ein Aufruf wie Set dicKat = LookupLaden(“tblKategorien”, “KategorieID”, “Kategoriename”)<\/b> lädt die gesamte Kategorientabelle. Danach liefert dicKat(“5”)<\/b> sofort den Kategorienamen – ohne Datenbankzugriff. Wichtig: Der Schlüssel muss hier als String übergeben werden, also in Anführungszeichen.<\/p>\n Listing 4: Beliebige Nachschlagetabelle ins Dictionary laden<\/span><\/b><\/p>\n Zum Abschluss eine kompakte Gegenüberstellung:<\/p>\n Die Faustregel: Brauchen wir nur eine geordnete Liste oder eine Objektsammlung, reicht die Collection<\/b>. Sobald wir Exists<\/b> brauchen, Werte ändern oder Schlüssel als Array abfragen wollen, nehmen wir das Dictionary<\/b>.<\/p>\n Das Dictionary<\/b> ist das vielseitigste Werkzeug in VBA, wenn es um Schlüssel-Wert-Zuordnungen geht. Exists<\/b> macht Duplikatprüfungen trivial, die automatische Anlage bei Item<\/b>-Zugriffen ermöglicht elegante Zählmuster, und Keys<\/b>\/Items<\/b> liefern die Daten als Array für die Weiterverarbeitung. Mit CompareMode = vbTextCompare<\/b> vermeiden wir Probleme mit Gross-\/Kleinschreibung.<\/p>\n Wer Arrays als dritte Alternative kennenlernen möchte, findet die Grundlagen im Beitrag VBA Basics: Mit Arrays programmieren<\/b> (www.vbentwickler.de\/439<\/b>).<\/p>\n Für das Zusammenspiel von Dictionary<\/b> und Stringfunktionen – etwa beim Parsen von CSV-Daten in eine Lookup-Tabelle – sei auf den Beitrag VBA Basics: Strings und Stringfunktionen <\/b>(www.vbentwickler.de\/511<\/b>). verwiesen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n VBABasics_Dictionaries.accdb<\/p>\n' Early Binding (mit Verweis)\r\nDim <\/span>dic As <\/span>New<\/span> Scripting.Dictionary\r\n' Late Binding (ohne Verweis)\r\nDim <\/span>dic As Object<\/span>\r\nSet<\/span> dic = CreateObject(\"Scripting.Dictionary\")<\/pre>\nDie Member des Dictionary<\/h2>\n
\n
Das Dictionary in Aktion<\/h2>\n
Public Sub <\/span>DictionaryDemo()\r\n Dim <\/span>dic As <\/span>New<\/span> Scripting.Dictionary\r\n Dim <\/span>varKey As Variant<\/span>\r\n dic.CompareMode = vbTextCompare\r\n dic.Add \"BE\", \"Berlin\"\r\n dic.Add \"HH\", \"Hamburg\"\r\n dic.Add \"BY\", \"München\"\r\n ' Existenz pruefen\r\n If <\/span>dic.Exists(\"HH\") Then<\/span>\r\n Debug.Print<\/span> dic(\"HH\") ' -> Hamburg\r\n End If<\/span>\r\n ' Wert direkt aendern\r\n dic(\"BY\") = \"Bayern (München)\"\r\n ' Alle Eintraege ausgeben\r\n For Each varKey In dic.Keys\r\n Debug.Print<\/span> varKey & \": \" & dic(varKey)\r\n Next<\/span> varKey\r\nEnd Sub<\/span><\/pre>\nCompareMode: Gross- und Kleinschreibung<\/h2>\n
Vorsicht: stille Anlage bei Item-Zugriff<\/h2>\n
Praxis: Duplikate filtern<\/h2>\n
Public Function <\/span>EindeutigeOrte() As Variant<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>dic As <\/span>New<\/span> Scripting.Dictionary\r\n Dim <\/span>strOrt As String<\/span>\r\n dic.CompareMode = vbTextCompare\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Ort FROM tblKunden\", dbOpenSnapshot)\r\n Do Until rst.EOF\r\n strOrt = Nz(rst!Ort, vbNullString)\r\n If <\/span>Len<\/span>(strOrt) > 0 Then<\/span>\r\n If <\/span>Not<\/span> dic.Exists(strOrt) Then<\/span>\r\n dic.Add strOrt, True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\n EindeutigeOrte = dic.Keys\r\nEnd Function<\/span><\/pre>\n Join(EindeutigeOrte, \";\")<\/pre>\n
Praxis: Zählen nach Kategorie<\/h2>\n
Public Sub <\/span>KategorienZaehlen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>dic As <\/span>New<\/span> Scripting.Dictionary\r\n Dim <\/span>strKat As String<\/span>\r\n Dim <\/span>varKey As Variant<\/span>\r\n dic.CompareMode = vbTextCompare\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Kategorie FROM tblProdukte\", dbOpenSnapshot)\r\n Do Until rst.EOF\r\n strKat = Nz(rst!Kategorie, \"(leer)\")\r\n dic(strKat) = Nz(dic(strKat), 0) + 1\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\n For Each varKey In dic.Keys\r\n Debug.Print<\/span> varKey & \": \" & dic(varKey)\r\n Next<\/span> varKey\r\nEnd Sub<\/span><\/pre>\nPraxis: Lookup-Tabelle im Speicher<\/h2>\n
Public Function <\/span>LookupLaden(ByVal strTabelle As String<\/span>, ByVal strKeyFeld As String<\/span>, ByVal strWertFeld As String<\/span> _\r\n ) As <\/span>Scripting.Dictionary\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>dic As <\/span>New<\/span> Scripting.Dictionary\r\n dic.CompareMode = vbTextCompare\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT \" & strKeyFeld & \", \" & strWertFeld & \" FROM \" & strTabelle, dbOpenSnapshot)\r\n Do Until rst.EOF\r\n dic(CStr(Nz(rst.Fields(strKeyFeld), \"\"))) = Nz(rst.Fields(strWertFeld), vbNullString)\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\n Set<\/span> LookupLaden = dic\r\nEnd Function<\/span><\/pre>\nDictionary vs. Collection: Wann was?<\/h2>\n
\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n