Einstieg in VBA und die Office Programmier Beispiel von Excel

Transcription

Einführung in die
Programmiersprache
Visual Basic
for Applications…
Maik Bürschgens
13.12.2011
Firma: CAE Elektronik GmbH
1.Betreuer: Prof. Dr. Hans-Joachim Pflug
2. Betreuer: Martin Clasemann
Einführung in Visual Basic for Applications
0. Vorwort
Das Skript verfolgt den Zweck, dem Leser einen Einblick in die Fähigkeiten der Programmiersprache
„Visual Basic for Applications“ , kurz VBA, zu liefern, um den Einstieg in die damit verbundene MSOffice Programmierung zu erleichtern. Dabei wird der Schwerpunkt nicht nur auf Syntax und
Implementierung gelegt - vielmehr soll das Skript dem Leser vermitteln, welche Möglichkeiten sich
im Bereich der Office Programmierung ergeben, falls man als Entwickler diese Programmiersprache
beherrscht.
Ein sekundäres Ziel ist es, Vorurteilen gegenüber VBA vorzubeugen sowie Motivation mitzugeben,
diese Sprache zu erlernen und einzusetzen: Im Programmierumfeld häuften sich auf Grund ihrer
Komplexität und Syntax in der Vergangenheit negative Vorurteile und destruktive Kritik an der
Sprache, welche eigentlich unbegründet sind, wie das Skript zu demonstrieren versucht.
VBA Programme können nicht direkt ausgeführt werden: Um ihre Leistungsfähigkeit und Vorteile in
der Office Programmierung zu demonstrieren, bedarf es der Wahl eines Programmes aus dem
Microsoft Office Paket. Im weiteren Verlauf des Skriptes wird es Excel 2007 sein. Da Excel
weitreichende Anwendungsgebiete umfasst, kann ein Entwickler dort das vollständige Potential VBAs
abrufen. Zusätzlich erhalten Excel-Anfänger die Möglichkeit, einen tiefgreifenden Gebrauch dieser
Office Anwendung kennenzulernen. Excel ist schließlich mehr als ein reines Rechen- oder
Übersichtsprogramm. Desweiteren lassen sich viele Aspekte der Programmierung mit VBA auf
andere MS-Office Programme übertragen und somit verallgemeinern. Wer VBA richtig einzusetzen
weiß, weiß auch um die Stärken des jeweiligen Office Programmes Bescheid.
Zu guter Letzt ist darauf hinzuweisen, dass Leser des Skriptes ein gutes logisches Verständnis
aufweisen sollten. Obendrein schadet es sicherlich nicht, den Sprachkern einer höheren
Programmiersprache z.B. Java zu beherrschen. Dies schließt einerseits Kontrollstrukturen und
andererseits das Konzept der objektorientierten Programmierung mit ein. Dem Sprachkern von VBA
wurde im Skript zwar ein eigenes Kapitel zugewiesen, doch auf die logischen Konzeptabläufe im
Hintergrund wird eher oberflächlich eingegangen. Vielmehr soll das erwähnte Kapitel Syntax und
Anwendung des Sprachkerns veranschaulichen. Das Skript ist also mehr auf Anfänger der
Programmiersprache VBA als auf Programmierneulinge ausgerichtet.
Um das schnelle Begreifen von Syntax und Gebrauch dennoch auch für Einsteiger zu gewährleisten,
werden die Darlegungen der Kapitel 2, 5 und 6 (Syntax und Anwendung I – III) von Tabellen und
Code Beispielen untermauert. Die Anwendungsbeispiele befinden sich im gesammelt
Abbildungsverzeichnis, während die Tabellen kontextabhängig bereits im Skript aufgeführt werden.
Vorwort | - 2 -
Inhaltsverzeichnis
1 Allgemeine Informationen zu VBA .............................................................................................. - 6 1.1 Geschichte und Anfänge der Sprache ........................................................................... - 6 1.2 Eigenschaften von VBA .................................................................................................. - 6 1.3 Verfügbarkeit / Einsatzgebiete ...................................................................................... - 7 2 Syntax und Anwendung I – Der Sprachkern ................................................................................ - 8 2.1 Allgemeines ................................................................................................................... - 8 2.2 Datentypen .................................................................................................................... - 8 2.3 Operatoren .................................................................................................................... - 9 2.4 Variablen, Konstanten und ihr Geltungsbereich ......................................................... - 10 2.5 Arrays, dynamische Arrays und Collections ................................................................ - 11 2.6 Benutzerdefinierte Datentypen .................................................................................. - 11 2.7 Unterprogrammtechnik............................................................................................... - 12 2.8 Klassen und Objektvariablen ....................................................................................... - 13 2.9 Kontrollstrukturen: Entscheidungsstrukturen & Schleifenstrukturen ....................... - 13 2.9.1 Entscheidungsstrukturen.................................................................................. - 13 2.9.2 Schleifenstrukturen .......................................................................................... - 14 2.10 Konvertierung und Manipulation von Daten ............................................................ - 14 2.11 Fehlerbehandlung...................................................................................................... - 15 3 Excel als Tabellenkalkulationsprogramm .................................................................................. - 16 3.1 Allgemeine Informationen zu Excel ............................................................................. - 16 3.2 Fähigkeiten und Bestandteile von Excel ...................................................................... - 16 3.3 Vorteile des Einsatzes von VBA ................................................................................... - 17 4 Der Arbeitsbereich von Excel und die Entwicklungsumgebung für VBA ................................... - 18 4.1 Der Arbeitsbereich von Excel ...................................................................................... - 18 4.2 Vorstellung des VBA Editors ........................................................................................ - 18 4.2.1 Projekt Explorer ................................................................................................ - 19 4.2.2 Eigenschaftenfenster ........................................................................................ - 19 4.2.3 Programmeditor ............................................................................................... - 19 4.2.4 Direktfenster..................................................................................................... - 20 4.2.5 Objektkatalog / IntelliSense ............................................................................. - 20 -
Inhaltsverzeichnis | - 3 -
5 Syntax und Anwendung II – VBA im Zusammenspiel mit Excel ................................................ - 21 5.1 Allgemeine Informationen .......................................................................................... - 21 5.2 Ereignisse ..................................................................................................................... - 21 5.3 Excel Objekte ............................................................................................................... - 22 5.4 Aktionen auf Tabellenblättern und Arbeitsmappen ................................................... - 22 5.5 Manipulation von Zellen und Zellbereichen................................................................ - 23 5.6 Layout von Zellen vordefinieren.................................................................................. - 25 5.6.1 Formatierung der Schrift .................................................................................. - 25 5.6.2 Formatierung von Rahmen............................................................................... - 25 5.6.3 Formatierung der Zelle ..................................................................................... - 26 5.7 Filterfunktionen ........................................................................................................... - 26 5.8 Dialoge und Formulare zur Interaktion mit dem Benutzer ......................................... - 27 5.8.1 Integrierte Dialogfelder .................................................................................... - 27 5.8.2 Das Tabellenblatt als Formular gestalten ........................................................ - 29 5.8.3 Benutzerdefinierte Dialoge .............................................................................. - 31 5.9 Selbst implementierte Ereignisse auslösen und anwenden ........................................ - 32 6 Syntax und Anwendung III – Externe Datenquellen und Präsentation von Daten .................. - 34 6.1 I/O Operationen .......................................................................................................... - 34 6.2 SQL Abfragen und Verarbeitung der Resultate ........................................................... - 35 6.3 Ausführung von Konsolenbefehlen ............................................................................. - 35 6.4 Austausch mit anderen Office Anwendungen............................................................. - 35 6.5 Externe DLL´s einbinden und nutzen ........................................................................... - 35 6.6 Präsentation und Visualisierung mit Hilfe von Grafiken und Diagrammen ................ - 36 6.6.1 Diagrammblätter erstellen ............................................................................... - 36 6.6.2 Eingebettete Diagramme erstellen .................................................................. - 37 6.6.3 Diagrammblätter gestalten .............................................................................. - 38 6.6.4 eingebettete Diagramme gestalten.................................................................. - 39 6.6.5 Diagrammblätter und Eingebettete Diagramme verwalten ............................ - 39 7 Weitergehende Informationen zur Verwendung von VBA ....................................................... - 40 7.1 Ähnliche Konzepte und Alternativen........................................................................... - 40 7.2 Der Makro Rekorder .................................................................................................... - 40 7.3 Das Sicherheitskonzept von Microsoft ........................................................................ - 41 -
8 Schlusswort ............................................................................................................................... - 41 9 Abbildungsverzeichnis ............................................................................................................... - 42 9.1 Deklaration von Variablen und Konstanten ................................................................ - 42 9.2 Einsatz von Arrays ....................................................................................................... - 43 9.3 Vorstellung des Collection-Objekts ............................................................................. - 44 9.4 Benutzerdefinierte Datentypen deklarieren und ansprechen .................................... - 44 9.5 Einsatz Prozeduren und Übergabeparametern ........................................................... - 45 9.6 Funktionen und ihre Rückgabeparameter .................................................................. - 46 9.7 Klassen und Objekte .................................................................................................... - 47 9.8 Die Excel Oberfläche.................................................................................................... - 48 9.9 Der VBA Editor ............................................................................................................. - 49 9.10 Anwendungsbeispiel für I/O Operationen ................................................................ - 50 9.11 SQL Operationen und ihre Auswertung .................................................................... - 51 10 Quellenverzeichnis .................................................................................................................. - 52 11 Eidesstattliche Erklärung ......................................................................................................... - 53 -
1
Allgemeine Informationen zu VBA
Das Skript startet inhaltlich mit allgemeinen Informationen zu VBA, mit denen der Leser sich vertraut
machen sollte. Es basiert darauf, dass der Leser ein gewisses Interesse an der Programmierung bzw.
der Programmiersprache zeigt. Dies impliziert somit nicht nur Wissen über Syntax und Anwendung,
sondern auch z.B. Eigenschaften sowie Einsatzgebiete der Sprache. Ohne Hintergrundinformationen
über eine Programmiersprache artet die Entwicklung einer Applikation schnell in das blinde
Auswendiglernen und Einfügen der Programmbefehle aus.
1.1 Geschichte und Anfänge der Sprache
Visual Basic for Applications (kurz: VBA) ist eine eng mit den Office Programmen assoziierte
Skriptsprache, welche aus dem von Microsoft entworfenen BASIC Dialekt Visual Basic entstanden ist.
Sie wurde zur Steuerung von Abläufen innerhalb der Office Programme konzipiert. Die Sprache wird
seit Mitte der 1990er Jahre verwendet und löste die bis dahin verwendeten verschiedenen Makro
Sprachen ab.
Unter dem Begriff Makro versteht man eine Abfolge von Befehlen, die sich zusammenhängend nach
nur einem Aufruf ausführen lassen. Im Skript wird der Begriff Makro mit VBA-Skripten oder VBAProgrammen gleichgesetzt.
1.2
Eigenschaften von VBA
VBA ist eine leistungsfähige Skriptsprache. Ihre Skripte werden zur Laufzeit interpretiert und
zusätzlich vorkompiliert, um Variablen und Konstantentabellen aufzubauen sowie syntaktische
Überprüfungen durchzuführen - es ist jedoch kein Kompilieren bis zu ausführbaren Maschinencode
hin möglich. Die Syntax von VBA ist stark an die Syntax von Visual Basic angelehnt. Die Sprache
unterstützt desweiteren keinerlei direkte Speicherzugriffe z.B. über Zeiger, Zeigerarithmetik und–
manipulation. VBA ist für die modulare Programmierung konzipiert, d.h. das durch VBA Skripte zu
lösende
„Problem wird in einzelne Module
Schnittstellenspezifikation aufweisen.“ 1
aufgeteilt,
die
jeweils
eine
genaue
VBA Programme werden somit in kleinere Bestandteile zerlegt, die übersichtlich sind und einfach
gewartet werden können. Eine genauere Betrachtung zum Einsatz kommender Modularten erfolgt
bei der Vorstellung der Entwicklungsumgebung für VBA in Kapitel 4.2. Mit der Zeit jedoch hat sich aus
einer recht einfachen Makro Sprache eine umfangreiche objektorientierte Sprache entwickelt:
Klassen und Objekte können syntaktisch dargestellt und implementiert werden. Ferner beherrscht
VBA das Prinzip der Datenkapselung und der Schnittstellenvererbung. Im Kontrast dazu unterstützt
die Sprache jedoch keine Implementierungsvererbung.
Eine direkte Ausführung der VBA Skripte ist nicht möglich – der Zugriff auf VBA (-Skripte) erfolgt über
eine vom jeweiligen Wirtsprogramm bereitgestellte Programmierschnittstelle (z.B. die
Entwicklungsumgebung).
1
Aus dem „Handbuch Programmiersprachen“, S.45
von Peter.A Henning und Holger Vogelsang
Allgemeine Informationen zu VBA | - 6 -
1.3 Verfügbarkeit / Einsatzgebiete
VBA wird standardmäßig in der Office Programmierung eingesetzt. Folglich können Entwickler die
Sprache in allen MS-Office Programmen, d.h. nicht nur in Word oder Excel, sondern z.B. auch in
Outlook, FrontPage oder Visio heranziehen. Es ist die am stärksten verbreitete Möglichkeit auf MS
Office basierende Programme zu erstellen. VBA ist überdies in Produkten der CorelCorporation wie
z.B. CorelDraw oder CorelPhoto zu finden. Darüber hinaus ist die Skriptsprache in vielen weiteren
Programmen als Makrosprache verfügbar z.B. MindManager oder AutoCAD. Dies ist darauf
zurückzuführen, dass Microsoft im Juni 1996 das „Microsoft Visual Basic for Applications licensing
program“ einführte, sodass alle unabhängigen Softwarehersteller, welche VBA in ihre Programme
integrieren wollten, Lizenzen dafür erwerben konnten. Nichtsdestotrotz entschied die Firma im Jahr
2007 jedoch Neukunden keine weiteren Lizenzen mehr anzubieten und das Lizenzprogramm
auslaufen zu lassen. Bereits bestehende Kunden können allerdings noch zusätzliche VBA Lizenzen
erwerben.
Allgemeine Informationen zu VBA | - 7 -
2 Syntax und Anwendung I – Der Sprachkern
Bevor es in den weiteren Kapiteln um VBA als Skriptsprache in der Office Programmierung geht,
sollte sich der Entwickler mit Syntax und Gebrauch des Sprachkerns von VBA vertraut machen. Der
Sprachkern von VBA beinhaltet eine Vielzahl elementarer Anweisungen zur Steuerung von Abläufen
bezüglich ihrer Programmlogik. Es wird zu Beginn auf grundlegende Anweisungen (genauer gesagt
die Deklaration von Variablen oder Anwendung von Operatoren), Datentypen und wichtige Objekte
eingegangen. Am Ende des Kapitels werden Unterprogrammtechnik und Fehlerbehandlung
eingeführt. Wie bereits im Vorwort angesprochen, dient das Kapitel als Kurzfassung, sodass eher auf
Syntax als auf tiefgreifende logische Konzepte geachtet wird.
2.1
Allgemeines
Im Gegensatz zu klassischen Programmiersprachen beispielsweise C/C++ oder Java fehlen die sonst
typischen Semikolons, welche das Ende einer Anweisung markieren. In VBA Skripten ist daher
prinzipiell pro Zeile nur eine Anweisung erlaubt. Der Einsatz von mehrzeiligen Anweisungen wird
durch das Einfügen von „ _“ (Leerzeichen + Unterstrich) am Ende einer Zeile gekennzeichnet.
Hochkomma (`) leiten Zeilenkommentare ein. VBA ist „Case insensitive“, d.h. zwischen Groß- und
Kleinschreibung wird bei Variablen und Methodennamen nicht unterschieden. Während in den
klassischen Programmiersprachen Escape-Sequenzen zur Darstellung von Steuerzeichen helfen,
bedient sich VBA sogenannter integrierter Konstanten, deren Einsatzzweck im weiteren Verlauf des
Kapitels vorgestellt wird.
2.2 Datentypen
VBA bietet für jeden Verwendungszweck den geeigneten Datentyp an. Die nachfolgende Tabelle
enthält die wichtigsten von VBA unterstützten Datentypen, sowie deren Speicherbedarf und
Wertebereich. Der Datentyp Variant ist ein universeller Datentyp, der sich automatisch den
zugewiesenen Daten anpasst. Er ist jedoch sehr speicheraufwändig und nicht optimal einzusetzen.
Datentyp
Speicherbedarf Wertebereich und Bedeutung
Boolean
Byte
Integer
Long
2 Byte
1 Byte
2 Byte
4 Byte
Single
4 Byte
Double
8 Byte
Date
Object
String
Variant
8 Byte
4 Byte
10 Byte (+)
16 Byte (+)
Wahrheitswert, kann den Wert „True“ oder „False“ annehmen
Ganze Zahl von 0 bis 255
Ganze Zahl von -32.768 bis 32.767
Ganze Zahl von -2,1 * 10^9 bis 2,1 * 10^9
Gleitkommazahl mit einfacher Genauigkeit von ca. -3,4 * 10^38 bis ca.
-1,4* 10^(-45) für negative und von ca. 1,4*10^(-45) bis 3,4 * 10^38 für
positive Werte
Gleitkommazahl mit doppelter Genauigkeit von ca. -1,8*10^308 bis 4,9*10^(-324) für negative und von ca. 4,9*10^(-324) bis 1,8*10^308
für positive Werte
Datumsangabe zwischen 1.Januar 100 und 31.Dezember 9999
Verweis auf ein Objekt
Zeichenkette mit variabler Länge
Datentyp nicht explizit festgelegt (universell)
Sprachkern | - 8 -
2.3
Operatoren
In VBA existieren vier verschiedene Typen von Operatoren, mit denen sich Variablen verknüpfen und
manipulieren lassen. Die folgende Zusammenstellung zeigt eine Auflistung der verschiedenen
Operatoren. Es gibt Arithmetische, Logische, Vergleichs-, und Verkettungsoperatoren.
Operator
Beschreibung
+
*
/
^
Mod
Addition
Subtraktion bei zwei Operanden, Negation bei einem Operand
Multiplikation
Division
Ganzzahldivision , zuerst werden die Operanden gerundet, dann dividiert und die
Nachkommastellen abgeschnitten
Potenzierung
Modulodivision
Operator
Beschreibung
<
<=
>
>=
=
<>
Like
Is
Kleiner als
Kleiner gleich als
Größer als
Größer gleich als
Gleich
Ungleich
Stringvergleich, kann auch Platzhalter (*) auswerten
Objektvergleich
Operator
Beschreibung
Not
And
Negation/Nicht: Das Ergebnis ist wahr, wenn der Ausdruck falsch ist.
Konjunktion/Und: Das Ergebnis ist wahr, falls beide Ausdrücke wahr sind.
Disjunktion/Oder: Das Ergebnis ist wahr, falls mindestens einer von zwei
Ausdrücken wahr ist.
Exklusives Oder: Das Ergebnis ist wahr, falls genau ein von zwei Ausdrücken wahr
ist.
Äquivalenz: Das Ergebnis ist wahr, falls beide Ausdrücke True oder False sind.
Implikation: ergibt false, falls aus einem wahren Ausdruck ein falscher folgt.
\
Or
Xor
Eqv
Operator
Beschreibung
&
Verkettet numerische und alphanumerische Inhalte zu einer neuen Zeichenkette
Verkettet numerische und alphanumerische Inhalte zu einer neuen Zeichenkette,
kann bei numerischen Ausdrücken schnell falsch verwendet werden, Vorsicht!
+
Sprachkern | - 9 -
2.4
Variablen, Konstanten und ihr Geltungsbereich
Variablen dienen auch in VBA als Platzhalter für Daten, die sich im weiteren Programmablauf
durchaus ändern können. Sie werden durch einen Namen und einen Datentyp identifiziert. Die
Deklaration und Initialisierung von Variablen erfolgt standardmäßig in zwei Schritten, die von
Konstanten in einem Schritt.
VBA unterscheidet zwischen expliziter und impliziter Variablendeklaration: Die explizite Deklaration
erzwingt die Bekanntmachung der Variable vor ihrem Einsatz, wogegen die implizite Deklaration
Variablen bei ihrer ersten Verwendung zur Laufzeit automatisch erzeugt. Letztere Einstellung kann
jedoch zu schwer auffindbaren Fehlern führen: Um eine explizite Deklaration zu fordern, müssen
Entwickler in einem VBA Modul die Anweisung „Option Explicit“ einsetzen. Zur verbesserten
Handhabung neuer Module fügt der VBA Editor diesen Befehl standardmäßig einem gerade neu
erstellten hinzu. Wird bei der Deklaration einer Variablen oder Konstanten kein expliziter Datentyp
angegeben, ordnet VBA automatisch den Typ Variant zu.
Zur Bekanntmachung von Variablen und Konstanten wird folgende Syntax verwendet:
Lokale Variablen:
o Dim [Name] (As [Datentyp])
`Deklaration
o [Name] = [Wert]
`Initialisierung
Modulebene: Die Initialisierung erfolgt in den Prozeduren eines Moduls
o (Sichtbarkeit) [Name] (As [Datentyp])
Konstanten:
o (Sichtbarkeit) Const [Name] (As[Datentyp]) = [Wert]
Abbildung 9.1 im Abbildungsverzeichnis liefert ein Codebeispiel, welches die einzelnen Möglichkeiten
der Variablendeklaration aufzeigt.
Der Geltungsbereich von Variablen unterscheidet sich je nach Deklarationsebene:
Auf
Prozedurebene deklarierte, lokale Variablen stehen nur in der jeweiligen Prozedur zur Verfügung,
während auf Modulebene deklarierte Variablen allen Prozeduren eines Moduls zur Verfügung
stehen. Ist eine Modulvariable mit dem Schlüsselwort „Public“ als öffentlich markiert, können
Prozeduren anderer Module diese Variable ebenfalls nutzen, defaultmäßig ist sie allerdings „Private“
und somit nur im aktuellen Modul verwendbar. Integrierte Konstanten sind systemdefinierte
Konstanten, welche vom Wirtsprogramm oder von VBA selbst bereitgestellt werden und spezielle
Funktionen aufweisen, z.B. repräsentiert die Konstante vbCrLf einen Zeilenumbruch.
Vorsilbe
Zugehörigkeit
Beispiel
vb
xl
mso
VBA
Excel
MS Office
vbRed: Farbe Rot
xlLine: Liniendiagramm
msoSortOrder: Sortierreihenfolge
Sprachkern | - 10 -
2.5
Arrays, dynamische Arrays und Collections
In der Programmiersprache VBA können Variablen zu Feldern, den Arrays, zusammengefasst werden.
Ihre Elemente werden intern durch einen fortlaufenden Index unterschieden und angesprochen.
Entwickler können Arrays bei der Deklaration eine feste Feldgröße zuweisen - alternativ können sie
die Felder aber auch dynamisch aufbauen. Dynamische Arrays können ihre Größe zur Laufzeit eines
Programmes je nach Bedarf ändern, dennoch müssen Programmierer bei der Veränderung der
Feldgröße darauf achten, dass VBA die gespeicherten Werte nicht mit Default-Werten überschreibt,
was standardmäßig der Fall wäre. Die Manipulation der Feldgröße wird durch den Befehl ReDim
eingeleitet. Das im Anschluss optionale Schlüsselwort Preserve verhindert das Überschreiben alter
Werte. Mehrdimensionale Felder werden in VBA ebenfalls unterstützt.
Syntaktisch bieten sich somit mehrere Alternativen zur Deklaration:
Standardvariante: Festgelegte Größe angeben, Indizes laufen von 0 bis Größe
o Dim [Name][Größe] (As [Datentyp])
Größe festlegen, aber den Laufindex beeinflussen
o Dim [Name][IndexAnf] To [IndexEnd] (As [Datentyp])
Dynamisches Feld anlegen
o Dim <Name>() As <Datentyp>
Dynamisches Feld vergrößern:
o ReDim (Preserve) [Name] [Größe]( As [Datentyp] )
In diesem Zusammenhang wird noch auf die Klasse Collection hingewiesen, welches Elemente
gleichen oder verschiedenen Typs mit thematischer Verwandtschaft in einer Liste zusammenfassen
kann. Ein Collection Objekt bietet mehrere Methoden zur Verwaltung dieser Liste an, z.B. Add() oder
Remove() zum Hinzufügen bzw. Löschen von Werten. Ihre Elemente sind ebenfalls über einen Index
ansprechbar.
Die Verwendung von Arrays und Collections in einem lauffähigen Programm werden durch die
Abbildungen 9.2 bzw. 9.3 im Abbildungsverzeichnis dargestellt.
2.6
Benutzerdefinierte Datentypen
Benutzerdefinierte Datentypen bieten ebenfalls die Möglichkeit, als Einheit zusammengehörende
Variablen zu einem größeren Datentypen zusammenzufassen - beispielsweise wenn Entwickler eine
Adresse bestehend aus Postleitzahl, Ort, Straße und Hausnummer simulieren wollen. Bestandteile
des neuen Datentyps können alle bekannten Datentypen sein, irrelevant ob Boolean, Array oder ein
anderer benutzerdefinierter Datentyp. Im Gegensatz zum Collection Objekt wird auf jedes Attribut
direkt über seinen Namen zugegriffen. Konzeptionell ähneln die benutzerdefinierten Datentypen
dem vielleicht aus C/C++ bekannten „struct“. Die Erzeugung eines neuen benutzerdefinierten
Datentypen erfolgt mit Hilfe des Schlüsselworts Type. Abbildung 9.4 im Abbildungsverzeichnis
untermauert die Erläuterungen.
Type [Name]
[Variablendeklarationen]
End Type
Sprachkern| - 11 -
2.7 Unterprogrammtechnik: Prozeduren, Aufruf, Parameterübergabe und
Optionale Argumente
Parallel zur Modularität seiner Programme ist VBA als prozedurale Programmiersprache entwickelt
worden, d.h.
„der auszuführende Programmcode ist in kleine, unabhängige Einheiten unterteilt, die sich
gegenseitig aufrufen können und Parameter zur Bearbeitung und Auswertung übergeben
können. Ist die Formulierung der Einheiten allgemein genug, können sie immer wieder in
unterschiedlichen Programmen benutzt werden.“.2
In VBA übernehmen diese Aufgabe Prozeduren und Funktionen. Prozeduren sind als kleinste
selbstständige Einheiten eines Programms zu verstehen und beinhalten eine Gruppe von
Anweisungen. Funktionen besitzen dieselbe Aufgabe, können im Gegensatz zu Prozeduren aber
einen Wert an die aufrufende Prozedur als Rückgabewert zurückgeben. Dieser wird innerhalb des
Funktionskörpers über die Anweisung
o
[Funktionsname] = [Wert]
zugewiesen. In VBA können sowohl Prozeduren als auch Funktionen Parameter übergeben werden.
Diese werden bei der Übergabe durch Kommata voneinander getrennt aufgelistet. Argumente
können entweder
o
o
als Kopie (Call-By-Value, Schlüsselwort „ByVal“)
oder
als Referenz (Call-By-Reference, Schlüsselwort „ByRef“)
übergeben werden. Standardmäßig übergibt VBA alle Parameter per Referenz. Optionale Argumente
werden durch das Schlüsselwort „optional“ gekennzeichnet. Analog zu Variablen können Funktionen
und Prozeduren bezüglich ihrer Sichtbarkeit „Public“ oder „Private“ sein. Prozeduren werden durch
den Rahmen
o
(Sichtbarkeit) Sub *Name+…End Sub
und Funktionen durch
o
(Sichtbarkeit) Function*Name+ *As Datentyp+…End Function
gekennzeichnet.
Ein übersichtliches Beispiel zur Syntax bezüglich Deklaration von Prozeduren und Funktionen sowie
dem Einsatz von Übergabeparametern befinden sich im Abbildungsverzeichnis unter Abbildung 9.5
und 9.6.
2
Sinngemäße Definition übernommen aus
ftp://ftp.fernuni-hagen.de/pub/pdf/urz-broschueren/broschueren/b012.pdf
Sprachkern | - 12 -
2.8 Klassen und Objektvariablen
In VBA lässt sich das Prinzip der Objektorientierung leicht wie in anderen Sprachen auch durch die
Erstellung und Verwendung von Klassen und ihren Methoden umsetzen. Die Deklaration und
Initialisierung eines Objektes einer Klasse erfolgt ebenfalls zweistufig – letztere wird durch
Verwendung des Schlüsselwortes „Set“ eingeleitet. Methoden, welche zum Setzen („Let“) und
Auslesen („Get“) von Attributen verwendet werden, werden durch das Schlüsselwort „Property“
gekennzeichnet. Klassen sind flexibler als benutzerdefinierte Datentypen, welche keine Methoden
besitzen und müssen – anders als die benutzerdefinierten Datentypen – in einem separaten
Klassenmodul bearbeitet werden. Der Name des Klassenmoduls entspricht dem Namen der neu
erzeugten Klasse. Aus diesem Grund entfallen in Klassenmodulen die beispielsweise aus C++
bekannten syntaktischen Einleitungen wie „Class XY ,… -“. Es enthält somit nur Attribute und
Methoden der Klasse. Eine Deklaration mehrerer Klassen innerhalb eines Moduls ist nicht möglich.
Ein Anwendungsfall, welcher im Anhang als Abbildung 9.7 gekennzeichnet ist, verdeutlicht die
Handhabung von Klassen in VBA.
2.9 Kontrollstrukturen: Entscheidungsstrukturen & Schleifenstrukturen
VBA bietet ebenso wie andere Programmiersprachen auch einen Pool an Kontrollstrukturen an.
Diese lassen sich nach Entscheidungs – und Schleifenstrukturen differenzieren. Die folgenden Listen
liefern eine Skizzierung der in VBA einsetzbaren Kontrollstrukturen:
2.9.1
Entscheidungsstrukturen:
Struktur/Syntax
Beschreibung
If [Bedingung] Then [Anweisung]
Else [Anweisung] End If
Fallunterscheidung in ihrer Standardform
Iif [Bedingung, Ausdruck1,Ausdruck2]
Kurzform der oberen Anweisung: Ist die
Bedingung wahr, wird Anweisung 1, sonst
Ausdruck2 ausgeführt
Select Case [Variable] Case [Ausdruck][Anweisung]
Case Else [Anweisung ]End Select
Einfacher und übersichtlicher als die IfAnweisung
Switch (Bedingung1, Ausdruck1,
*Bedingung2, Ausdruck2+,…)
Wertet eine Liste von n Bedingungen aus und
verarbeitet den Ausdruck der zutreffenden
Bedingung
Choose(Index, Ausdruck1, *Ausdruck2+,…)
Gibt in Abhängigkeit von Wert eines
ganzzahligen Indexes den Wert aus einer
Liste der Alternativen aus, dessen
Listenposition dem Indexwert entspricht
Sprachkern | - 13 -
2.9.2
Schleifenstrukturen:
Struktur / Syntax
While [Bedingung] [Anweisung] Wend
Do [While Bedingung]
[Anweisung]
Loop [While Bedingung]
For Zähler [Anfang] To [Endwert] [Step = 1]
[Anweisung]
Next [Zähler]
For Each [Element] in [Feld]
[Anweisung]
Next [Element]
With [Objekt]
[Anweisungen]
End With
Exit For / Exit Do
Beschreibung
Schleifenstruktur in ihrer Standardform
Führt Anweisung aus, solange oder bis die
Bedingung erfüllt ist, kann über Exit Do
vorzeitig verlassen werden, die
Prüfbedingung kann am Anfang oder am
Ende der Schleife erfolgen
Anzahl der Wiederholungen über einen
Zähler festgelegt, Zähler inkrementiert in
Höhe der Schrittweite
Anzahl der Durchläufe implizit durch Größe
der Gruppe festgelegt, speziell für Arrays und
Auflistungen
Schleife mit nur einem Durchlauf, kann
mehrere Eigenschaften eines Objekts
manipulieren, ohne dass jedes Mal der
Objektname angegeben werden muss
Ermöglichen das vorzeitige Verlassen der
Schleifenstruktur
2.10 Konvertierung und Manipulation von Daten
VBA bietet eine Menge Funktionen zur Manipulation von Daten an. Da hier nicht alle Funktionen
vorgestellt werden sollen, bietet die folgende Zusammenstellung eine grobe Übersicht über die am
häufigsten verwendeten Funktionen. Einige beschäftigen sich z.B. mit der Umwandlung und Analyse
von Datentypen, während andere Funktionen wiederum Strings bearbeiten können.
Funktion
Vartype()
CStr(), CInt(), CVar(),
CDbl(),…
RTrim(),LTrim(),Trim()
Left(), Right(), Mid()
InStr()
UCase() , LCase()
Split()
Replace()
Join()
Beschreibung
Liefert einen Integer Wert zurück, der Rückschlüsse auf den Datentypen
zulässt: Ist die Variable vom Typ Integer ist der Rückgabewert 2, bei
Double z.B. 5
Die C-XXX Methoden konvertieren beliebige Ausdrücke in den
gewünschten Datentyp.
Schneidet überflüssige Leerzeichen Rechts, Links bzw. an beiden Enden
einer Zeichenkette ab.
Lösen Teilketten der angegebenen Länge aus übergebenem String von
links, rechts oder der Mitte aus heraus. Bei Mid() muss zusätzlich noch
die Startposition angegeben werden.
Prüft, ob der übergebene Ausdruck in der aktuellen Zeichenkette vorliegt
und gibt einen Boolean-Wert zurück.
Führt Umwandlungen von Klein- in Großbuchstaben (U) oder umgekehrt
(L) durch.
Trennt eine übergebene Zeichenkette nach dem angegebenen Muster
auf. Als Rückgabewert erhält man ein Feld mit den Teilstrings (ohne
Trennmuster) zurück.
Ersetzt einen Ausdruck in einer Zeichenkette durch einen anderen.
Führt Zeichenketten mit dem Angegebenen Trennsymbol zusammen.
Sprachkern | - 14 -
2.11 Fehlerbehandlung
Zur Behandlung von (Laufzeit-)Fehlern dient dem Entwickler das Schlüsselwort
o
On Error: [Anweisung]
Nach dieser Anweisung kann man weitere Maßnahmen zur Fehlerbehandlung einleiten, z.B. die
Ausgabe eines Fehlertextes mit anschließendem Programmende. Meist kombiniert man die On Error
Anweisung mit der im Entwicklerumfeld eher unerwünschten Anweisung
o
GoTo [Marke]
welche in VBA jedoch noch frequentiert zur Fehlerbehandlung eingesetzt wird. Eine Beschreibung
des Fehlers erhalten Office Programmierer durch Aufruf der Eigenschaft „Description“ des
Fehlerobjekts „Err“:
o
Err.Description
Mit der Anweisung
o
Exit Sub
kann man, falls gewünscht, eine Prozedur vorzeitig verlassen, während mit dem Befehl
o
Resume Next
der Programmablauf nach Auftreten des Fehlers fortgesetzt werden kann. Entwickler sollten vor
allem im Umgang mit I/O Operationen oder Eingabeoperationen die Fehlerbehandlung nicht
unterschätzen, denn ein nicht bedachter oder übergangener Fehler kann schnell zu unerwünschten
Ergebnissen führen.
Sprachkern | - 15 -
3 Excel als Tabellenkalkulationsprogramm
Die aktuelle Passage soll Lesern, welche wenige oder keine Erfahrungen im Umgang mit Excel
aufweisen, das Programm vorstellen. Vor der Einsicht in Fähigkeiten und Bestandteile werden
allgemeine Informationen über das Programm vermittelt, derweil kommt am Ende des Kapitels die
logische Verknüpfung zwischen Excel und VBA zustande. Eine strukturierte bzw. detaillierte
Einführung der einzelnen Komponenten und Funktionen von Excel ist in diesem Kapitel aufgrund des
Umfangs nicht vorgesehen: Die sich durch VBA ergebenden Möglichkeiten zur Entwicklung einer
professionellen Excel Anwendung stellen diese im weiteren Verlauf des Skripts automatisch vor.
Außerdem soll Excel im Rahmen des Skripts nur als Inbegriff für ein mögliches Office Programm
fungieren, da sich viele Konzepte auf die Office Programmierung mit VBA verallgemeinern lassen.
3.1 Allgemeine Informationen zu Excel
Excel ist ein von Microsoft entwickeltes Programm zur Tabellenkalkulation. Als Tabellenkalkulation
wird
„eine Software für die interaktive Eingabe und Verarbeitung von numerischen und
alphanumerischen Daten in Tabellenform“ 3
bezeichnet. Es ist standardmäßig ein Teil des ebenfalls von diesem Unternehmen herausgegebenen
MS Office Paketes. Die zuletzt veröffentlichte Version ist Excel 2010 und ist aktuell eines der
bekanntesten Tabellenkalkulationsprogramme. Vorgängerversionen wie Excel 2007 und sogar Excel
2003 sind zurzeit noch weit verbreitet.
3.2
Fähigkeiten und Bestandteile von Excel
Excel bietet dem Anwender viele Möglichkeiten zur Datenkalkulation, -analyse und deren
Präsentation. Sortier- und Filterfunktionen unterstützen ihre Auswertung, während Diagramme zur
graphischen Veranschaulichung solcher Informationen dienen können. Excel beherrscht diverse
Zahlenformate, die den Umgang mit spezifischen Größen z.B. Datum und Uhrzeit oder Postleitzahlen,
erleichtern. Die Kalkulation von Daten als Kernaufgabe von Excel wird durch den gezielten Einsatz
von Formeln und Funktionen bestimmt. Die Berechnung des BMI nach Angabe von Gewicht und
Körpergröße wäre ein typischer Fall für den Verwendungszweck einer Formel in Excel. Weitere
Funktionen ermöglichen den Import von Daten aus externen Datenquellen z.B. CSV oder XML
Dateien und Datenbanken. Die Interaktion mit dem Benutzer kann durch Einfügen von Dialogen und
Formularsteuerelementen aufgewertet und belebt werden. Excel weist - genauso wie alle anderen
Office Anwendungen - eine VBA-Schnittstelle zur Bearbeitung und Ausführung von VBA Makros auf.
3
http://de.wikipedia.org/wiki/Tabellenkalkulation
Excel als Tabellenkalkulationsprogramm| - 16 -
3.3
Vorteile des Einsatzes von VBA
Warum sollte man VBA nun bei der Entwicklung einer Excel- (und somit auch Office-) Anwendung
nutzen?
Theoretisch ist es leistbar, die überwiegende Anzahl an Aufgaben manuell oder mit reinen Excel
Funktionen zu lösen. Beherrscht man als Entwickler einer Excel Anwendung jedoch die
Programmiersprache VBA, ermöglicht das aus einem reinen Tabellenkalkulationsprogramm ein noch
mächtigeres Entwicklungssystem zu erzeugen. Durch eine gezielte und professionelle Anwendung
von VBA Skripten bietet sich die Gelegenheit, eine Excel-Anwendung relativ einfach an die eigenen
Bedürfnisse anzupassen und zusätzlich die in der Anwendung benötigten Fähigkeiten von Excel
optimal einzusetzen. Mit Hilfe von VBA Skripten können benutzerdefinierte Abläufe und Lösungen
für Problemstellungen festgelegt und im Hintergrund automatisiert werden: Ein Anwendungsfall
wäre das Einlesen von Daten aus einer Textdatei, deren Aufbau, aber nicht deren Menge, bekannt
ist, weil die einzulesenden Daten bestimmten Bedingungen unterliegen. Aus diesem Beispiel lässt
sich ebenfalls schließen, dass die Sprache Aufgaben lösen kann, für die reine Excel Funktionen (z.B.
Formeln) nicht ausreichen oder einen viel zu hohen Mehraufwand erfordern.
Das Excel Programm des Anwenders kann durch den Einsatz von VBA somit gezielt erweitert werden,
da ihm zusätzliche Funktionen und Abläufe zur Verfügung stehen, aber auch zur Vermeidung von
Fehlbedienungen eingeschränkt werden.
Betrachtet man von betrieblicher Seite aus den Kostenaspekt, so fällt sicherlich auf, dass man keine
weiteren Lizenzgebühren für die Nutzung der Programmiersprache bezahlen muss: Alle Firmen, die
das MS Office Paket nutzen, mussten bereits Lizenzgebühren für das Office Paket entrichten, in dem
die Programmiersprache längst fester Bestandteil ist. Diese Kostenersparnis wird damit gerade für
kleine und mittlere Unternehmen lukrativ, welche Ausgaben für zusätzliche Software, Schulungen
oder vielleicht sogar Hardware meiden wollen. Viele Softwareentwickler und Anwender sind
schließlich schon das MS Office Paket (oder ähnliche Office Pakete) gewohnt, sodass die Arbeit,
irrelevant ob Entwicklung oder Anwendung, in einer vertrauten Umgebung stattfinden kann. Dies
kann sogar u.U. die Produktivität erhöhen.
Excel als Tabellenkalkulationsprogramm | - 17 -
4 Der Arbeitsbereich von Excel und die Entwicklungsumgebung für
VBA
Im Vorwort des vorherigen Kapitels wurde schon erwähnt, dass der sichere Umgang mit dem
Arbeitsbereich des Office Programms und der Entwicklungsumgebung von VBA entscheidend für die
Office Programmierung ist. Ist man als Entwickler über wesentliche Elemente des Arbeitsbereiches
im Bilde, begreift man auch schnell den Einsatz elementarer VBA Objekte und Funktionen.
Da im Skript Excel herangezogen wird, schließt sich dem Vorwort eine Vorstellung des
Arbeitsbereiches von Excel 2007 an, während im Anschluss dazu auf die Entwicklungsumgebung für
VBA, den VBA Editor, eingegangen wird.
4.1 Der Arbeitsbereich von Excel
Der maßgebliche Arbeitsbereich von Excel besteht aus den sog. Arbeitsmappen. Diese enthalten im
Register angeordnete Tabellenblätter, deren Inhalt angezeigt werden kann. Tabellenblätter
wiederum bestehen aus Zellen, die Daten speichern. In Excel wird die Tabelle in Zeilen und Spalten
eingeteilt, sodass jede Zelle über eine Kombination aus Buchstabe (Spalte) und Zahl (Zeile) eindeutig
identifiziert werden kann - das Zellbezugssystem. Im oberen Bereich befindet sich die Menüleiste mit
ihren zahlreichen Funktionen. Bild Nummer 9.8 im Abbildungsverzeichnis liefert eine visuelle
Darstellung des Arbeitsbereiches.
4.2
Vorstellung des VBA Editors:
Zur Entwicklungsumgebung für VBA, den VBA Editor, gelangt man
o
o
über die Tastenkombination Alt-F11
oder - seit Office 2007 - auch über
die Auswahl von Entwicklertools  Visual Basic in der Menüleiste.
Daraufhin öffnet sich der VBA Editor als neues Fenster.
Prinzipiell ist die IDE ein eigenständiges Programm mit Fenstersystem und Symbolleisten, trotzdem
jedoch nur über oben genannte Methoden zu erreichen. Sie besteht aus mehreren Komponenten,
die in den weiteren Abschnitten vorgestellt werden. Zur visuellen Unterstützung ist Abbildung 9.9 im
Anhang vorzufinden.
Der Arbeitsbereich von Excel und die Entwicklungsumgebung für VBA | - 18 -
4.2.1 Projekt Explorer
Der Projektexplorer stellt eine Überschau der aktuell verwendeten Module in Form einer
Baumstruktur zur Verfügung. Baut das Projekt auf mehreren Arbeitsmappen auf, werden sie
untereinander aufgelistet. Module dienen als „Container“ für bereits erstellten Programmcode. Wie
in der Einleitung bereits erwähnt, weisen Module eine Schnittstellenspezifikation auf – VBA
unterscheidet zwischen vier Arten von Modulen:
4.2.1.1 Office Objekte
Hier werden alle Module aufgelistet, die bereits von Beginn an zur Office Anwendung selbst gehören.
Im VBA Editor für Excel Anwendungen erscheint die Beschreibung „Microsoft Excel Objekte“ und es
folgt eine Auflistung aller zur aktuellen Arbeitsmappe gehörenden Tabellen inklusive eines Verweises
auf die aktuelle Arbeitsmappe selbst („DieseArbeitsmappe“). Tabellen und Dokumenten kann
nämlich auch VBA Code zugewiesen werden. Module aus diesem Teilbereich werden vor allem im
Zusammenspiel mit Ereignissen (Kapitel 5.2 und 5.9, Syntax und Anwendung II) interessant.
4.2.1.2 Formulare
Im Bereich Formulare werden alle Module aufgelistet, welche sich mit benutzerdefinierten Dialogen
und Formularen (GUI) befassen. Näheres zu benutzerdefinierten Dialogen und Formularen ist in
Kapitel 5.8.3 nachzulesen.
4.2.1.3 Klassenmodule
In diesem Ordner werden alle Module abgelegt, welche Programmcode für selbst erstellte Klassen
beinhalten.
4.2.1.4 Module
Hier werden alle anderen allgemeinen Module abgelegt, welche nicht einer o.g. Spezifikation
entsprechen. Enthaltene Prozeduren und Variablen sind für die direkte Ausführung in Excel oder
Verwendung in anderen Modulen vorgesehen.
4.2.2 Eigenschaftenfenster
Das Eigenschaftenfenster dient als Übersicht über die Eigenschaften (Attribute) des aktuell
ausgewählten Moduls und erleichtert ihre Modifikation. Im Bereich der Formulare wird das
Eigenschaftenfenster frequentiert verwendet.
4.2.3 Programmeditor
Das Codefenster dient sowohl zur Eingabe neuen Programmcodes als auch zur Vorschau bereits
bestehenden Programmcodes für das aktuell ausgewählte Modul. Zusätzlich wird im
Programmeditor die Gestaltung von Dialogen und Formularen vorgenommen.
4.2.4 Direktfenster
Das Direktfenster kann bei der Entwicklung von Modulen zu Testzwecken und zum Debugging
genutzt werden. Funktionen lassen sich dort direkt aufrufen und ausführen. Zusätzlich erscheinen
alle Ausgaben im Direktfenster, welche mit Hilfe der Anweisung
o
Debug.Print [text]
im Programmcode angegeben wurden. Das Direktfenster ist standardmäßig ausgeblendet und muss
unter
o
Ansicht  Direktfenster
erst manuell aktiviert werden.
4.2.5 Objektkatalog / IntelliSense
Der Objektkatalog enthält eine Auflistung aller durch VBA nutzbaren bzw. verfügbaren Objekte. Er
dient als Nachschlagewerk. Im linken Teilfenster erscheint eine Liste der Klassen, im rechten die zu
einer markierten Klasse gehörenden Attribute und Methoden. Der Objektkatalog wird über
o
Ansicht  Objektkatalog
eingeblendet.
Eng mit dem Objektkatalog verknüpft ist die Eigenschaft des VBA Editors, während der Eingabe von
Programmcode eine Liste mit Methoden und Eigenschaften für das aktuell ausgewählte Objekt
vorzuschlagen. In der von Microsoft bereitgestellten Entwicklungsumgebung Visual Studio wird diese
Fähigkeit als IntelliSense bezeichnet. Der Begriff hat sich im Programmierumfeld für ähnliche
Funktionen etabliert und wird somit auch hier übernommen.
5
Syntax und Anwendung II – VBA im Zusammenspiel mit Excel
VBA-Skripte sind nur im Zusammenspiel mit ihren Wirtsanwendungen sinnvoll. Demgemäß lassen
sich auch mit dem Sprachkern alleine keine zweckmäßigen Makros entwickeln. Wirtsprogramme
bieten VBA jedoch spezifische Objekte und Funktionen an, auf die es zugreifen kann. Dank dieser
Objekte kann eine Interaktion zwischen VBA Skript und Wirtsprogramm realisiert werden.
Im Verlauf des Kapitels werden Excel Objekte eingeführt und vorgestellt. Neben den Excel Objekten
wird auch auf Formularsteuerelemente eingegangen, welche für den Entwurf von Dialogen und
Formularen bedeutsam sind. In diesem Zusammenhang werden auch die im vorherigen Kapitel
erwähnten Ereignisse wichtig. Am Ende des Abschnitts sollten Leser ihre Anwendung verstehen und
somit schon recht fortgeschrittene VBA-Makros implementieren können.
5.1 Allgemeine Informationen
Vorausschauend lässt sich sagen, dass viele Operationen bzw. Problemstellungen auf verschiedenste
Weise mit jeweils anderen Methoden und Objekten gelöst werden können, denn die VBA-Excel
Bibliothek ist groß. Da der Titel dieses Skripts „Einführung in die Programmiersprache VBA und
Einführung in die Office Programmierung“ lautet, stehen hier Einfachheit und Verständlichkeit im
Vordergrund. Effektive oder stilgerechte Programmierung ergeben sich mit der Zeit durch praktische
Anwendung des Erlernten. Aus diesem Grund wird also nicht der gesamte Befehlssatz von VBA-Excel
detailliert vorgestellt, sondern nur die intuitivsten oder am häufigsten verwendeten Anweisungen.
Im Zweifelsfalle helfen Objektkatalog, IntelliSense oder Foren aus dem Web weiter.
5.2
Ereignisse
In der Office Programmierung sind die sog. Ereignisprozeduren, kurz Ereignisse, von grundlegender
Bedeutung: Diese Prozeduren werden unter bestimmten Voraussetzungen automatisch aufgerufen ohne dass der Benutzer zwingend etwas davon bemerkt. Genauer betrachtet wird
o
das [Workbook-]Ereignis Workbook_Open()
ausgelöst, sobald der Nutzer in Excel eine neue Arbeitsmappe öffnet. Es dient im Zusammenhang als
Beispiel für bereits „integrierte“ Ereignisprozeduren. Der im Skript häufiger auftauchende Zusatz
„integriert“ ist kein feststehender Begriff – er wird hier zur verbesserten Beschreibung des
Prozedurcharakters verwendet, denn diese Ereignisprozeduren wurden implizit schon angelegt,
erhalten aber ohne manuelle Implementierung keinerlei zusätzliche Funktionalität. Von diesem
Ereignistyp wurden bereits viele angelegt, deren jeweilige Bezeichnung sich auch im Objektkatalog
nachschlagen lässt. Neben den integrierten Ereignissen können in Klassenmodulen auch neue
Ereignisse angelegt und ausgelöst werden. Eine genauere Betrachtung der Ereignisprozeduren ergibt
sich im weiteren Skriptverlauf automatisch, denn Ereignisprozeduren sind nur sinnvoll einzusetzen,
sobald der Umgang mit Excel Objekten und Dialogen vergegenwärtigt wurde.
Excel Objekte und Interaktion mit dem Nutzer| - 21 -
5.3
Excel Objekte
Neben dem Sprachkern (vorgestellt in Kapitel 2, Syntax und Anwendung I ) kann VBA auf spezielle
Objekte, Methoden und integrierte Konstanten zugreifen, die sich auf die jeweilige OfficeAnwendung beziehen. Die aufgeführte Abbildung liefert einen Auszug elementarer Objekte in Excel.
Objekt
Beschreibung
Application
Hauptobjekt, repräsentiert die Anwendung selbst
Workbooks
Auflistung aller zur Anwendung gehörenden Arbeitsmappen
ActiveWorkbook
Auflistung aller zur aktuellen Arbeitsmappe gehörenden
Tabellenblätter
Auflistung aller zur aktuellen Arbeitsmappe gehörenden
Diagrammblätter
Die aktuell aktive Arbeitsmappe
ActiveSheet
Das aktuell aktive Tabellenblatt
ActiveCell
Die aktuell aktive Zelle
ActiveChart
Das aktuell aktive Diagrammblatt
Worksheets
Charts
Cells(Zeile,Spalte)
Die Arbeitsmappe mit dem aktuell ausgeführten VBA Code, muss nicht
die aktive Arbeitsmappe sein
Das Tabellenblatt in welcher die aktuell ausgeführte Prozedur steht,
muss nicht das aktive Tabellenblatt sein
Repräsentiert eine Zelle
Range
Repräsentiert einen Zellverbund
Selection
Repräsentiert selektierten (markierten) Zellverbund
ActiveSheet.UsedRange
Repräsentiert den aktuell verwendeten Platz in der Tabelle
ThisWorkbook
ThisWorksheet
5.4 Aktionen auf Tabellenblättern und Arbeitsmappen
Im Zusammenspiel zwischen VBA und Excel kommt es immer wieder vor, dass die Anwendung im
Hintergrund automatisch auf Arbeitsmappen oder Tabellen zugreifen muss. Ereignisse können hier
u.U. eine wichtige Rolle spielen, denn die Sprache bietet in diesem Teilbereich mehrere integrierte
Ereignisse an, welche Entwickler manuell implementieren können. Neben den Ereignissen bieten VBA
und Excel einfache Funktionen zur Manipulation von Tabellenblättern und Arbeitsmappen an, von
denen die grundlegenden in der nächsten Tabelle aufgeführt sind: Bei der Vorstellung von Methoden
und Eigenschaften werden im weiteren Verlauf des Kapitels Anwendungsfälle aufgeführt und der
ausschlaggebende Befehl jeweils entsprechend hervorgehoben.
Methode / Beispiel
Beschreibung der Funktionalität
Ereignisprozedur
Workbooks(„Mappe1.xslm”).Activate
Aktiviert eine Arbeitsmappe.
Workbook_Activate
Workbooks(“Mappe1.xslm“).Close
Schließt eine Arbeitsmappe
Workbooks.Open “Mappe1.xslm”
Öffnet eine Arbeitsmappe
ActiveWorkbook.Name
Namen einer Arbeitsmappe
ActiveWorkbook.Save
Sichert eine Arbeitsmappe
Worksheets(“Tabelle1”).Activate
vollständigen Pfad einer
Arbeitsmappe
Sichert eine Arbeitsmappe unter
anzugebendem Pfad ab
Aktiviert ein Tabellenblatt
Range(„A2:D2“).Select
Zellbereich auswählen
Worksheets(“Tabelle1”).Select
Aktiviert ein Tabellenblatt und
holt es in den Vordergrund
Worksheets.Add
Neues Tabellenblatt hinzufügen
ThisWorkbook.Path
ThisWorkbook.SaveAs
Worksheets(“Tabelle1”).Move
after/before:= Worksheets(“Tabelle2”)
Worksheets(“Tabelle1”).Visible
Workbooks/Worksheets.Count
Workbook_Open
Worksheet_Activate
Workbook_NewSheet
Verschiebt ein Tabellenblatt
Sichtbarkeit der Tabelle
Anzahl der zur Anwendung
gehörenden Arbeitsmappen bzw.
zu der Arbeitsmappe
gehörenden Tabellen
5.5 Manipulation von Zellen und Zellbereichen
Da Excel ein Tabellenkalkulationsprogramm ist, kann der Entwickler auf ein vielfältiges Arsenal an
Methoden und Objekten zurückgreifen, welche die Manipulation von Zellen und Zellbereichen zum
Ziel haben, sei es die Selektion oder das Einfügen von Zellen oder das Füllen der Zellen mit Inhalt
oder Formaten. Einen Auszug mit wichtigen Methoden liefert die nun aufgeführte
Zusammenstellung.
Methode / Beispiel
Range(„A5“).Value
ActiveCell.Formula
Cells(3,3).Cut Destination:=Cells(2,3)
ActiveCell.Copy Destination:=Range(“C4”)
Zum Setzen oder Auslesen des Inhalts der
ausgewählten Zelle
Zum Setzen oder Auslesen der Formel einer
ausgewählten Zelle
Schneidet den Inhalt einer Zelle aus und fügt ihn
in einer anderen Zelle ein
Kopiert den Inhalt einer Zelle und fügt ihn in
einer anderen Zelle ein
ActiveCell.Row / Column
Liest Reihe bzw. Spalte einer Zelle aus
Cells(1,2).EntireRow/EntireColumn
Selektiert die gesamte Reihe/Spalte
ActiveSheet.UsedRange
.SpecialCells(xlCellTypeLastCell)
Spricht spezielle Zellen an, beispielsweise hier die
Letzte verwendete
ActiveCell.EntireRow/EntireColumn
.Insert Shift:=xlToRight/xlDown
fügt eine Reihe/Spalte hinzu
ActiveCell.Clear
ActiveCell.Delete
ActiveCell.AddComment
Range(“A1:E4”).Find(“test”).Value
Range(“A1:E4”).Find(“test”).Address
IsNumeric
IsDate
Convert (Range(“A4”).Value, “km”, “mi”)
ActiveSheet.Sort
Range(“A1:A3”).NumberFormatLocal
= “#.##0,00€”
Cells(1,1).FormulaLocal =
"=Wennfehler((Summe(L" & j & "/C" & j & "));0)"
Löscht den Inhalt der Zelle
Löscht die gesamte Zelle und verschiebt somit
auch das gesamte Tabellenblatt
Fügt einer Zelle einen Kommentar hinzu
Prüft, ob im selektierten Bereich eine Zelle mit
angegebenem Inhalt zu finden ist, und gibt ihren
Wert zurück.
Prüft, ob im selektierten Bereich eine Zelle mit
angegebenem Inhalt zu finden ist, und gibt ihre
Adresse zurück.
Überprüft den Inhalt einer Zelle auf numerische
Inhalte
Überprüft ob der Inhalt der Zelle vom Datentyp
Date ist
Liefert eine Reihe von Umrechnungen für
physikalische Einheiten, exemplarisch eine
Umrechnung des Wertes aus Zelle A4 von
Kilometer in Meilen
Sortiert den angegebenen Bereich des
Tabellenblatts nach übergebenem Muster
Zellen formatieren
Fügt eine Excel Formel ein
(deutsche Schreibweise und absoluter Bereich)
5.6 Layout von Zellen vordefinieren
Das Erscheinungsbild jeder Anwendung sollte der Aufgabenstellung entsprechend angemessen sein.
Desweiteren fördert ein gutes Layout die intuitive Bedienung eines Programms. Zellen von Daten,
welche kritische Grenzen über- oder unterschreiten, mit roter Farbe als Warnsignal zu unterlegen
kann beispielsweise die Benutzerführung vereinfachen. Die Layoutgestaltung von Tabellen in Excel
kann recht einfach mit Hilfe von VBA gehandhabt werden. Formatiert werden können u.a.
Schriftentyp, Rahmen, Farbe, Höhe und Breite einer Zelle. Farben können entweder über einen
ColorIndex, über ein RGB-Objekt oder über integrierte Konstanten zugewiesen werden. Eine Liste
zeigt die gängigsten Formatierungsmöglichkeiten auf.
5.6.1
Formatierung der Schrift
Methode/Beispiel
Range(„A1:E3“).Font.Size = 12
Range(„A1:E3“).Font.Italic = true
Range(„A1:E3“).Font.Bold = true
Range(„A1:E3“).Font.name = “ComicSansMS”
Größe der Schrift
Ausgabe in kursiver Schrift
Ausgabe in fetter Schrift
Schriftstyle ändern
Ausgabe der Schrift in Farbe (Angabe mit Hilfe einer
Integrieren Konstanten)
Ausgabe einer Schrift in Farbe (Angabe abhängig
von der Farbpalette in Excel, Index 1-56)
Ausgabe in tiefgestellter Schrift
Ausgabe in hochgestellter Schrift
Ausgabe unterstrichen
Range(„A1:E3“).Font.Color = vbRed
Range(„A1:E3“).Font.ColorIndex = 52
Range(„A1:E3“).Font.Subscript = true
Range(„A1:E3“).Font.Superscript = true
Range(„A1:E3“).Font.Underline = true
5.6.2
Formatierung von Rahmen
Methode / Beispiel
Range(“A1:C8”).Borders
Wählt den Gesamtrahmen aus
Range(“A1:C8”).Borders(Index)
Range(“A1:C8”).BorderAround
Range(“A1:C8”).Borders.LineStyle
Range(“A1:C8”).Borders.Weight
Range(“A1:C8”).Borders.ColorIndex = 52
Range(“A1:C8”).Borders.Color = vbYellow
Ordnet einen Teilrahmen über den Indexwert zu.
Zulässig sind die Konstanten xlTop, xlBottom, xlLeft,
und xlRight. xlNone löscht den Rahmen.
Erstellt einen Rahmen um den angegebenen
Zellbereich.
Ordnet die Rahmenart zu. Es können die Konstanten
xlContinous, xlDash, xlDouble, xlDot und xlNone
angegeben werden
Definiert die Dicke des Rahmens. Möglich sind
xlThick, xlMedium, xlThin und xlHairline
Bestimmt die Farbe des Rahmens abhängig von der
Farbpalette in Excel
Bestimmt die Farbe des Rahmens anhand einer
integrierten Konstanten
5.6.3
Formatierung der Zelle
Methode / Beispiel
ActiveCell.Interior.ColorIndex = 52
ActiveCell.Interior.Color = RGB(125,200,100)
Selection.Columns.AutoFit
Selection.Rows.AutoFit
5.7
Füllt die Zelle mit einer Farbe aus der Farbpalette
von Excel
Alternativ zu integrierten Konstanten kann die
Farbzuordnung auch durch Angabe eines RGB
Objektes erfolgen
Passt die Spaltenbreite der aktuell ausgewählten
Zelle(n) an.
Passt die Zeilenhöhe der aktuell ausgewählten
Zelle(n) an
Filterfunktionen
Sowohl für die Präsentation als auch für die bessere Übersicht von Datensätzen bietet Excel eine
Reihe von Filterfunktionen, die auch in VBA genutzt werden können. Grundsätzlich ist es möglich, alle
in einer Tabelle befindlichen Daten nach verschiedensten Kategorien zu filtern. Präziser formuliert
gibt es nicht nur Text- oder Zahlenfilter, sondern auch Datumsfilter oder zusammenhängende Filter
mit mehreren Bedingungen. VBA verwendet für die Automatisierung und Konfiguration von
Filtervorgängen das AutoFilter Objekt:
Methode / Beispiel
ActiveSheet.UsedRange…
.AutoFilter [Spalte],[Bedingung]
.AutoFilter
.AutoFilter 6,“>20“
.AutoFilter 1, „>=2010/1/22“
.AutoFilter 6, „Test1“ ,xlOr, „42“
.AutoFilter 6, „<=99“ , xlAnd , „<>12“
.AutoFilter 2, „*wild*“
.AutoFilter 4, „rwth“
.AutoFilter 5, „fh“
Vorbereitend den verwendeten Tabellenbereich
ermitteln…
Grundlegende Syntax
Löscht den aktuell definierten Filter
Beispiel für einen einfachen Zahlenfilter, abhängig von
einer Spalte und einer Bedingung.
Beispiel für einen einfachen Datumsfilter. Verwendet wird
die amerikanische Schreibweise
Beispiel für eine Mehrfachbedingung innerhalb einer
Spalte, durch Oder verknüpft
Beispiel für eine Mehrfachbedingung innerhalb einer
Spalte, durch Und verknüpft
Bei Textfiltern ist es möglich mit Platzhaltern (*) zu
arbeiten um Teilzeichenketten zu filtern
Beispiel für einen doppelten Filter, abhängig von zwei
Spalten und zwei Bedingungen. Lässt sich beliebig
erweitern.
5.8 Dialoge und Formulare zur Interaktion mit dem Benutzer
Dialoge dienen zur Interaktion mit dem Benutzer. Aus ihrer Hilfe soll eine komfortable und deutliche
Benutzerführung resultieren. Nicht nur als Warn- oder Statusmeldung werden Dialoge in VBA
verwendet. Häufig unterstützen sie auch die Eingabe von Daten in vorformatierte Formulare. In VBA
existieren mehrere Arten von Dialogfeldern, die integrierten Dialogfelder und die
benutzerdefinierten Dialoge bzw. Formulare. Zusätzlich kann man mit Hilfe von Steuerelementen
und passenden Formatierungen das Tabellenblatt als Formular gestalten.
5.8.1 Integrierte Dialogfelder
Als integrierte Dialogfelder werden diejenigen Dialoge bezeichnet, welche für spezielle Aufgaben
schon präpariert und konzipiert worden sind. An ihrer Gestaltung lässt sich kaum etwas verändern,
wohl aber die Reaktion auf Benutzereingaben. Integrierte Konstanten kommen bei der Erzeugung
dieser Dialoge recht häufig als Funktionsparameter zur Anwendung. Zu den integrierten
Dialogfeldern zählen exemplarisch die Message Box, die Input Box oder auch der Speichern UnterDialog.
5.8.1.1 Die Message Box
Message Boxen dienen zur Ausgabe von einfachen Status- oder Warnmeldungen. Mögliche
Reaktionen des Benutzers können durch Auswahl integrierter Konstanten gesteuert werden:
Beispielsweise lassen sich die anzuzeigenden Buttons (Ok, Abbrechen, etc.) einstellen, sowie
Statusmeldungen visuell unterstützen (Ausrufezeichen, Fragezeichen,…). Die Auswahl eines
speziellen Buttons durch den Benutzer kann ebenfalls mit Hilfe von Konstanten ausgewertet werden.
Die allgemeine Syntax zum Aufruf einer Message Box ist
o
[Benutzerauswahl] = MsgBox [Ausgabetext, Aussehen und Verhalten, Titel]
und lässt folgende Konstanten im Bereich Aussehen und Verhalten zu, welche sich auch durch den +
Operator oder Or-Operator sogar kombinieren lassen:
Konstante
Bedeutung
vbAbortRetryIgnore
Drei Buttons: Abbrechen, Wiederholen, Ignorieren
vbCritical
Bild, das eine kritische Warnung visuell unterstützt
vbInformation
Legt fest, welcher Button ausgeführt wird, sobald der
Benutzer nur die Enter-Taste betätigt.
Bild, das einen Hinweis mit einem Ausrufezeichen
visuell unterstützt
Infozeichen
vbQuestion
Fragezeichen
vbRetryCancel
Zwei Buttons: Wiederholen, Abbrechen
vbDefaultButton1 [2,3]
vbExclamation
vbSystemModal
vbApplicationModal
vbYesNo
Dialogfeld bleibt immer im Vordergrund, auch wenn der
Benutzer die Anwendung wechselt
Die Anwendung kann nur fortgesetzt werden, wenn der
Dialog beendet wird. Andere Anwendungen sind nicht
betroffen.
Zwei Buttons: Ja, Nein
Konstante zur Auswertung der Benutzerauswahl
Bedeutung
vbOk
vbNo
vbCancel
vbRetry
vbAbort
vbYes
vbIgnore
Ok-Button bestätigt
Nein-Button
Abbrechen-Button
Wiederholen-Button
Abbruch-Button
Ja-Button
Ignorieren-Button
Die oben aufgeführten Konstanten können verwendet werden, um nach einer spezifischen Aktion
des Benutzers unterschiedliche Maßnahmen in die Wege zu leiten.
5.8.1.2 Die Input Box
Die Input Box nimmt Eingaben eines Benutzers entgegen. Beim Aufruf unterscheidet man zwischen
zwei Varianten:
o
[Eingabewert] = InputBox [Eingabetext,[Titel, Defaultwert, xpos, ypos]]
Diese Variante ermöglicht die Angabe eines Default-Wertes und gibt die Eingabe als String zurück an
die aufrufende Prozedur. Nutzt der Anwender den Abbrechen-Button, wird eine leere Zeichenkette
zurückgegeben.
o
[Eingabewert] = Application.InputBox(Eingabetext,[Titel,Defaultwert ,Left, Top, Type])
Diese Funktion lässt zusätzlich noch die Formatierung und Prüfung einer Eingabe zu. Als Typ dienen
z.B. Zahl, Formel, Text oder Zellbezug, die jeweils durch einen Integerwert repräsentiert werden. Falls
der Benutzer auf den Abbrechen-Button klickt, wird false zurückgegeben, sonst entspricht der
Rückgabewert dem eingestellten Format.
5.8.1.3 Speichern Unter Dialog
Hinter diesem Dialog verbirgt sich das klassische „Speichern unter…“ Menü. Es lassen sich u.a. ein
Standarddateiname und Dateityp festlegen. Er wird hier repräsentativ für alle weiteren integrierten
Dialoge aufgeführt, welche sich mit Hilfe des Befehls
o
Application.Dialogs(Konstante).Show([Parameter])
aufrufen lassen:
Integrierte Konstante
xlDialogOpen
xlDialogSaveAs
xlDialogPatterns
xlDialogFontProperties
xlDialogSendMail
Beschreibung
Datei öffnen-Dialog
Speichern Unter-Dialog
Farbauswahl-Dialog
Schriftauswahl-Dialog
Öffnet ein Fenster zum Versenden von Emails. Das Aussehen ist
abhängig vom Standard Email-Client.
5.8.2 Das Tabellenblatt als Formular gestalten [Formular-/ActiveX Steuerelemente]
Neben den im vorherigen Kapitel vorgestellten integrierten Dialogfeldern bieten Excel und VBA noch
weitere Dialogformen an: Das Positionieren von Steuerelementen in Tabellenblättern ermöglicht die
Gestaltung von Formularen. Excel bietet zwei Arten von Steuerelementen an.
Formularsteuerelemente sind darauf ausgerichtet, mit den klassischen Excel Funktionen bzw.
Formeln zu interagieren und somit ohne VBA Code auszukommen. Sie sind für die Bewältigung
kleinerer Aufgaben konzipiert. Formularsteuerelementen Makros und somit VBA Code zuzuweisen ist
nur im geringen Umfang z.B. bei Buttons sinnvoll. Diese Sorte von Steuerelementen ist über
o
Entwicklertools  Einfügen  Formularsteuerelement
zu erreichen.
Neben den Formularsteuerelementen können dort auch sog. ActiveX – Steuerelemente ausgewählt
und in einem Formular platziert werden. Diese bieten deutlich mehr Möglichkeiten als reine
Formularsteuerelemente, denn VBA bietet zahlreiche Objekte und Methoden zur Interaktion mit
diesen Elementen an, zum Beispiel kann der Inhalt einer Combo Box ausgelesen oder gesetzt
werden. Als vorteilhaft erweist sich beim Einsatz von ActiveX – Komponenten, dass sie mit Hilfe von
VBA automatisch erzeugt und im Tabellenblatt positioniert werden können. Auf ein Beispiel zur
dynamischen Erzeugung von ActiveX Komponenten wird wegen der Komplexität des Source Codes
allerdings nicht weiter eingegangen. Sie sind in VBA unter dem Begriff MSForms zu finden. Es ist
sowieso eher üblich, benutzerdefinierte Dialoge aus dem nächsten Abschnitt zu implementieren.
Nichtsdestotrotz sollten Leser den Begriff ActiveX in Kombination mit Microsoft Produkten mal
gehört haben, da es von Microsoft
„als ein Softwarekomponenten-Modell für aktive Inhalte“ 4
entwickelt wurde und somit auch in ihren Produkten frequentiert verwendet wird.
Excel bietet eine Fülle von Komponenten zur Auswahl an:
-
-
-
4
Die Schaltfläche
Die Schaltfläche verkörpert einen klassischen Button. Er wird in Kombination mit Ereignissen
interessant. Es lassen sich u.a. Eigenschaften wie Größe, Name und Aktivierung festlegen.
Das Kombinationsfeld (Combo Box)
Das Kombinationsfeld lässt den Nutzer aus einer Reihe beliebiger Inhalte auswählen. Der
aktuell repräsentierte Wert wird in der Box angezeigt. Über den integrierten Auswahlbutton
gelangt man zur Auswahlliste. Das Feld kommt häufig bei Filtervorgängen oder
benutzerseitigen Einstellungen zum Einsatz.
Das Kontrollkästchen (Check Box)
CheckBox
Die Check Box kommt ins Spiel, falls benutzerseitige Einstellungen vorgenommen werden
müssen und anhand der Einstellungen spezifische Funktionen ausgeführt werden sollen.
Charakteristisch ist ihr Einsatzzweck als graphischer Vertreter einer Boolean-Variablen.
http://de.wikipedia.org/wiki/ActiveX
-
-
-
-
-
Das Drehfeld
Über das Drehfeld lässt sich eine Variable benutzerseitig zwischen zwei vorher definierten
Grenzen konfigurieren. Oft lassen sich dadurch wichtige Messgrößen z.B. Abstände regeln.
Das Listenfeld
Das Listenfeld weist eine ähnliche Funktion wie das Kombinationsfeld auf, wird graphisch
allerdings etwas anders dargestellt.
Das Optionsfeld (RadioButton)
Die Arbeitsweise des Optionsfeldes ist annähernd deckungsgleich zu den Kontrollfeldern.
Das Gruppenfeld (Rahmen)
Das Gruppenfeld soll die Identifizierung mehrerer zusammengehöriger Komponenten
erleichtern. Hier lassen sich u.a. Rahmen und Überschrift beeinflussen.
Bezeichnung (Label) Label1
Das Label soll wichtige Komponenten durch eine Beschriftung hervorheben und zu der
intuitiven Benutzersteuerung beitragen.
Textfeld (nur als ActiveX – Komponente einzubinden)
Das Textfeld ermöglicht die Eingabe und Anzeige benutzerabhängiger Daten. Es ist vielseitig
einsetzbar, z.B. lässt sich deaktivieren und als Ausgabefeld nutzen.
Neben den oben aufgelisteten Komponenten lassen sich z.B. auch noch Bilder oder Umschaltflächen
einbinden.
Abschließend ist noch darauf hinzuweisen, dass aus Tabellenblättern erstellte Formulare trotz ihrer
Umgestaltung Tabellenblätter bleiben und somit nicht zu den klassischen Dialogen zählen. Aufgrund
schlechter Programmierung kann es dem Entwickler möglicherweise passieren, dass unbefugte
Nutzer Zugriff auf Rohdaten erhalten, welche in den Zellen des Tabellenblatts gespeichert werden
und diese - genauso wie den Aufbau des Formblattes - manipulieren können. Dialoge können diese
Problematik lösen, da keine Einträge mehr in einem Tabellenblatt vorgenommen werden können,
solange sie aktiv sind (modale Dialoge).
5.8.3 benutzerdefinierte Dialoge
Für eine intuitive und bequeme Benutzerführung reichen integrierte Dialoge und Formulare nicht
aus. In vielerlei Hinsicht ist es sinnvoll, eigene Dialoge bzw. Formulare verwenden zu können, die mit
Hilfe von verschiedenen Steuerelementen genau auf die Bedürfnisse der Anwendung abgestimmt
werden können. Sogenannte „User Forms“ sind im VBA Editor mühelos zu gestalten. Mit Hilfe von
o
Einfügen  User Form
wird ein neuer Dialog erzeugt. Dieser ist zunächst leer. Nun lassen sich die in der Werkzeugsammlung
aufgelisteten Elemente mit Drag & Drop an beliebiger Stelle auf dem neuen Dialog platzieren und
formatieren. Es werden neben den oben bereits vorgestellten Steuerelementen einige zusätzliche
angeboten. In diesem Zusammenhang ist das Eigenschaftenfenster des VBA Editors sehr hilfreich – es
listet nicht nur die Eigenschaften der aktuell ausgewählten Komponente auf, sondern dort lassen sie
sich auch leicht editieren. Über
o
Rechtsklick  Code anzeigen
gelangt man zurück zum Code Fenster, um die Funktionalität des Moduls implementieren zu können.
Mit der Verwendung von benutzerdefinierten Dialogen ist die gezielte Manipulation von Ereignissen
verknüpft. Beispielsweise wird das Ereignis
o
[Buttonname]_Click()
aufgerufen, sobald ein Nutzer auf einen Button klickt. Es existieren viele Ereignisvarianten, die es bei
sauberer Programmierung zu beachten gilt. Im Gegensatz zu integrierten Dialogfeldern müssen User
Forms durch die Anweisung
o
[UserFormName].Show
explizit eingeblendet werden. Die Oberflächenprogrammierung mit VBA und UserForms erweist sich
als vielfältig, daher wird in diesem Abschnitt nur eine Übersicht mit den wichtigsten Methoden,
Eigenschaften und Ereignissen vorgestellt. Ein Anwendungsfall ergibt sich im nächsten Unterkapitel
im Zusammenhang mit selbst implementierten Ereignissen.
Anweisung
Beschreibung
[Komponente]_Clicked()
Ereignis, Bietet die Möglichkeit beim Erzeugen des Dialoges den
Komponenten Defaultwerte zuzuordnen.
Ereignis Einfacher Mausklick
[Komponente]_DblClick()
Ereignis Doppelklick
[Liste].AddItem()
Fügt ein weiteres Auswahlelement der Liste / ComboBox hinzu
[Liste].Clear()
Löscht die Auswahlliste / ComboBox
[Liste].RemoveItem()
Entfernt ein Auswahlelement aus der Liste / ComboBox
[Liste].Value / Text
Aktueller Wert einer Liste / ComboBox
[Liste].ListCount
Anzahl der Einträge einer Liste / ComboBox
UserForm_Initialize()
5.9 Selbst implementierte Ereignisse auslösen und anwenden –
Eventprogrammierung
Ereignisse können professionellen Office Entwicklern viel Arbeit ersparen: Durch sie wird es erst
möglich, zwei unterschiedliche Module, exemplarisch ein wichtiges Klassenmodul und einen
benutzerdefinierten Dialog, zu verbinden. Um einen verständlichen Einstieg in die Event
Programmierung zu erhalten, soll ein Anwendungsfall den Umgang mit Ereignissen näher bringen:
Der auf der vorherigen Seite aufgeführte Programmcode soll das Teamwork zwischen Dialog und
Klassenmodul hervorheben:
Der erste Codeblock enthält den Inhalt des Klassenmoduls „clsRaise“, dem sich wiederum der Code
des Dialogs im zweiten Codeblock anschließt. Seine Gestaltung zeigt die Abbildung links unten.
Durch Ereignisse wird es Klassen nun letztendlich erlaubt, dynamisch auf Attribute einer anderen
Klasse zuzugreifen. Im o.g. Fall greifen die Events „Aktion1“ und Aktion2“ der Klasse „clsRaise“ auf
die beiden Bezeichnungsfelder des Dialogs zurück und modifizieren sie automatisch nach der
Aktivierung des Buttons. Sie färben die beiden Bezeichnungsfelder rot und zeigen einen
hochzählenden Counter an. In der Abbildung rechts unten ist das zu erwartende Ergebnis graphisch
aufgeführt.
Solch einen Ablauf ohne Ereignisse zu implementieren ist theoretisch nicht ausgeschlossen, würde
aber recht schnell zu aufwändig werden. Dafür müssten letztendlich Umwege über zusätzliche
Funktionsparameter und Klassenmodule herhalten. Obendrein ist letztere Variante fehleranfälliger
und komplizierter zu warten. Eventprogrammierung ist ein weites Feld, dessen Möglichkeiten weit
über das vorgestellte Beispiel hinausgehen.
6 Syntax und Anwendung III – Externe Datenquellen und
Präsentation von Daten
Für fortgeschrittene Excel bzw. Office Anwendungen reichen die bisher angesprochenen
Möglichkeiten sicherlich schon aus. Will man allerdings eine tiefgreifende Office Anwendung
entwickeln, wird man mit dem bis jetzt vorgestellten Befehlssatz von VBA schnell auf Probleme
stoßen. Mehrere Datensätze gleichzeitig aus einer Datenbank auszulesen und per Hand oder
Formular in Excel Tabellen zu übertragen wird auf Dauer mehr als mühselig. Möchten Anwender
dann auch noch die Daten automatisch im Hintergrund per Email verschicken und graphisch
darstellen, wird die Implementierung ein nahezu aussichtsloses Unterfangen. Aus diesem Grunde
bietet der VBA-Befehlssatz auch Schnittstellen für den kontrollierten Austausch mit externen
Datenquellen und Programmen an.
6.1
I/O Operationen
Der Umgang mit I/O Operationen wurde recht einfach gestaltet: Es gibt wenige Grundoperationen,
die schon ausreichen, Datensätze aus Textdateien (o.ä. Formaten) auszulesen bzw. in Dokumente zu
exportieren. Das bereits vorgestellte Arsenal an Bearbeitungsmöglichkeiten von Zeichenketten
schafft zusätzliche Unterstützung.
Open() öffnet die anzugebende Datei. Der Öffnungsmodus (Input, Output oder Append) entscheidet,
welche Operationen mit der Datei durchgeführt werden können. Jeder geöffneten Datei wird eine
eindeutige Dateinummer zugeordnet, die sie im weiteren Verlauf des Programmes identifizert. Diese
Maßnahme wird bei paralleler Datenverarbeitung nützlich. Line Input #<Nr> liest die aktuelle Zeile
aus der Datei mit der übergebenen Nummer. VBA erkennt Datentypen z.B. Datumsangaben oder
Zeichenketten automatisch. Print #<Nr> dient zum Schreiben einer Zeile in eine Datei. Der Close <Nr>
Befehl schließt die angegebene Datei wieder, während EOF das Dateiende repräsentiert.
Ein sinnvolles Codebeispiel zur praktischen Anwendung befindet sich als Ergänzung im
Abbildungsverzeichnis (Abbildung 9.10).
Desweiteren bietet der VBA Befehlssatz Funktionen zum Löschen, Kopieren, Suchen oder
Umbenennen von Dateien. Die folgende Grafik bietet einen groben Überblick über die wichtigsten
Operationen dieser Kategorie:
Methode
Dir ( [Pfad] & [Suchmuster] )
FileDateTime ( [Pfad] )
FileLen ( [Pfad] )
GetAttr ( [Pfad] And Konstante)
FileCopy( [PfadAlt], [PfadNeu])
Name ( [Alt], [Neu])
Kill ( [Pfad])
Dient zur Suche von Dateien. Es können auch Platzhalter (*)
verwendet werden. Als Rückgabewert erhält man den ermittelten
Pfad oder einen Leerstring.
Liefert Datum und Uhrzeit der letzten Änderung der Datei
Liefert die Dateigröße
Dient zur Ermittlung von Datei- und Verzeichnisattributen.
[vbHidden, vbSystem, vbDirectory und vbArchive]
Kopiert angegebene Datei an den übergebenen Zielort
Benennt eine Datei um
Löscht eine Datei. Die Aktion kann nicht gemacht rückgängig
werden.
Externe Datenquellen und Präsentation| - 34 -
6.2
SQL Abfragen und Verarbeitung der Resultate
Datenbanken gewährleisten eine persistente Datenhaltung. Professionelle Softwareentwickler
werden infolgedessen unweigerlich irgendwann einmal mit Datenbanken in Kontakt kommen.
Gerade Excel als Tabellenkalkulationsprogramm kommuniziert häufiger mit Datenbanken als mit
gewöhnlichen Textdateien, sobald eine gewisse Menge an Datensätzen auf Dauer bearbeitet und
verwaltet werden muss. VBA wartet aus diesem Grunde auch mit einem Befehlssatz für das Absetzen
von SQL Befehlen und die Verarbeitung deren Resultate auf. Kernpunkt ist die Verwendung des
ADODB.Connection Objektes (ADO: Microsoft ActiveX Data Object),
Die Verbindung zur Datenbank wird durch Instanziierung eines Objekts vom Typ ADODB.Connection
aufgebaut. Der ConnectionString gibt Datenbankprovider und Datenquelle an. Open() öffnet die
Verbindung zur Datenbank, während Close() diese Verbindung wiederum schließt. Das Absetzen
eines SQL Befehls erfolgt durch die execute()-Funktion. Die Ergebnisse einer Abfrage werden immer
in einem Objekt vom Typ ADODB.RecordSet abgespeichert. Die Datensätze lassen sich durch
Kombination aus While-Schleife mit dem Befehl MoveNext() zeilenweise abfragen. Innerhalb eines
Datensatzes können die einzelnen Attribute in der Form <Objektname>!<Attributname>
angesprochen und verarbeitet werden. Das im Anhang aufgeführte Beispiel macht den sinnvollen
Gebrauch der verwendeten Objekte und weiterführender Operationen sichtbar. Es ist dort unter
Abbildung 9.11 zu finden.
6.3 Ausführung von Konsolenbefehlen
Ähnlich wie in anderen gebräuchlichen Programmiersprachen lassen sich durch VBA Konsolenbefehle
an die CMD übergeben und ausführen. Doch es lässt sich immer nur ein einziges Kommando
übergeben. Als möglicher Lösungsweg bietet sich hier eine Batchdatei oder ein mit && verkettetes
Kommando an. Ebenso lassen sich andere externe Programme direkt aus Excel aufrufen.
6.4 Austausch mit anderen Office Anwendungen
Eine Spezialität von VBA ist der Austausch von Informationen zwischen unterschiedlichen Office
Anwendungen. Nutzt der Anwender das vollständige Office Paket, kann VBA hier seine ganze Stärke
ausspielen, weil komplexe Hintergrundabläufe auf wenige, aber effektive Spezialobjekte
zurückgeführt werden können. Der Austausch von Daten zwischen Word, Excel, Outlook und Access
wird durch VBA zum Kinderspiel. Dieses Thema ist allerdings ziemlich weitreichend, sodass auf
Details der Implementierung im Skript verzichtet wird.
6.5 Externe DLL´s einbinden und nutzen
Theoretisch kann es passieren, dass der Befehlssatz von VBA nicht mehr ausreicht oder
Möglichkeiten einer weiteren Programmiersprache, z.B. C/C++, die von VBA deutlich übertreffen.
VBA lässt aus diesem Grund das Einbinden und die Verwendung externer DLL´s zu. Ein
Softwareentwickler kann schwierige Teilaspekte einer Aufgabenstellung nun mit seiner gewohnten
Programmiersprache und gewohnten Datenstrukturen lösen. Er hat nur noch dafür zu sorgen, dass
VBA die DLL einbindet. Dabei unterstützt den Programmierer die Declare-Anweisung, mit der es auf
Modulebene möglich ist, Verweise auf Funktionen und Klassen in einer DLL zu deklarieren.
6.6 Präsentation und Visualisierung mit Hilfe von Grafiken und
Diagrammen
Zu guter Letzt folgt ein Einblick in die Präsentation und Visualisierung von Daten mit Hilfe von VBA.
Die Sprache leistet Unterstützung bei der Erstellung, Verwaltung und Manipulation von Diagrammen
und Grafiken. Excel zum Beispiel hat zwar hauptsächlich die Auswertung und Kalkulation von
Datenmengen als Aufgabe, eine Präsentation der Daten mit aussagekräftigen Diagrammen sollte in
einer professionellen Anwendung aber nicht fehlen. Alle Grafiken, die man in Excel per Knopfdruck
erstellen kann, lassen sich auch automatisch und kontextabhängig mittels VBA erstellen und
verwalten. Dazu zählen z.B. nicht nur Diagramme sondern auch WordArt, Shapes, Bilder etc.. Dieses
Kapitel behandelt aber nur Diagramme. Man differenziert zwischen Diagrammblättern und
eingebetteten Diagrammen: Erstere werden in einem separaten Blatt generiert, während letztere
kontextabhängig in ein bereits existierendes Tabellenblatt integriert werden. Um eine klare
Vorstellung über Verwendungsmöglichkeiten und Resultate der Methoden zu erhalten, wurden die
Codebeispiele direkt ergänzt, anstatt sie in das Abbildungsverzeichnis zu integrieren: Die
Gestaltungsmöglichkeiten von Diagrammen sind schließlich sehr weit gefächert, folglich sind die
aufgeführten Erläuterungen eng mit dem Quellcode verknüpft und enthalten nur die wichtigsten
Formatierungsmöglichkeiten.
6.6.1 Diagrammblätter erstellen
Der Aufruf der Add()-Methode eines Charts-Objektes erstellt ein neues Diagrammblatt und fügt es
der Liste der bereits existierenden Diagrammblätter hinzu. Before oder After legen die Platzierung
des neuen Diagrammblattes fest. Das erzeugte Diagramm entspricht einer Instanz der Klasse Chart.
Mit Hilfe der Eigenschaft Chart Type lässt sich der Diagrammtyp (hier ein Liniendiagramm: xlLine)
festlegen und durch die SetSourceData() Funktion bestimmen, welche Daten dargestellt werden
sollen. Durch die Eigenschaft Name lässt sich dem Diagrammblatt ein eindeutiger Name zur
verbesserten Identifikation zuweisen.
6.6.2 Eingebettete Diagramme erstellen
Im unten aufgeführten Codeauszug lassen sich viele Parallelen zur Erstellung eines Diagrammblattes
erkennen. Hier wird jedoch anstatt einer Instanz vom Typ Chart ein Objekt vom Typ ChartObjekt
erzeugt. Neu ist die Platzierung des ChartObjekts im Tabellenblatt durch Angabe von Abstand des
Rahmens zum linken und zum oberen Ende der Tabelle, Höhe und Breite.
6.6.3 Diagrammblätter gestalten
Diagramme besitzen viele Eigenschaften, die im Laufe des Programmes manipuliert werden können.
Die nun dargestellte Prozedur zeigt einige wichtige davon auf, längst aber nicht alle. Eine Instanz der
Klasse ChartArea repräsentiert die Diagrammfläche des Diagramms. Das schließt auch die
Zeichnungsfläche oder auch Titel und Legende ein. Die Eigenschaft Interior verweist auf das „Innere“
des Diagramms, welchem wiederum z.B. eine Farbe zugewiesen werden kann. Das Objekt PlotArea
steht für die Zeichnungsfläche des Diagramms, wobei das Innere der Fläche auch mit Interior
angesprochen werden kann. Ob ein Diagramm einen Titel besitzt, bestimmt die Eigenschaft HasTitle,
dessen Layout mit Hilfe des ChartTitle Objekts modifiziert wird. Beispielsweise verkörpert die
Eigenschaft Text die Beschriftung des Titels. Analog dazu bestimmt die Eigenschaft HasLegend ob ein
Diagramm eine Legende besitzt und das entsprechende Legend Objekt wie das Layout gestaltet
werden soll. Das Axes-Objekt steht für eine Auflistung aller Achsen eines Diagrammes, wobei es nicht
mit dem Axis-Objekt verwechselt werden sollte, welches genau eine Achse repräsentiert. Hier lassen
sich Titel (AxisTitel), Formatierung der Achsenbeschrifung (TickLabels) sowie Skalierung der
jeweiligen Wertachse (…Scale) bearbeiten. Datenreihen lassen sich über das Objekt SeriesCollection
verwalten, einzelne Datenpunkte über das Points Objekt ansteuern.
6.6.4 Eingebettete Diagramme gestalten
Eingebettete Diagramme weisen dieselben Eigenschaften wie Diagrammblätter auf und können
somit auf die gleiche Weise gestaltet und manipuliert werden. Zusätzlich lassen sich beim Zugriff auf
das entsprechende ChartObjekt noch Größe(Width, Height) und Abstand zum Rand (Left, Top)
modifizieren. Aus den aufgeführten Gründen wird hier auf ein weiteres Programmbeispiel verzichtet.
6.6.5 Diagrammblätter und eingebettete Diagramme verwalten
VBA bietet dem Entwickler die Möglichkeit, Diagrammblätter mittels einer Copy()-Funktion an die
gewünschte Position in der Arbeitsmappe zu kopieren. Falls kein Parameter angegeben wird, landet
das Diagramm einfach in einer frisch angelegten Arbeitsmappe. Eingebettete Diagramme
unterstützen ebenfalls diese Methode, wobei das Einfügen von eingebetteten Diagrammen manuell
durch Aufruf der Paste()-Methode vorgenommen wird. Beide Diagrammtypen lassen sich durch den
Aufruf der Delete()-Funktion einfach löschen. Sofern gewünscht, lässt sich das Diagramm als Bilddatei
unter Zuhilfenahme der Export()-Methode als Bilddatei an den angegebenen Zielort exportieren.
7 Weitergehende Informationen zur Verwendung von VBA
Der abschließende Passus beinhaltet weitergehende Informationen für alle Programmierer und
Anwender, welche mit VBA erstmals oder auch professionell in Kontakt kommen. Die Informationen
stellen u.a. auch Nachteile von VBA heraus und sollten Entwickler wissen. Sie sollen aber keineswegs
davon abhalten sich mit VBA zu beschäftigen – die Sprache hat sich auf unabsehbare Zeit als
Skriptsprache für Office Anwendungen etabliert.
7.1 Ähnliche Konzepte und Alternativen
Das Konzept, wiederkehrende Abläufe zu automatisieren oder benutzerabhängige Aktionen mit Hilfe
von Makros zu unterstützen, kommt auch in anderen Anwendungen zum Einsatz: Bekanntermaßen
unterstützt OpenOffice nicht nur VBA, sondern auch JavaScript. Als Alternative zur Implementierung
von VBA Makros bietet Microsoft die Möglichkeit an, in Visual Studio.Net mit den „VS Tools for Office
System“ Add-Ins für Office zu entwickeln, welche die gleichen Aufgaben übernehmen können wie
klassische VBA Makros. Bis zur Version 6.0 der Programmiersprache Visual Basic ist es problemlos
möglich, Module und Formulare zwischen VBA und VB auszutauschen – dies ist durch die Umstellung
von VB auf das .NET Framework deutlich erschwert worden. Einzelne VBA Module können zwar
durch gezielte Umbenennung und Anpassung an die .NET Strukturen überführt werden, ganz anders
aber bei den Formularen, welche seit der Umstellung neu erstellt werden müssen. Microsoft bietet
auf ihrer Webseite Hilfestellung bei der Migration von VBA Code zu VB.NET an, falls man nach dem
Einsatz von VBA Makros auf die VSTools umsteigen und alten Code portieren möchte.
7.2 Der Makro Rekorder
Der Sprachkern von VBA ist vom logischen Aufbau her nicht schwer zu verstehen und somit auch für
Programmieranfänger potentiell geeignet. Bei der professionellen Anwendung von VBA besteht
aufgrund der modularen Programmierung allerdings die Gefahr, der Programmlogik nicht mehr
richtig folgen zu können (Spaghetticode durch zu viele GoTo´s oder viel zu klein gehaltene und
verschachtelte Prozeduren). Für Einsteiger sollte daher der Makro Rekorder in Office Programmen
nicht unerwähnt bleiben: Dieser zeichnet diverse Anweisungen, z.B. die Auswahl einer speziellen
Zelle in Excel, auf und übersetzt sie automatisch in VBA-Code, solange er aktiviert ist. Der Makro
Rekorder ist unter dem Reiter
o
Entwicklertools  Makro aufzeichnen
zu finden. Er bietet somit Anfängern die Möglichkeit, erste Makros zu implementieren und
weiterzuentwickeln. Der Makro Rekorder ist nicht nur für Einsteiger interessant, da er
professionellen Entwicklern ebenfalls viel Zeit bei der Implementierung ersparen kann. Somit können
sie sich auf die schweren bzw. zeitintensiven Aufgaben konzentrieren und folglich auch dem Kunden
recht zeitnah ein Ergebnis präsentieren.
Weitergehende Informationen zur Verwendung von VBA| - 40 -
7.3 Das Sicherheitskonzept von Microsoft
VBA ist ein Visual Basic Dialekt und erbt somit auch wesentliche Funktionen von Visual Basic (siehe
Kapitel 1, Allgemeine Informationen und Kapitel 2, Sprachkern). Folglich können VBA Anwendungen
wie andere Windows Anwendungen auch Schadcode enthalten: Es entstehen sog. Makroviren. Um
eine Infizierung zu vermeiden, bietet Microsoft die Makrozertifizierung an. In neueren MS Office
Versionen sind Makros standardmäßig deaktiviert, sodass man diese erst manuell vor der Ausführung
aktivieren muss. Zusätzlich empfehlen Office Programme automatisch, nur vertrauenswürdige oder
mit überprüfbaren Zertifikaten ausgestattete Makros zuzulassen. Ebenso ist es möglich Makros in
sog. vertrauenswürdigen Ordnern zu speichern. Zusätzliche Sicherheit schaffen heutzutage auch gute
Anti-Viren Programme. Aber ein fehlendes A-Priori Sicherheitskonzept, z.B. der Einsatz einer
Sandbox, führt dazu, dass man als Endanwender immer noch viel selbst zur Sicherheit beitragen
muss. Gerade im Internet sollte man aufpassen, denn schädigende Webseiten und Emails bieten zum
Download gerne Worddateien an, die durch ein verstecktes Makro kompromittiert wurden oder die
Datei wird beim Aufruf der Seite im Hintergrund gleich automatisch heruntergeladen.
8 Schlusswort
Wie bereits mehrfach angeschnitten, ließen sich sicherlich einige Ausführungen vertiefen. Dies würde
allerdings den Rahmen des Skripts sprengen. Über spezielle Themen wie z.B. die intuitive Gestaltung
einer Benutzeroberfläche oder eine detaillierte Einführung in die Fähigkeiten von Excel lassen sich
sogar ganze Bücher finden. Auch Tutorials und Bücher, welche den Einstieg in VBA und somit auch in
die Office Programmierung unterstützen, entdeckt man im Netz häufig. Foren, die sich um
Problemlösungen bezüglich VBA bzw. Office Programmierung bemühen, runden das Angebot ab.
Abschließend lässt sich noch sagen, dass Entwickler Erfahrungen mit einer Programmiersprache auf
Dauer weniger durch Theorie als durch die praktische Anwendung sammeln. Die Ausarbeitung soll
letztendlich praxisbegleitend sein. Die im Anhang aufgelisteten Codebeispiele sollen u.a. auch als
Anregung dienen, VBA praktisch auszuprobieren!
Schlusswort| - 41 -
9 Abbildungsverzeichnis
Die hier aufgeführten Informationen und Codeausschnitte zu diversen Anwendungsfällen wurden
größtenteils dem Buch „Thomas Theis: Einstieg in VBA mit Excel“ entnommen oder angelehnt und
dem Skriptverlauf entsprechend zusammengestellt. Die Kommentare in den Code Beispielen dienen
zur Erläuterung der verwendeten Anweisungen. Falls die Kommentare nicht ausreichen bzw. weitere
Informationen zum Programmablauf notwendig sind, erfolgen diese im Anschluss an das Beispiel.
Zu guter Letzt noch eine Anmerkung für diejenigen Leser, welche die Abbildungen 9.1 bis 9.4
nachschlagen ohne das Kapitel 2.7 „Unterprogrammtechnik“ vorher gelesen zu haben:
Die Schlüsselphrase „Sub...End Sub“ markiert den Anfang bzw. das Ende einer sog. „Prozedur“.
Prozeduren beinhalten eine Gruppe von Anweisungen, welche durch den Aufruf dieser nacheinander
ausgeführt werden können.
9.1 Deklaration von Variablen und Konstanten
Abbildungsverzeichnis| - 42 -
9.2 Einsatz von Arrays
Der Aufruf der Prozedur Felder() erzeugt nacheinander folgende Ausgaben in Form einer
MessageBox:
Abbildungsverzeichnis| - 43 -
9.3 Vorstellung des Collection Objekts
Der Aufruf der Prozedur CollectionObject() erzeugt folgende Ausgabe in Form einer MessageBox:
9.4 Benutzerdefinierte Datentypen deklarieren und ansprechen
Abbildungsverzeichnis | - 44 -
9.5 Einsatz von Prozeduren und Übergabeparametern
Dieses Beispiel soll die Deklaration und den Aufruf von Prozeduren und die verschiedenen
Möglichkeiten der Argumentübergabe nahelegen. Desweiteren soll der Programmcode den
Unterschied zwischen Call-By-Value und Call-By-Reference aufzeigen.
9.6 Funktionen und ihre Rückgabeparameter
9.7 Klassen und Objekte
9.8 Die Excel Oberfläche
Abbildung 9.8 zeigt die grundlegende Excel Oberfläche. Bedeutsame Komponenten, deren
Einsatzzweck man kennen sollte, sind entsprechend markiert.
9.9 Der VBA Editor
Abbildung 9.9 zeigt die grundlegende Oberfläche des VBA Editors. Auch hier sind die grundlegenden
Komponenten rot hervorgehoben bzw. beschriftet. Um die Klassifikation der Modularten im
Projektexplorer zu visualisieren, wurden die einzelnen Modultypen grün eingerahmt.
9.10 Anwendungsbeispiel für I/O Operationen
Der erste Teil des Quellcodes (bis „Close 1“) liest den Inhalt der unten links aufgeführten Textdatei
ein und schreibt ihren Inhalt zeilenweise in die erste Spalte der Excel Tabelle. Das Ergebnis ist in der
Abbildung rechts unten zu sehen. Im zweiten Teil wird der Inhalt der Excel Tabelle ausgelesen und in
eine zweite Textdatei namens „Test2.txt“ herausgeschrieben.
9.11 SQL Operationen und ihre Auswertung
Durch das Skript wird eine Verbindung zur Beispieldatenbank „Nordwind 2007.accdb“ realisiert, die
Microsoft zusammen mit Datenbankprogramm „Access“ ausliefert. Es handelt sich dabei um ein
Warenwirtschaftsprogramm. Im Beispiel werden Kundeninformationen aus der Tabelle Kunden
ausgelesen und in Excel gespeichert.
10 Quellenverzeichnis
Auf dieser Seite sind die wichtigsten Quellen noch einmal zusammengefasst:
o
Einstieg in VBA mit Excel, Thomas Theis, Galileo Computing, 2te und aktualisierte Auflage
2010
o
ftp://ftp.fernuni-hagen.de/pub/pdf/urz-broschueren/broschueren/b012.pdf
o
Handbuch Programmiersprachen (Softwareentwicklung zum Lernen und Nachschlagen),
Peter A. Henning und Holger Vogelsang, Hanser Verlag, 2007
o
http://www.online-excel.de/excel/singsel_vba.php?f=50
o
http://www.office-loesung.de/
o
http://msdn.microsoft.com/de-de/isv/bb190538.aspx
o
http://de.wikipedia.org/wiki/Visual_Basic_for_Applications
o
http://de.wikipedia.org/wiki/Tabellenkalkulation
o
http://de.wikipedia.org/wiki/Microsoft_Excel
o
http://de.wikibooks.org/wiki/VBA_in_Excel_-_Grundlagen
o
http://www.vba-beispiele.de/office.php?act=excel&cat=vbaereignisse
o
http://www.activevb.de/tutorials/tut_vbatutorial/tut_vbatutorial.html
Quellenverzeichnis | - 52 -
11 Eidesstattliche Erklärung
Eidesstattliche Erklärung | - 53 -

Einstieg in VBA und die Office Programmier Beispiel von Excel

Transcription

Similar documents

Aspekte moderner Web-Applikationen - Das IICM

Das Python3.2-Tutorial auf Deutsch

MWA-JavaScript 2015