VBA - w3- · PDF fileVBA Programmieren mit ... können mit VBA gesteuert wer-den. In Word, Excel und Powerpoint können Sie den Visual Basic-Editor auf die gleiche Weise aufrufen

easy2know-how

VBAProgrammieren mit

Visual Basic for Applications “Investition in Wissen zahlt die besten Zinsen”

Benjamin Franklin

easy2know-how – Erhard Closs, Ihr PC-Coach, Tel.: 089/ 910 72 813, Fax.: 089/ 910 72 813

Dieses Werk ist urheberrechtlich geschützt.

Alle dadurch begründeten Rechte, insbesondere der Nachdruck, die Übersetzung, die Wiedergabe aufphotomechanischen oder ähnlichen Wegen, die Speicherung und Verarbeitung mit Hilfe der EDVbleiben auch auszugsweise dem Urheber vorbehalten.

-

Visual Basic for Applications 3

Inhaltsverzeichnis

Modul 1: Einführung in die Programmierung .................................................................................................. 5Grundlagen von VBA ....................................................................................................................................... 6Projekte, Eigenschaften und Module ............................................................................................................... 7Planung eines Programms ................................................................................................................................ 8Eingeben eines Programms .............................................................................................................................. 9Unterschiede zwischen Anweisungen und Funktionen .................................................................................. 10Prozeduren ..................................................................................................................................................... 11Befehle zur Ein- und Ausgabe ........................................................................................................................ 12Ausführen und Testen eines Programms ......................................................................................................... 13Einzelschrittmodus ......................................................................................................................................... 14Zusammenfassen und Vertiefen: Einführung in die Programmierung ............................................................. 15

Modul 2: Variablen und Konstanten .............................................................................................................. 16Konstanten, Variablen, Datenfelder ............................................................................................................... 17Variablen ....................................................................................................................................................... 18Datentypen .................................................................................................................................................... 19Gültigkeitsbereiche von Variablen ................................................................................................................ 20Gültigkeitsdauer ............................................................................................................................................ 21Konstanten ..................................................................................................................................................... 22Datenfelder .................................................................................................................................................... 23Zusammenfassen und Vertiefen: Variablen und Konstanten .......................................................................... 24

Modul 3: Prozeduren und Funktionen ........................................................................................................... 25Parameter ...................................................................................................................................................... 26Referenzübergabe oder Wertübergabe? ......................................................................................................... 27Funktionen ..................................................................................................................................................... 28Gültigkeitsbereiche von Prozeduren .............................................................................................................. 29Exkurs: Optionale Parameter ......................................................................................................................... 30Exkurs: Parameterfelder ................................................................................................................................. 31Zusammenfassen und Vertiefen: Prozeduren und Funktionen ........................................................................ 32

Modul 4: Objekte und Auflistungen .............................................................................................................. 33Überblick....................................................................................................................................................... 34Zugriff auf Elemente einer Auflistung ............................................................................................................ 35Arbeiten mit Eigenschaften ............................................................................................................................ 36Arbeiten mit Methoden .................................................................................................................................. 37Objektkatalog ............................................................................................................................................... 38With-Anweisung ............................................................................................................................................ 39Exkurs: Klassenmodule .................................................................................................................................. 40Exkurs: Benutzerdefinierte Eigenschaften und Methoden .............................................................................. 41Zusammenfassen und Vertiefen: Objekte und Auflistungen .......................................................................... 42

Modul 5: Programmstrukturen ....................................................................................................................... 43Überblick über Schleifen ............................................................................................................................... 44For � Next ..................................................................................................................................................... 45For Each � Next ............................................................................................................................................. 46Do � Loop ...................................................................................................................................................... 47Überblick über Verzweigungen ..................................................................................................................... 48If � Then � Else .............................................................................................................................................. 49Select Case � End Select ............................................................................................................................... 50Zusammenfassen und Vertiefen: Programmstrukturen .................................................................................... 51


Modul 6: Fehlerbehandlung ......................................................................................................................... 52Benutzerdefinierte Fehlerroutinen ................................................................................................................ 53Exkurs: Auslösen von benutzerdefinierten Fehlern ...................................................................................... 54Hierarchie der Fehlerroutinen ...................................................................................................................... 55Zusammenfassen und Vertiefen: Fehlerbehandlung .................................................................................... 56

Modul 7: Formulare und Dialogfelder ......................................................................................................... 57Erstellen von Dialogfeldern .......................................................................................................................... 58Hinzufügen von Steuerelementen ................................................................................................................ 59Ändern der Größe und Position von Steuerelementen ................................................................................. 60Eigenschaften von Steuerelementen ............................................................................................................ 61Ereignisprozeduren ....................................................................................................................................... 62Anzeigen von Dialogfeldern......................................................................................................................... 63Zusammenfassen und Vertiefen: Formulare und Dialogfelder .................................................................... 64

Modul 8: Datenaustausch mit anderen Anwendungen ................................................................................ 65Zugriff auf Objekte anderer Anwendungen .................................................................................................. 66Exkurs: Datenaustausch mit DDE ................................................................................................................ 67Exkurs: Zugriff auf Windows-Funktionen ..................................................................................................... 68Zusammenfassen und Vertiefen: Datenaustausch mit anderen Anwendungen ........................................... 69

Wichtige Tastenkombinationen ................................................................................................................... 70Index ............................................................................................................................................................. 71


Modul 1Einführung in die Programmierung

Was ist VBA? Was ist der Unterschied zu Visual Basic? Wofür kann man VBA einsetzen? Wie kannich ein Projekt erstellen? Wie kann ich Eigenschaften von Dokumenten einstellen? Was ist ein Modul?Wie kann ich ein Modul erstellen? Wie plane ich ein Programm? Wie kann ich ein Programm eingeben,ausführen und testen? Was ist der Unterschied zwischen Anweisungen und Funktionen? Wie erstelleich Prozeduren? Wie kann ich mit dem Benutzer kommunizieren?

In diesem Modul werden folgende Themen behandelt:

� Grundlagen von VBA

� Projekte, Eigenschaften und Module

� Planung eines Programms

� Eingeben eines Programms

� Unterschiede zwischen Anweisungen und Funktionen

� Prozeduren

� Befehle zur Ein- und Ausgabe

� Ausführen und Testen eines Programms

� Einzelschrittmodus

Lernziel

Der Anwender lernt die Bedienung des Visual Basic-Editors und die Grundlagen der Programmierung kennen.

Voraussetzungen

Grundlagenkenntnisse im Umgang mit Word-Dokumenten, Excel-Arbeitsmappen und/oder Powerpoint-Präsenta-tionen und im Umgang mit einer Textverarbeitung.

-


Grundlagen von VBA

Was ist VBA? Was sind die Unterschiede zu Visual Basic und VB-Skript? Wie rufe ich den VBA-Editorauf?

VBA (Visual Basic für Applikationen) stellt eine Sprachfamilie von Microsoft dar, dieu.a. Visual Basic für Word, Excel, Powerpoint und Access umfaßt. Daneben unterstüt-zen noch einige andere Microsoft-Anwendungen VBA, z.B. Project und Visual C++.Eine Untermenge von VBA stellt VB-Skript dar, das derzeit nur vom Internet Explorerund von Outlook unterstützt wird. Die Möglichkeiten von VB-Skript sind sehreingeschränkt.

VBA ist eine Untermenge von Visual Basic. Im Unterschied zu Visual Basic kann manmit VBA keine eigenständigen Anwendungen kreieren, sondern ist immer auf eine derOffice-Anwendungen angewiesen. Einzig zu Access gibt es optional ein Runtime-Modul, das es ermöglicht, Access Datenbanken samt dem VBA-Code auszuführen,ohne daß Access installiert ist. Visual Basic und VBA haben viele Gemeinsamkeiten.

VBA ersetzt die verschiedenen Makro-Sprachen der Microsoft Office-Anwendungen.Der Vorteil ist, daß der Programmierer nur mehr eine Programmiersprache erlernenmuß, um alle Office-Anwendungen zu programmieren. Mit VBA ist es nicht nurmöglich, die aktuelle Anwendung zu beeinflussen, sondern man kann auch fremdeAnwendungen, soweit diese das erlauben, �fernsteuern�. Alle Anwendungen, diesogenannte OLE-Automatisierungs-Server darstellen, können mit VBA gesteuert wer-den.

In Word, Excel und Powerpoint können Sie den Visual Basic-Editor auf die gleiche Weise aufrufen. Hierzu wählenSie Menü Extras�Makro�Visual-Basic Editor. Access hat in bezug auf VBA eine Sonderstellung.

Abb.1: Aufruf des Visual Basic-Editors

Abgrenzung

Anwendungen

OLE-Anwendungen

-


Projekte, Eigenschaften und Module

Was ist ein Projekt? Wie füge ich neue Module in ein Projekt ein? Wie kann ich Eigenschaften fürDokumente festlegen?

In Visual Basic stellt ein Projekt normalerweise eine komplette Anwendung dar. InVBA wird ein Projekt definiert durch ein Office-Dokument, wie z. B. ein Word-Dokument oder eine Excel-Arbeitsmappe. In einem Projekt werden gespeichert

� das Dokument

� alle Makros, die mit diesem Dokument verbunden sind

� Benutzerformulare (Dialogboxen)

� Verweise auf andere Dokumente, Anwendungen, Vorlagen u. ä.

Die Makros werden in Modulen zusammengefaßt, die den Gültigkeitsbereich bestim-men.

Alle geöffneten Projekte sowie deren Komponenten kann man im Projekt-Explorerbetrachten und verwalten. Diesen kann man mit Ansicht�Projekt-Explorer oder überdas Symbol Projekt-Explorer im Visual Basic-Editor ein- und ausblenden. Komponen-ten kann man löschen, indem man auf sie mit der rechten Maustaste klickt und denBefehl Entfernen von <Komponenten-Name>... auswählt. Man kann auch den BefehlDatei�Entfernen von <Komponenten-Name>... auswählen.

Die Eigenschaften zu einer Komponente werden im Eigenschaftenfenster angezeigtund bearbeitet. Dieses wird mit Ansicht�Eigenschaften oder dem Symbol Eigenschaften-fenster ein- und ausgeblendet. Im Eigenschaftenfenster legt man z. B. den Namen vonKomponenten fest.

Abb.2: Projekt-Explorer und Eigenschaftenfenster

Projekt

Module

Ein neues Modul fügt man in das gerade ausgewählte Projekt mit dem Befehl Einfügen�Modul oder überdas Symbol Modul einfügen ein.

Projekt-Explorer

Eigenschaftenfenster

-


Planung eines Programms

Was muß bei der Erstellung einer VBA-Anwendung beachtet werden? Wie kann ich ein größeresProjekt planen?

Jeder in sich abgeschlossene Programmteil besteht aus 5 Elementen, die sorgfältig vorder Implementierung geplant werden sollten:

1. Schnittstelle: Über die Schnittstelle (Interface) kommuniziert ein Programmteil mitanderen Programmteilen. Nicht jeder Programmteil verfügt über eine solcheSchnittstelle.

2. Deklarationsteil: Hier werden Variablen und Datentypen deklariert, die imProgrammteil verwendet werden sollen.

3. Eingabe: Jedes Programm benötigt Daten, die es verarbeiten kann. Diese Datenkönnen über die Schnittstelle kommen, vom Benutzer eingegeben werden, oderaus anderen Datenquellen (z. B. Dokumente oder Datenbanken) extrahiert wer-den.

4. Verarbeitung: Die eingegebenen Daten werden mit Hilfe eines Algorithmus(Lösungsweges) verarbeitet. Kompliziertere Algorithmen sollten verbal oder gra-phisch dargestellt werden. Zur graphischen Darstellung eignen sich u.a.Struktogramme und Flußdiagramme.

5. Ausgabe: Die Ergebnisse der Verarbeitung können über die Schnittstelle, überBenutzerschnittstellen (z.B. Dialogboxen) oder in andere Datenquellen (z.B.Dokumente oder Datenbanken) ausgegeben werden.

Abb.3: Elemente eines Teilprogramms

Teilprogramme

Schnittstelle

Bei großen Projekten sollte man vor der Implementierung Ist- und Soll-Analysen durchführen, um das Ziel desProjektes klar zu definieren. Solche Projekte werden dann in viele kleinere Programmteile zerlegt.

Deklarationsteil

Eingabe

Verarbeitung

Ausgabe

-


Eingeben eines Programms

Wo gebe ich meine Programme ein? Welche Möglichkeiten bietet der Visual Basic-Editor?

Bevor man ein Programm eingeben kann, muß man ein Modul erzeugen. JedesDokument hat bereits ein Standardmodul. Dieses kann angezeigt werden, indem mandas Dokument im Projekt-Explorer auswählt und den Menübefehl Ansicht�Codeausführt. Man kann aber auch einfach auf das Dokument doppelklicken. Ebensohaben benutzerdefinierte Formulare bereits ein eigenes Modul. Diese Module solltenjedoch nur für Ereignisprozeduren und direkt damit in Zusammenhang stehendeProzeduren und Funktionen verwendet werden. Man sollte daher den Großteil desVBA-Codes auf eigene Module verteilen.

Den Programmcode kann man wie in einer Textverarbeitung eingeben. Jede Anwei-sung und jeder Befehl wird in eine neue Zeile geschrieben. Mit der TABULATOR-Tasteerfolgen Einrückungen, die den Programmcode übersichtlicher machen. Mit UM-SCHALT + TABULATOR können Einrückungen zurückgenommen werden. DerProgrammcode kann ansonsten wie in einer Textverarbeitung üblich bearbeitet,verschoben und kopiert werden. Im Menü Bearbeiten stehen zudem die BefehleSuchen... und Ersetzen... zur Verfügung.

Das Apostroph (�) markiert den dahinterstehenden Text als Kommentar.

Abb.4: Visual Basic-Editor

Code-Ansicht

Eingeben des Codes

Bei den meisten Schlüsselwörtern zeigt der Editor nach der Eingabe die Syntax der Parameter in Form einesQuickTips an. Konstanten, Eigenschaften und Methoden zu Objekten können häufig aus automatisch aufklappen-den Listen gewählt werden. Dabei kann man auch die ersten paar Buchstaben der Konstanten eintippen und denNamen mit TABULATOR vervollständigen.

Kommentare

-


Unterschiede zwischen Anweisungen und Funktionen

Was ist eine Anweisung? Was ist ein Befehl? Was ist eine Funktion?

Anweisungen legen die grundsätzliche Programmstruktur fest, z.B. Deklarations-,Schleifen- und Verzweigungsanweisungen, während Befehle die eigentliche Daten-verarbeitung erledigen, z.B. Ein- und Ausgabebefehle. Daneben kann man aucheigene Befehle definieren, die Prozeduren genannt werden.

Hauptmerkmal von Befehlen ist, daß die Ausgabe entweder über die Benutzerschnitt-stelle (z.B. Dialogboxen) oder in eine andere Datenquelle (z.B. Dokumente, Daten-banken) erfolgt.

Fast jedes Programm benötigt Berechnungen, um das gewünschte Ergebnis zuerreichen. VBA unterstützt die Grundrechnungsarten und das Potenzieren. Danebengibt es eine Reihe eingebauter Funktionen, die kompliziertere Berechnungen durch-führen.

Funktionen können nie als eigenständige Befehle im Programm stehen, sondern dasErgebnis einer Funktion muß immer sofort von einer Anweisung oder einem Befehlweiterverarbeitet werden. Z.B. liefert die Funktion Int(Zahl) den ganzzahligen Teileiner Zahl. Das Ergebnis dieser Funktion wird aber weder gespeichert noch amBildschirm ausgegeben, sondern es wird direkt an das aufrufende Programm zurück-gegeben. Int kann daher nur Teil einer Anweisung sein, die das Ergebnis weiterver-arbeitet.

Abb.5: Datenfluß zwischen Prozeduren und Funktionen

Anweisungen

Befehle

Sowohl die meisten Befehle und Prozeduren als auch die meisten Funktionen benötigen Parameter. Sie dürfenbei Prozeduren und Befehlen die Parameter niemals in Klammern schreiben, bei Funktionen müssen Sie sie immerin Klammern schreiben. Hat eine Funktion keine Parameter, müssen Sie leere Klammern anschließen, z. B. Date().

Funktionen

Verwendung vonFunktionen

-


Prozeduren

Was sind Prozeduren? Wie deklariere ich Prozeduren? Wie werden Prozeduren aufgerufen?

Prozeduren sind das Grundgerüst eines jeden Projekts. Man unterscheidet allgemeineProzeduren und Ereignisprozeduren. Allgemeine Prozeduren ohne Parameter werdenauch Makros genannt und können von den Office-Programmen (mit Ausnahme vonAccess) aus mit dem Menübefehl Extras�Makro�Makros direkt als Makros aufgerufenwerden. Ereignisprozeduren werden in der Regel automatisch beim Eintreten derverschiedenen Ereignisse aufgerufen. Alle Prozeduren, also auch allgemeine Proze-duren mit Parametern, können von anderen Prozeduren oder Funktionen aus aufge-rufen werden.

Eine Prozedur ohne Parameter sieht folgendermaßen aus:

Public Sub Prozedurname ()� Es folgen die Anweisungen

End Sub

Diese Deklaration kann aber auch über Menü Einfügen�Prozedur oder über dasSymbol Prozedur einfügen erfolgen. Im darauf folgenden Dialog ist der Name derProzedur einzugeben.

Die anderen Einstellungen in diesem Dialog betreffen den Typ, den Gültigkeitsbereichder Prozedur und die Gültigkeitsdauer von Variablen. Die Standardeinstellungenwerden in den meisten Fällen sinnvoll sein.

Aufgerufen wird eine Prozedur von einer anderen Prozedur oder Funktion aus mit derAnweisung Call Prozedurname.

Abb.6: Einfügen einer Prozedur

Prozeduren

Aufruf

Die Anweisung Call können Sie immer weglassen, wodurch Sie die Prozedur nur unter Angabe des Prozedur-namens aufrufen können. Sie können Prozeduren mit der Anweisung Exit Sub innerhalb des Modulkörpersvorzeitig verlassen.

-


Befehle zur Ein- und Ausgabe

Wie kann man Benutzereingaben entgegennehmen? Wie kann man Meldungen am Bildschirmausgeben?

Der MsgBox-Befehl und die MsgBox-Funktion zeigen eine Meldungsbox mit einemfrei definierbaren Text und verschiedenen Schaltflächen an.

Die InputBox-Funktion fordert den Benutzer zur Eingabe eines Textes auf und gibtdiesen als Zeichenkette zurück.

MsgBox Meldungstext, , Titeltext � Anweisung

MsgBox (Meldungstext, Buttons, Titeltext) � Funktion

InputBox (Meldung, Titeltext, Vorgabe)

Meldungstext Frei definierbarer Text, der in der Meldungsbox erscheinen soll.

Buttons Eine Summe von Konstanten, die die Schaltflächen und dasSymbol in der Meldungsbox festlegen. (Optional, wenn nur dieOk-Schaltfläche benötigt wird.)

Titeltext Der Text, der in der Titelleiste der Meldungsbox erscheinen soll.(Optional)

Vorgabe Vorgabetext, der in der Eingabebox erscheinen soll.

Die MsgBox-Funktion gibt abhängig von der Schaltfläche, die der Benutzer angeklickthat, einen Wert zurück, der je nach Schaltflächen mit verschiedenen Konstantenverglichen werden kann.

Die InputBox-Funktion gibt den vom Benutzer eingegeben Text zurück. Klickt derBenutzer auf Abbrechen, wird eine leere Zeichenkette zurückgegeben.

Abb.7: Meldungsbox und Eingabebox

MsgBox

InputBox

Zu Testzwecken können Sie Ausgaben für den Benutzer unsichtbar im Direktbereich bzw. Testfenster vorneh-men. Dazu dient die Anweisung Debug.Print, die auch mit Debug.? abgekürzt werden kann. Nähere Informa-tionen zu diesen Befehlen finden Sie in der Hilfe.

Syntax

Parameter

Rückgabewert

-


Ausführen und Testen eines Programms

Wie kann ich Makros aufrufen? Wie zeige ich den Direktbereich an? Wie kann ich den Inhalt vonVariablen anzeigen?

Allgemeine Prozeduren ohne Parameter werden auch Makros genannt und könnenvon den Office-Programmen (mit Ausnahme von Access) aus direkt als Makrosaufgerufen werden. Dazu dient der Menübefehl Extras�Makro�Makros.

Im Visual Basic-Editor stellt man den Cursor in die entsprechende Prozedur und wähltaus dem Menü Ausführen�Sub/UserForm ausführen.

Der Direktbereich stellt eine weitere Möglichkeit dar, Prozeduren und auch einzelneAnweisungen und Befehle zu testen. Mit dem Befehl Ansicht�Direktbereich kannman diesen ein- und ausblenden. Im Direktbereich gibt man einfach die Anweisung,den Befehl oder den Prozedurnamen ein und drückt die EINGABETASTE. Hier könnenauch Prozeduren mit Parametern und Funktionen getestet werden. Um den Inhalt vonVariablen oder das Ergebnis von Funktionen auszugeben, dient der Befehl Print bzw.?. Z. B. gibt Print Int(3.5) als Ergebnis 3 zurück.

Mit dem Befehl Ansicht�Lokal-Fenster wird ein Fenster angezeigt, das alle lokalenVariablen der aktiven Prozedur mit deren Inhalt anzeigt. Der Befehl Ansicht�Überwachungsfenster zeigt ein Fenster an, in dem man Überwachungsausdrückedefinieren kann, deren Ergebnis hier ständig angezeigt wird. Diese Ausdrückedefiniert man mit dem Befehl Testen�Überwachung hinzufügen....

Abb.8: Direktbereich, Lokalfenster, Überwachungsfenster

Makros ausführen

Prozeduren ausführen

Im Überwachungsfenster lassen sich auch Situationen definieren, bei denen das Programm gestoppt werden soll,was bei der Fehlersuche hilfreich sein kann.

Direktbereich

Lokal-Fenster

-


Einzelschrittmodus

Wie kann ich die Anweisungen eines Programms einzeln ausführen? Welche Möglichkeiten bietet derEinzelschrittmodus?

Häufig muß man ein Programm im Einzelschrittmodus ausführen, um Fehler zufinden. Dazu setzt man an entsprechender Stelle im Programm einen Haltepunkt. DasSetzen und Löschen von Haltepunkten erfolgt durch einen Mausklick in den grauenBereich links neben der entsprechenden Zeile. Stoppt das Programm an diesemHaltepunkt, stehen folgende Befehle zur Verfügung:

Testen�Einzelschritt

Führt die Anweisung aus und stoppt das Programm abermals.

Testen�Prozedurschrittt

Führt die Anweisung aus. Wird hierbei eine andere Prozedur aufgerufen, wirddiese nicht im Einzelschrittmodus ausgeführt.

Testen�Prozedur abschließen

Wurde mit Testen � Einzelschritt in eine andere Prozedur gesprungen, so führtdieser Befehl die Prozedur ohne Pause aus und stoppt nach dem Rücksprung insaufrufende Programm.

Testen�Ausführen bis Cursor-Position

Führt das Programm bis zur Cursor-Position ohne Pause aus.

Ausführen�Fortsetzen

Führt das Programm ohne Pause bis zum nächsten Haltepunkt aus.

Diese Befehle findet man auch auf der Symbolleiste Testen.

Abb.9: Symbolleiste Testen

Haltepunkte

Im Einzelschrittmodus kann man auch die Anweisung festlegen, die als nächstes ausgeführt werden soll, indemman den gelben Pfeil im Code-Fenster zu einer anderen Anweisung zieht.


Zusammenfassen und VertiefenModul 1: Einführung in die Programmierung

1. Visual Basic für Applikationen stellt eine einheitliche Makro-Sprache für alleMicrosoft-Anwendungen dar, die auch anwendungsübergreifendes Programmie-ren erlaubt. Der Visual Basic Editor wird in Word, Excel und Powerpoint über denMenübefehl Extras�Makro�Visual Basic Editor aufgerufen.

2. Im Projekt-Explorer können die Komponenten eines Projektes verwaltet werden,im Eigenschaften-Fenster können die Eigenschaften der Objekte bestimmt wer-den. Der Programm-Code wird in Module eingegeben, die sich über den Menü-befehl Einfügen�Modul erzeugen lassen.

3. Jeder abgeschlossene Programmteil besteht aus einer Schnittstelle, einemDeklarationsteil, dem Eingabeteil, dem Verarbeitungsteil und dem Ausgabeteil.Besonders bei größeren Programmierprojekten ist eine sorgfältige Planung wich-tig.

4. Beim Eingeben des Programm-Codes ist es wichtig, daß jeder Befehl in eine eigeneZeile geschrieben wird. Kommentare werden mit einem Apostroph (�) gekenn-zeichnet.

5. Bei Anweisungen und Befehlen sind die Parameter nie in Klammern zu schreiben,bei Prozeduren hingegen schon. Eine Prozedur kann nie alleine aufgerufenwerden, sondern das Ergebnis muß immer in irgendeiner Weise weiterverarbeitetwerden.

6. Prozeduren werden immer mit dem Schlüsselwort Sub eingeleitet und mit End Subbeendet. Eine Prozedur kann einfach durch Angabe des Prozedurnamens aufge-rufen werden.

7. Mit den Funktionen MsgBox und InputBox können Meldungen an den Benutzerweitergeleitet werden bzw. Eingaben entgegengenommen werden. Mit Debug.Printkann man Testausgaben im Direktbereich vornehmen.

8. Im Direktbereich können Programme und Befehle getestet werden. Über dieBefehle Ansicht�Lokal-Fenster und Ansicht�Überwachungsfenster lassen sichzwei Fenster einblenden, die zur Überwachung der Inhalte von Variablen einge-setzt werden.

9. Im Einzelschrittmodus können fehlerhafte Programme leichter korrigiert werden.Dabei wird nach der Ausführung eines jeden Befehls gestoppt, und man kann dieInhalte von Variablen kontrollieren.

GrundlagenSeite 6

-

EinzelschrittmodusSeite 14

Anweisungen� FunktionenSeite 10

EingabeSeite 9

PlanungSeite 8

Projekte, Eigenschaften,ModuleSeite 7

Testen, AusführenSeite 13

Ein- und AusgabeSeite 12

ProzedurenSeite 11


Modul 2Variablen und Konstanten

Wie kann ich Daten in Programmen zwischenspeichern? Wie kann ich häufig verwendete Wertevordefinieren? Wie kann ich auf eine Reihe gleichartiger Daten am einfachsten zugreifen? WelcheDatentypen gibt es in VBA? Wie lange sind Variablen gültig? Wo kann ich überall Variablen verwenden?


� Konstanten, Variablen, Datenfelder

� Deklaration von Variablen

� Datentypen

� Gültigkeitsbereich

� Gültigkeitsdauer

� Konstanten

� Datenfelder

Lernziel

Der Anwender erlernt den Unterschied zwischen Variablen und Konstanten sowie deren Verwendung imProgramm.

Voraussetzungen

Kenntnis über die Bedienung des Visual Basic-Editors. Kenntnisse über den Unterschied zwischen Projekten,Modulen und Prozeduren sowie über die Deklaration eigener Prozeduren.

-


Konstanten, Variablen, Datenfelder

Wo kann ich Konstanten und Variablen einsetzen? Wie verwende ich Datenfelder?

Fast jedes Programm benötigt Speicherplätze, wo es Werte für eine spätere Verwen-dung zwischenspeichern kann. Man kann sich diese Speicherplätze wie Schubladenvorstellen. Jede Schublade stellt eine Variable dar. Die Beschriftung der Schublade istder Variablenname. In dieser Schublade kann man Werte verschiedenen Typs(Zahlen, Texte, Objekte) speichern. Der Inhalt dieser Variablen läßt sich jederzeitabrufen und verändern.

In vielen Programmen gibt es neben diesen variablen Werten auch eine Anzahl vonkonstanten Werten. Manchmal ist es sinnvoll, auch diesen konstanten Werten Namenzuzuweisen. Man spricht dann von Konstanten. In Visual Basic sind bereits zahlreicheKonstanten vordefiniert. Ihr Name beginnt immer mit vb. Außerdem gibt es spezielleWord-Konstanten, die alle mit wd beginnen, spezielle Excel-Konstanten, die alle mitxl beginnen und spezielle Access-Konstanten, die mit ac beginnen. Konstantenwerden einmal definiert und dürfen über die gesamte Laufzeit eines Programms nichtverändert werden.

Oft will man auf eine größere Anzahl gleichartiger Daten unter dem gleichenVariablennamen zugreifen. Der jeweilige Wert soll dabei meist durch den Inhalt eineranderen Variablen ausgewählt werden. Man kann sich das als Schubladenschrank miteinem bestimmten Namen vorstellen. Die einzelnen Laden werden dabei durchNummern gekennzeichnet. In Programmiersprachen spricht man dabei von Datenfel-dern oder Arrays.

Abb.10: Variablen und Datenfelder

Variablen

Konstanten

Egal ob Sie Variablen, Konstanten oder Datenfelder definieren. Sie können sie alle überall an Stelle von jedemanderen Wert verwenden.

Datenfelder

-


Variablen

Wie deklariere ich Variablen? Welche Datentypen können Variablen haben? Wie kann ich den Inhaltvon Variablen verändern?

Normalerweise müssen Variablen in Basic nicht deklariert werden. Sie werden dannbei der ersten Verwendung automatisch mit dem Datentyp Variant angelegt. Esempfiehlt sich jedoch aus Gründen der Fehlervermeidung und AblaufgeschwindigkeitVariablen vorher zu deklarieren. Man kann die Deklaration von Variablen erzwingen,indem man im Modulkopf (der Bereich am Beginn eines Moduls, bevor die ersteProzedur deklariert wird) die Anweisung Option Explicit eingibt. Wenn man mitdem Befehl Extras�Optionen im Register Editor die Option Variablendeklarationerforderlich aktiviert, wird diese Anweisung in allen neuen Modulen automatischeingefügt.

Variablen können mit verschiedenen Anweisungen entweder im Modulkopf oderinnerhalb einer Prozedur oder Funktion deklariert werden. Dazu verwendet man dieSyntax Dim Variablenname As Datentyp. Statt Dim können auch dieSchlüsselwörter Private, Public und Static verwendet werden, die der Variablen einenunterschiedlichen Gültigkeitsbereich bzw. eine unterschiedliche Gültigkeitsdauergeben.

Der Wert einer Variablen wird mit der Syntax Variablenname = Wert zugewie-sen. Um einer Variablen vom Typ Object oder eines Untertyps von Object ein Objektzuzuordnen, muß die Anweisung Set verwendet werden.

strT = "Text"

Set objO = ActiveWorkbook

Abb.11: Verwendung von Variablen

Deklaration

Schlüsselwörter

Die Schlüsselwörter Dim und Private haben die gleiche Wirkung und können sowohl innerhalb von Prozedurenals auch im Modulkopf verwendet werden. Public kann nur im Modulkopf verwendet werden, Static nurinnerhalb von Prozeduren.

Wertzuweisung

-


Datentypen

Welche Datentypen können Variablen haben? Welche Besonderheiten haben Objekt- und Variant-Variablen?

VBA unterstützt folgende Datentypen:

Boolean 2 Bytes, True (-1) oder False (0)

Byte/Integer/Long 1/2/4 Byte, Ganzzahl, 0 bis 255/-32.768 bis +32.767/-2.147.483.648 bis +2.147.483.647

Single/Double 4/8 Bytes, Fließkommazahl, 7/15 Dezimalstellen

Currency 8 Bytes, Festkommazahl, 4 Nachkommastellen

Decimal 14 Bytes, Fließkommazahl, 29 Dezimalstellen

Date 8 Bytes, Datum/Uhrzeit

String 10 Bytes + Länge der Zeichenkette, Zeichenketten, bis zu ca. 2Milliarden Zeichen Länge

Object 4 Bytes, Verweis auf ein beliebiges Objekt

Variant numerisch: 16 Bytes, String: 22 Bytes + Länge der Zeichenkette,variabler Universal-Datentyp

Variant kann auch die speziellen Werte Empty (nicht initialisiert), Null und Errorannehmen. Diese Werte können mit den Funktionen IsEmpty(), IsNull() und IsError()abgefragt werden. Einen Error-Wert erzeugt man mit der Funktion CVError(Fehler-nummer). Der eigentliche Datentyp einer Variant-Variable kann mit der FunktionVarType() ermittelt werden.

Eine Objektvariable enthält nie das Objekt selbst, sondern nur einen Verweis auf dasObjekt. Mit Set Objektvariable = Nothing wird der Verweis gelöscht.

Abb.12: Übersicht über Datentypen

Datentypen

Variant

Der Datentyp Object sollte möglichst nicht verwendet werden, statt dessen eine Objektklasse, wie z. B.Document, Workbook, Recordset oder Form. Variant ist der Standarddatentyp bei Variablen, deren Typ nichtangegeben wird.

Objekt

-


Gültigkeitsbereiche von Variablen

In welchen Programmteilen ist der Name einer Variablen gültig? Wie kann ich auf Variablen in anderenModulen zugreifen?

Für Variablen gibt es die drei Gültigkeitsbereiche Prozedurebene, Modulebene undProjektebene. Es ist immer empfehlenswert, den Gültigkeitsbereich einer Variablensoweit wie möglich einzuschränken.

Variablen werden auf Prozedurebene mit den Anweisungen Dim, Private oder Staticdeklariert, wobei diese Anweisungen innerhalb der jeweiligen Prozedur, also zwi-schen Sub und End Sub stehen müssen. Diese Variablen sind nur innerhalb derProzedur sichtbar.

Um Variablen für alle Prozeduren im gleichen Modul sichtbar zu machen, verwendetman die Anweisungen Dim oder Private im Modulkopf. Um Variablen im gesamtenProjekt sichtbar zu machen, verwendet man die Anweisung Public im Modulkopf.

Haben Variablen mit unterschiedlichen Gültigkeitsbereichen oder in unterschiedli-chen Modulen den gleichen Namen, hat die Variable mit dem kleineren (näherliegen-den) Gültigkeitsbereich den Vorrang. Wenn also auf Prozedurebene eine Variable mitgleichem Namen wie eine andere auf Modulebene deklariert wird, so ist innerhalb derProzedur nur die lokale Variable sichtbar. Ebenso haben bei NamensgleichheitVariablen im gleichen Modul Vorrang vor Variablen in anderen Modulen.

Abb.13: Sichtbarkeit von Variablen

Gültigkeitsbereich

Prozedurebene

Sie können auf jeden Fall auf Variablen und Prozeduren in anderen und im eigenen Modul zugreifen, indem Siedie Syntax Modulname.Variablenname bzw. Modulname.Prozedurname verwenden.

Modulebene/Projektebene

Namenskonflikte

-


Gültigkeitsdauer

Wie lange bleibt der Inhalt von Variablen erhalten? Kann man die Gültigkeitsdauer auch verändern?

Bei VBA bleibt der Inhalt von Variablen nur solange gültig, bis eines der folgendenEreignisse eintritt:

� Erneutes Kompilieren des Projektes

� Projekt wird neu initialisiert

� Deklaration der Variablen wird verändert

� Projekt wird geschlossen

Variablen, die innerhalb einer Prozedur mit dem Schlüsselwort Dim deklariert wurdensind noch kürzer gültig, nämlich nur bis die Prozedur beendet wird, sie also mit ExitSub oder End Sub verlassen wird. Der Speicherplatz solcher Variablen wird daraufhinfreigegeben. Beim nächsten Aufruf dieser Prozedur werden die Variablen erneut imSpeicher angelegt und neu intialisiert.

Will man den Inhalt von Variablen auf Prozedurebene zwischen zwei Aufrufen dergleichen Prozedur erhalten, so sind diese mit dem Schlüsselwort Static an Stelle vonDim zu deklarieren. Das Schlüsselwort Static kann nicht im Modulkopf verwendetwerden, da alle Variablen auf Modulebene auf jeden Fall statisch sind.

Abb.14: Beispiel einer statischen Variablen

Gültigkeitsbereiche

Lokale Variablen

Sollen alle Variablen einer Prozedur automatisch statisch sein, so kann man das Schlüsselwort Static auch imProzedurkopf verwenden: Public Static Sub Prozedurname (). Die Variablen können dann sowohlmit Dim als auch mit Static deklariert werden, verhalten sich aber in jedem Fall so, als ob Sie sie mit Staticdeklarieren würden.

Static

-


Konstanten

Wie kann ich Konstanten deklarieren? Wann verwendet man Konstanten?

Konstanten werden immer dann verwendet, wenn ein Wert mehrmals im Programmvorkommt, aber nirgends verändert werden darf.

In Visual Basic sind bereits zahlreiche Konstanten vordefiniert. Ihr Name beginntimmer mit vb. Außerdem gibt es spezielle Word-Konstanten, die alle mit wd beginnen,spezielle Excel-Konstanten, die alle mit xl beginnen und spezielle Access-Konstanten,die mit ac beginnen.

Konstanten werden mit dem Schlüsselwort Const deklariert. Die Syntax dafür lautet:

Const Konstantenname = Ausdruck

Als Ausdruck kann ein einfacher Wert, wie z. B. eine Zahl oder ein Text zwischendoppelten Anführungszeichen, dienen. Man kann aber auch Berechnungen an dieserStelle durchführen lassen. In diesen Berechnungen dürfen allerdings keine Variablenund Funktionen vorkommen. Es dürfen aber andere Konstanten darin vorkommen.

Die Konstantendeklaration erfolgt normalerweise im Modulkopf. Mit den Schlüssel-wörtern Public und Private vor Const kann ihr Gültigkeitsbereich definiert werden(sieheKapitel �Gültigkeitsbereich�). Es ist außerdem möglich, mit dem Schlüsselwort Aseinen genauen Datentyp anzugeben und mehrere Konstanten in einer Zeile zudefinieren.

Abb.15: Deklaration von Konstanten

Verwendung

Vordefinierte Konstanten

Konstanten können überall im Programm anstelle des Wertes vorkommen. Sie dürfen aber nicht während derLaufzeit des Programms verändert werden.

Deklaration

Ausdruck

Gültigkeitsbereich/Datentyp

-


Datenfelder

Wie kann man Datenfelder deklarieren? Kann man die Größe von Datenfeldern zur Laufzeit verän-dern?

Man unterscheidet statische und dynamische Datenfelder. Dynamische Datenfelderkönnen ihre Größe im Programmablauf ändern.

Ein statisches Datenfeld wird mit der Anweisung Dim/Private/Static/PublicVariablenname (niedrigste Indexnummer To höchste Indexnummer)As Datentyp deklariert. Die Grenzen für die Indexnummern müssen konstant sein.Werden die niedrigste Indexnummer und das Schlüsselwort To weggelassen, beginntder Index mit 0 zu zählen.

Um ein dynamisches Datenfeld zu deklarieren, läßt man den Wert in Klammern weg,z. B. Dim A() As String. Ein solches Datenfeld muß vor der ersten Verwendungnochmals dimensioniert werden. Das geschieht mit der Anweisung ReDim, die auchmehrmals im Programm erfolgen kann. Dabei geht der Inhalt des Datenfeldesverloren, was mit dem Schlüsselwort Preserve hinter ReDim verhindert werden kann.

Die einzelnen Elemente eines Datenfeldes spricht man über deren Indexnummern inKlammern an. Anstelle einer konstanten Zahl kann diese Indexnummer auch durcheine andere Variable dargestellt werden, z. B.: A(i).

Bei der Deklaration mehrdimensionaler Datenfelder gibt man die Größe jederDimension separat, durch Komma getrennt an. Beim Zugriff auf Elemente einesmehrdimensionalen Datenfeldes muß die Position in jeder Dimension angegebenwerden, z. B. A(0, 2, 5).

Abb.16: Beispiel zur Verwendung von Datenfeldern

Statisch/Dynamisch

Statische Datenfelder

Um die Ober- und Untergrenzen für den Index zu ermitteln, können Sie die Funktionen UBound() und LBound()verwenden.

Dynamische Datenfelder

Indexnummern

MehrdimensionaleDatenfelder


Zusammenfassen und VertiefenModul 2: Variablen und Konstanten

1. Variablen sind eines der wichtigsten Programmierelemente. In ihnen könnenWerte für eine spätere Verwendung zwischengespeichert werden.

2. Konstanten werden mit dem Schlüsselwort Const deklariert. Sie dürfen über diegesamte Laufzeit des Programms nicht verändert werden.

3. Variablen werden mit den Schlüsselwörtern Dim, Private, Public oder Staticdeklariert. Objektvariablen lassen sich nur mit dem Schlüsselwort Set auf einbestimmtes Objekt setzen.

4. Die am häufigsten verwendeten Datentypen sind Integer, Long, Single, Double,String, Variant und Objektklassen. Der Datentyp Variant kann einige besondereWerte, wie Empty oder Null, enthalten.

5. Je nachdem, an welcher Stelle und mit welchem Schlüsselwort man Variablendeklariert, haben sie unterschiedliche Gültigkeitsbereiche. Die möglichen Gül-tigkeitsbereiche sind Projektebene, Modulebene und Prozedurebene.

6. Variablen auf Prozedurebene bleiben normalerweise nur so lange erhalten, wiedie Prozedur läuft, es sei denn, sie werden mit dem Schlüsselwort Static deklariert.Variablen auf Modul- und Projektebene bleiben über die gesamte Laufzeit desProjekts erhalten.

7. Mit Hilfe von Datenfeldern ist es möglich, mehrere Variablen unter dem gleichenNamen, aber mit unterschiedlichen Indexnummern anzusprechen. Es gibt stati-sche Datenfelder, deren Größe sich über die gesamte Laufzeit des Programmsnicht verändert, und dynamische Datenfelder, deren Größe sich jederzeit ändernkann.

VariablenSeite 17

-

GültigkeitsbereichSeite 21

DatentypenSeite 20

Deklaration von VariablenSeite 19

KonstantenSeite 18

GültigkeitsdauerSeite 22-23

DatenfelderSeite 24


Modul 3Prozeduren und Funktionen

Wie kann ich Daten an Prozeduren übermitteln? Wie kann ich eigene Funktionen programmieren? Wiekönnen Prozeduren und Funktionen Ergebnisse zurückgeben? Was sind Parameter? Was verstehtman unter Call By Reference? Was versteht man unter Call by Value? Wie lassen sich optionaleParameter deklarieren?


� Parameter

� Referenzübergabe oder Wertübergabe?

� Funktionen

� Gültigkeitsbereiche

� Optionale Parameter

� Parameterfelder

Lernziel

Der Anwender lernt Möglichkeiten kennen, Eingabewerte an Prozeduren und Funktionen zu übergeben, undErgebnisse zurückzugeben.

Voraussetzungen

Deklaration von Prozeduren und Variablen, Kenntnisse über Datentypen, Gültigkeitsbereiche, Gültigkeitsdauer undDatenfelder.

-


Parameter

Wie deklariere ich Parameter? Wie kann ich an eine Prozedur Eingabewerte übergeben?

Durch die Deklaration von Parametern steht eine klar definierte Schnittstelle für dieEingabewerte einer Prozedur zur Verfügung. Der Nachteil ist, daß Prozeduren mitParametern nicht mehr als Makros, sondern nur mehr von anderen Prozeduren oderFunktionen aus aufgerufen werden können. Sie stellen sozusagen benutzerdefinierteBefehle dar.

Um eine Prozedur mit Parametern zu deklarieren, schreibt man in die Klammern imProzedurkopf den Namen des Parameters, gefolgt vom Schlüsselwort As und einemDatentyp. Mehrere Parameter werden durch Komma getrennt. Wird das Schlüssel-wort As und der Datentyp weggelassen, erhält der Parameter den Datentyp Variant.Beispiele:

Public Sub A (Par1 As Integer, Par2 As String)

Public Sub B (Par3)

Im zweiten Beispiel bekommt Par3 den Datentyp Variant. Beim Aufruf dieserProzeduren sind die Parameter durch Werte, Konstanten oder Variablen des gleichenoder eines kompatiblen Datentyps zu ersetzen, z. B.:

A 20, "Text"

B #01.01.97#

Die übergebenen Parameter können innerhalb der Prozedur wie Variablen unterAngabe des Parameternamens verwendet werden.

Prozeduren mit Parametern können nicht als Makros eingesetzt werden.

Abb.17: Übergabe von Parametern

Schnittstelle

Deklaration

Für Parameter stehen alle Datentypen zur Verfügung, die Sie auch für Variablen verwenden können.

Aufruf

Verwendung

-


Referenzübergabe oder Wertübergabe?

Was ist der Unterschied zwischen Call by Reference und Call by Value?

Parameter können an Prozeduren über Referenz und über den Wert übergebenwerden. Der Unterschied zwischen den beiden Übergabearten wirkt sich nur bei derÜbergabe einer Variablen als Parameter aus.

Bei der Referenzübergabe wird lediglich die Adresse der Variablen übergeben. DieProzedur kann somit die übergebene Variable selbst verändern, was eine Möglichkeitdarstellt, Ergebnisse an die aufrufende Prozedur zurückzugeben, aber auch einezusätzliche Fehlerquelle ist.

Bei der Wertübergabe wird hingegen eine Kopie des Inhaltes der Variablen erzeugtund diese Kopie übergeben. Die Prozedur kann somit die übergebene Variable selbstnicht verändern. Änderungen wirken sich auf die aufrufende Prozedur in keiner Weiseaus, da der Inhalt der Parametervariablen nach Ende der Prozedur verloren geht.

Der Aufruf erfolgt bei einer Referenzübergabe. Referenzübergabe ist die Standardein-stellung.

Bei der Deklaration einer Prozedur definiert man auch, wie die Parameter standard-mäßig übergeben werden. Das geschieht mit den Schlüsselwörtern ByRef und ByValvor dem Parameternamen, z. B.: Public Sub P (ByRef A As Integer, ByValB As Byte).

Beim Aufruf der Prozedur kann man aber diese Voreinstellung ändern, z. B.: P ByValintA, ByRef bytB, wobei intA nun als Wert übergeben wird, während bytB alsReferenz übergeben wird.

Abb.18: Unterschied Referenzübergabe � Wertübergabe

Parameter übergeben

Referenzübergabe

Die Übergabe über Referenz bringt nur dann Geschwindigkeitsvorteile, wenn die Parametervariable nicht zuBeginn der Prozedur in eine lokale Variable kopiert werden muß, um sie vor Veränderungen zu schützen.

Wertübergabe

Standard

ByRef / ByVal

Aufruf

-


Funktionen

Wie kann ich eigene Funktionen definieren? Wie werden eigene Funktionen aufgerufen?

Eigene Funktionen werden wie Prozeduren deklariert. Man ersetzt jedoch dasSchlüsselwort Sub durch Function und schreibt ans Ende der Deklaration As Datentyp,um den Datentyp des Rückgabewertes zu definieren.

Parameter können wie bei Prozeduren deklariert werden. Zusätzlich wird automa-tisch eine Variable deklariert, die den Namen der Funktion und den in der Kopfzeileangegebenen Datentyp erhält. Dieser Variablen weist man das Ergebnis der Funktionzu. Der Inhalt dieser Variablen wird als Ergebnis an die aufrufende Prozedurzurückgegeben. Ähnlich wie Prozeduren können auch Funktionen innerhalb desFunktionskörpers mit der Anweisung Exit Function vorzeitig abgebrochen werden.Beispiel einer Funktion:

Public Function Wurzel (dblZahl As Double, dblExponent _As Double) As Double

Wurzel = Zahl ^ (1 / Exponent)

End Function

Das Ergebnis einer Funktion muß man sofort weiterverarbeiten. Typische Funktions-aufrufe sind z. B.: W = Wurzel (2, 2) oder Debug.Print Wurzel (2, 2) oderMsgBox Wurzel (2, 2). In Excel können benutzerdefinierte öffentliche Funktio-nen auch in Tabellenblättern, in Access in Abfragen, Formularen und Berichtenverwendet werden.

Abb.19: Rückgabe des Ergebnisses

Deklaration

Parameter

Die Parameter von Funktionen stehen im Gegensatz zu jenen der Prozeduren normalerweise immer in Klammern.Besitzt eine Funktion keine Parameter, müssen die Klammern trotzdem geschrieben werden, z. B. MsgBoxGestern ().

Aufruf

-


Gültigkeitsbereiche von Prozeduren

Gibt es bei Prozeduren und Funktionen verschiedene Gültigkeitsbereiche? Wie kann ich dieseeinsetzen?

Um eine Prozedur auf Modulebene zu deklarieren, schreibt man in den Prozedurkopfdas Schlüsselwort Private Sub bzw. bei Funktionen Private Function.

Private Prozeduren können nicht als Makros aufgerufen werden. Private Funktionenkönnen nicht in Excel-Tabellenblättern und in Access weder in Abfragen oderFormularen noch in Berichten verwendet werden. Private Prozeduren und Funktionenkönnen nur innerhalb des Moduls, in dem sie deklariert wurden, aufgerufen werden.

Um eine Prozedur auf Projektebene zu deklarieren, schreibt man in den Prozedurkopfdas Schlüsselwort Public Sub bzw. bei Funktionen Public Function. Public ist Standardbei VBA, kann also auch weggelassen werden.

Öffentliche Prozeduren können, wenn sie keine Parameter verlangen, als Makros inWord, Excel und Powerpoint aufgerufen werden. Öffentliche Funktionen können inExcel-Tabellenblättern und in Access in Abfragen, Formularen und Berichten verwen-det werden. Öffentliche Prozeduren und Funktionen können im ganzen Projektaufgerufen werden.

Bei Namensgleichheit beim Aufruf zwischen einer Prozedur im eigenen Modul undeiner in einem fremden Modul, hat jene im eigenen Modul den Vorrang. Um aufProzeduren und Funktionen in einem fremden Modul zuzugreifen, schreibt manModulname.Prozedurname.

Abb.20: Gültigkeitsbereich bei Prozeduren

Private

Private Prozeduren

Meistens werden Sie Prozeduren und Funktionen mit Public deklarieren. Einzig Ereignisprozeduren sind meistprivate Prozeduren.

Public

Öffentliche Prozeduren

Namenskonflikte

-


Exkurs: Optionale Parameter

Wie kann ich optionale Parameter deklarieren? Wie kann ich überprüfen, ob ein optionaler Parameterübergeben wurde?

Bei vielen eingebauten Befehlen und Funktionen sind manche Parameter optional,wie z. B. bei den Befehlen MsgBox und InputBox.

In eigenen Prozeduren und Funktionen kann man diesen Mechanismus ebenfallsnachbilden. Dazu deklariert man einen oder mehrere Parameter mit dem Schlüssel-wort Optional als optionale Parameter. Beispiele:

Public Sub S1 (Optional P1 As Integer)

Public Sub S2 (P1 As Integer, Optional ByVal P2, OptionalByRef P3)

Das Schlüsselwort Optional steht also immer vor den Schlüsselwörtern ByVal undByRef. Außerdem müssen optionale Parameter immer am Schluß der Parameterlistestehen. Nach dem ersten optionalen Parameter müssen alle folgenden Parameterebenfalls optional sein.

Die beiden obigen Prozeduren können nach Ihrer Deklaration auf folgende Weiseaufgerufen werden:

S1

S1 20

S2 intA

S2 20, "Kunden"

S2 30, , "Lieferanten"

S2 40, "Kunden", "Lieferanten"

Die Funktion IsMissing (Parametername) überprüft auf fehlende Parameter.

Abb.21: Wurzelfunktion

Optionale Parameter

Optimal

Achtung: Die Funktion IsMissing kann nur für Parameter vom Typ Variant eingesetzt werden. Daher verwendetman für optionale Parameter immer nur den Datentyp Variant.

Syntax

Aufruf

IsMissing()

-


Exkurs: Parameterfelder

Wie muß man eine Prozedur deklarieren, bei der die Anzahl der Parameter variabel ist? Wie benutztman Parameterfelder?

In manchen Fällen benötigt man eine Liste von gleichartigen Parametern, wobei derProgrammierer nicht vorhersagen kann, wie viele Parameter übergeben werdenmüssen.

Solche Parameterfelder werden durch dynamische Datenfelder dargestellt. Dazuschreibt man vor dem Parameternamen im Prozedurkopf das Schlüsselwort ParamArray.Nach dem Parameternamen schreibt man eine öffnende und eine schließendeKlammer, z. B. ParamArray Liste().

Folgendes ist dabei zu beachten:

� In einer Parameterliste darf immer nur ein Parameterfeld enthalten sein.

� Das Parameterfeld muß der letzte Parameter in der Parameterliste sein.

� Parameterfelder müssen den Datentyp Variant haben.

� ParamArray darf nicht mit den Schlüsselwörtern Optional, ByVal und ByRefkombiniert werden.

� Parameterfelder sind immer auch optional.

Auf die einzelnen Parameter eines Parameterfeldes greift man auf die gleiche Weisezu, wie bei herkömmlichen Datenfeldern, also über die Indexnummer. Die Unter-grenze von Parameterfeldern beträgt immer 0. Die Anzahl der Parameter im Parameter-feld kann mit der Funktion UBound(Parameterfeld) bestimmt werden. Ist diese Anzahlkleiner als 0, enthält das Parameterfeld keine Parameter.

Beim Aufruf trennt man die Parameter des Parameterfeldes durch Kommas.

Abb.22: Beispiel zur Verwendung eines Parameterfeldes

Liste gleichartiger Parameter

Parameterfelder

Zur Bearbeitung von Parameterfelder verwendet man praktisch immer eine For � Next-Schleife. Diese und andereSchleifen werden in einem späteren Modul behandelt.

Verwendung

Aufruf


Zusammenfassen und VertiefenModul 3: Prozeduren und Funktionen

1. In eigenen Prozeduren lassen sich Parameter deklarieren. Mit Hilfe von Parame-tern lassen sich über eine definierte Schnittstelle Daten an ein Unterprogrammübergeben.

2. Bei der Parameterübergabe über Referenz wird die Adresse der Variablenübergeben, wodurch das Unterprogramm das Original der Variablen verändernkann. Bei der Parameterübergabe über den Wert wird vorher eine Kopie derVariablen erzeugt, wodurch das Unterprogramm das Original der Variablen nichtverändern kann.

3. Funktionen werden mit dem Schlüsselwort Function deklariert. Die Definition desRückgabewertes erfolgt mit Hilfe einer Variablen, die den gleichen Namen wiedie Funktion trägt.

4. Mit den Schlüsselwörtern Public und Private läßt sich der Gültigkeitsbereich vonProzeduren und Funktionen definieren. Es stehen die Gültigkeitsbereiche Projekt-ebene und Modulebene zur Verfügung.

5. Mit dem Schlüsselwort Optional können Parameter deklariert werden, die nichtangegeben werden müssen. Optionale Parameter stehen immer am Ende derParameterliste.

6. Mit dem Schlüsselwort ParamArray lassen sich Parameterfelder deklarieren. MitParameterfeldern kann man eine Reihe gleichartiger Parameter an eine Prozeduroder Funktion übergeben.

ParameterSeite 26

-

Gültigkeitsbereich vonProzedurenSeite 29

FunktionenSeite 28

Referenz- / WertübergabeSeite 27

Optionale ParameterSeite 30

ParameterfelderSeite 31


Modul 4Objekte und Auflistungen

Was ist eine Klasse? Was ist ein Objekt? Was ist eine Auflistung? Wie kann ich auf Elemente einerAuflistung zugreifen? Wie kann ich Eigenschaften verwenden? Wie kann ich Methoden auf Objekteanwenden? Wie kann ich eigene Klassen schaffen? Wie kann ich feststellen, welche Objekte,Eigenschaften und Methoden es gibt?


� Überblick über Klassen, Objekte, Auflistungen, Eigenschaften und Methoden

� Zugriff auf Elemente einer Auflistung

� Arbeiten mit Eigenschaften

� Arbeiten mit Methoden

� Objektkatalog

� With-Anweisung

� Klassenmodule

� Benutzerdefinierte Eigenschaften und Methoden

Lernziel

Der Anwender lernt, mit Klassen, Objekten, Eigenschaften und Methoden umzugehen und eigene Klassen zuerstellen.

Voraussetzungen

Umgang mit Variablen, Prozeduren und Funktionen.

-


Überblick

Was sind Objekte, Auflistungen und Klassen? Wozu dienen Eigenschaften und Methoden?

Gleichartige Objekte mit gleichen Eigenschaften und Methoden werden in Klasseneingeteilt. Jede Anwendung definiert eigene Klassen. Klassen können zur Deklarationvon Objektvariablen eingesetzt werden, z. B.:

Dim frmKundenformular As Form.

Zu den meisten Klassen gibt es eine Auflistung, die alle bestehenden Objekte dieserKlasse zusammenfaßt. Der Name der Auflistung entspricht meist dem Klassennamenin der Mehrzahl, z. B. enthält die Auflistung Forms alle geöffneten Form-Objekte.

Jedes Objekt kann seinerseits Auflistungen, Eigenschaften und Methoden enthalten,die durch seine Klasse bestimmt werden. Auflistungen enthalten untergeordneteObjekte. Z. B. enthält jedes Form-Objekt (Formular) unter anderen eine Controls-Auflistung (Steuerelemente).

Neben den Auflistungen besitzt jedes Objekt eine Reihe von Eigenschaften. DieEinstellungen dieser Eigenschaften unterscheiden es von anderen Objekten dergleichen Klasse. So besitzen z. B. die meisten Objekte eine Name-Eigenschaft, die denNamen des Objekts angibt. Die meisten Eigenschaften von Objekten können ähnlichwie Variablen gelesen und gesetzt werden.

Methoden können mit Funktionen und Prozeduren verglichen werden. Sie können aufein Objekt angewandt werden, das dann eine bestimmte Reaktion zeigt.

Abb.23: Objekte, Eigenschaften, Methoden, Auflistungen

Klassen

Auflistung

Die Wurzel des Objekt-Modells ist in jeder Anwendung das Objekt Application. Sie brauchen es aber nieanzugeben.

Objekt

Eigenschaft

Methode

-


Zugriff auf Elemente einer Auflistung

Wie kann ich auf einzelne Elemente einer Auflistung zugreifen? Wie kann ich auf Objekte zugreifen,deren Namen ich nicht kenne?

Auf Objekte greift man meist dadurch zu, daß man es als Teil einer Auflistunganspricht. Dazu hat man drei Möglichkeiten:

1. Man kennt den Namen des Objektes zum Zeitpunkt der Programmierung, er istalso konstant. Dann schreibt man: Objekt.Auflistung![Objektname]. Objekt ist dasübergeordnete Objekt, das die Auflistung enthält. Handelt es sich hierbei um dasApplication-Objekt, kann es inklusive Punkt weggelassen werden. Beispiel:Application.Forms!Kunden entspricht Forms!Kunden. Handelt es sichum die sogenannte Standard-Auflistung, kann man sie weglassen. Work-books![Telefonkosten.xls]!Worksheets!Prognose entspricht z. B.:Workbooks![Telefonkosten.xls]!Prognose.

2. Man kennt den Namen des Objektes erst zur Laufzeit, er steht also in einer String-Variable. Dann schreibt man grundsätzlich: Objekt.Auflistung(String-variable). Z. B.: Forms(strFormularname) oder Workbooks(strDatei-name).

3. Man kennt den Namen des Objektes nicht, sondern will auf ein Objekt über seinePosition in der Auflistung zugreifen. Man schreibt: Objekt.Auflistung(Index). Diemeisten Auflistungen beginnen bei 0 zu zählen. Z. B. ergibt Forms(0).Name daserste geöffnete Formular. Statt der Indexnummer kann auch eine numerischeVariable stehen.

Die eckigen Klammern um den Objektnamen können weggelassen werden, wennder Name keine Sonder- oder Leerzeichen enthält. Um festzustellen, wie viele

Abb.24: Übersicht über verschiedene Zugriffsmöglichkeiten

Objektname beiProgrammierung bekannt

Objekte eine Auflistung enthält, haben fast alle Auflistungen die Nur-Lese-Eigenschaft Count, z. B. Forms.Count.

Objektname beim Ablaufbekannt

Objektname unbekannt

-


Arbeiten mit Eigenschaften

Wie kann ich Eigenschaften setzen? Wie kann ich auf Eigenschaften zugreifen? Welche Arten vonEigenschaften gibt es?

Eigenschaften werden ähnlich wie Variablen verwendet. Die meisten Eigenschaftenvon Objekten sind Lese-/Schreib-Eigenschaften. Ein Beispiel für so eine Lese-/Schreib-Eigenschaft, die fast jedes Objekt besitzt, ist die Eigenschaft Name, die den Namendes Objekts bestimmt. Es gibt auch Nur-Lese-Eigenschaften. Z. B. besitzen fast alleAuflistungsobjekte die Eigenschaft Count. Ihr Wert kann nur durch das Hinzufügenund Löschen von Objekten aus der Auflistung verändert werden. Bei manchenObjekten (z. B. Access-Formularen) gibt es Eigenschaften, die nur gesetzt werdenkönnen, wenn das Objekt in einem bestimmten Modus (z. B. Entwurfs-Modus)geöffnet wird.

Eigenschaften haben ebenso wie Variablen einen fixen Datentyp. Manche Eigen-schaften stellen wiederum Objekte dar. Z. B. haben Range-Objekte (Bereich in Wordoder Excel) die Eigenschaft Font, die ein Font-Objekt zurückliefert, das seinerseitswieder Eigenschaften wie z. B. Size hat.

In jedem Fall werden Eigenschaften genauso behandelt wie Variablen. Die Syntax fürdas Setzen von Eigenschaften lautet: Objekt.Eigenschaft = Wert. Ist dieEigenschaft ihrerseits ein Objekt, lautet die Syntax natürlich: Set Objekt.Ei-genschaft = Objektverweis.

Zum Lese-Zugriff auf normale Eigenschaften schreibt man: Variable = Ob-jekt.Eigenschaft. Bei Eigenschaften, die Objekte darstellen, schreibt man: SetObjektvariable = Objekt.Eigenschaft.

Abb.25: Verwendung von Eigenschaften

Arten von Eigenschaften

Datentyp

Das Objekt, dessen Eigenschaft Sie verwenden wollen, kann natürlich seinerseits eine Eigenschaft eines Objektessein, das wiederum seinerseits meist in einer Auflistung enthalten ist, z. B. Workbooks![Um-satz.xls]!Soll.Range(�A1:Z1�).Font.Size = 14.

Wertzuweisung

Lesen

-


Arbeiten mit Methoden

Wie kann ich Methoden auf Objekte anwenden? Welche Arten von Methoden gibt es?

Man unterscheidet Prozedurmethoden und Funktionsmethoden. Funktionsmethodenarbeiten ähnlich wie normale Funktionen und liefern einen Wert oder ein Objektzurück. Prozedurmethoden arbeiten hingegen ähnlich wie Prozeduren und liefernkeinen Wert zurück.

Prozedurmethoden werden folgendermaßen angewandt: Objekt.Methode. Da-nach können noch Parameter angeführt sein, die diese Methode benötigt. Die Syntaxdafür ist identisch zu normalen Prozeduren.

Bei Funktionsmethoden muß der Rückgabewert ähnlich wie bei Funktionen sofortweiterverarbeitet werden. Der Aufruf erfolgt daher wie folgt: Variable =Objekt.Methode(). Wie bei Funktionen muß unbedingt das leere Klammernpaarfolgen. Benötigt die Methode Parameter, sind diese in die runden Klammern zuschreiben. Der zurückgelieferte Wert steht anschließend in der angegebenen Varia-blen. Wird ein Objekt zurückgegeben, wie z. B. bei der Methode OpenRecordset inAccess, lautet die Syntax natürlich: Set Objektvariable = Objekt.Methode().

Abb.26: Beispiel zu Methoden

Unterscheidung

Prozedurmethoden

Manche Methoden verlangen keine Parameter. Statt dessen müssen vorher bestimmte Eigenschaften des Objekteskorrekt gesetzt werden. Nähere Informationen zu den Methoden und ihren Parametern finden Sie in der Hilfe derjeweiligen Anwendung.

Funktionsmethoden

-


Objektkatalog

Wie finde ich heraus, welche Objekte, Eigenschaften und Methoden eine Anwendung besitzt? Wiebekomme ich Hilfe zum Objektmodell?

Da kein Programmierer die kompletten Objektmodelle aller Anwendungen auswen-dig können kann, müssen die Anwendungen ihrerseits einen sogenannten Objekt-katalog bereitstellen, der sich im Visual Basic-Editor mit dem Menübefehl Ansicht �Objektkatalog oder der Taste F2 ein- und ausblenden läßt. Sie können auch dasSymbol Objektkatalog verwenden.

Im Objektkatalog-Fenster ist zunächst links oben im Listenfeld die Bibliothek zuwählen, deren Objektkatalog betrachtet werden soll. In der linken Fensterhälfte wähltman die Klasse oder Auflistung, deren Eigenschaften, Methoden und Auflistungen manbetrachten möchte. In der rechten Hälfte erscheinen diese dann. Im unteren Teil desFensters erscheint die Definition des gewählten Elements und Querverweise auf dieübergeordneten Objekte. Mit der Taste F1 erhält man die Hilfe zu diesem Element.

Meist stehen die Bibliothek der jeweiligen Anwendung, die Bibliothek des aktuellenProjekts, die VBA-Bibliothek, die MSForms-Bibliothek und die Office-Bibliothek zurVerfügung.

Weiters ist auch immer die Bibliothek der aktiven Anwendung geladen, z. B. Wordoder Excel. Je nach Anwendung können auch zusätzliche Bibliotheken erscheinen.

Abb.27: Objektkatalog

Anzeigen

Objektkatalog-Fenster

Der Objektkatalog besitzt auch eine Suchfunktion für Elemente im Objekt-Modell.

Bibliotheken

-


With-Anweisung

Wie kann ich den Zugriff auf Objekte beschleunigen? Wie kann ich Schreibarbeit beim Zugriff aufObjekte sparen?

Eine Möglichkeit, mehrere Zugriffe auf ein und dasselbe Objekt zu beschleunigen, ist,das Objekt vorher einer Objektvariablen zuzuordnen und anschließend nur mehr dieObjektvariable zu verwenden, um auf die Eigenschaften und Methoden des Objektszuzugreifen. Der Programmablauf wird aber beschleunigt und Tipp-Arbeit eingespart,wenn man statt dessen das With-Konstrukt verwendet.

Dieses wird mit der Anweisung With Objekt eingeleitet, wobei Objekt ein gültigerVerweis auf ein Objekt sein muß, aber auch eine Objektvariable sein darf. Innerhalbdieses With-Konstrukts schreibt man nun statt dem Objektverweis immer nur einenführenden Punkt (.) oder ein führendes Rufzeichen (!), um auf die Eigenschaften,Methoden und auf die Standard-Auflistung des Objektes zuzugreifen. Am Ende dieserKonstruktion muß die Anweisung End With stehen, z. B.:

With ActiveSheet.Range("A1:Z1").Font

.Bold = True

.Italic = True

.Size = 14

End With

Natürlich kann man innerhalb von With und End With auch auf andere Objektezugreifen, muß aber dabei wie gewohnt die vollständige Syntax verwenden.

Abb.28: Access-Formular in Dialog umwandeln

Wiederholte Objektzugriffe

With

Die With-Konstruktion spart nicht nur Tipp-Arbeit, sondern beschleunigt auch den Programmablauf, da dieObjekt-Adresse von VBA nur einmal berechnet werden muß. Deshalb empfiehlt es sich, Schleifen, die immer aufdas gleiche Objekt zugreifen, mit With und End With zu ummanteln.

Zugriff auf andere Objekte

-


Exkurs: Klassenmodule

Wie kann ich eigene Klassen erstellen? Wie kann ich neue Objekte aus meinen Klassen erzeugen?

Bei der Programmierung ist man nicht auf die fertigen Klassen beschränkt. Um eineeigene Klasse zu definieren, erstellt man ein neues Klassenmodul. Das geschieht mitdem Menübefehl Einfügen � Klassenmodul. Man kann dazu auch das SymbolKlassenmodul einfügen benutzen. Im Eigenschaftenfenster legt man mit der Eigen-schaft Name den Namen der Klasse fest.

Die Eigenschaften und Methoden im Klassenmodul werden durch globale Variablen,Eigenschaftsprozeduren und herkömmliche Prozeduren und Funktionen definiert.

Um ein neues Objekt der eigenen Klasse zu erzeugen, definiert man zunächst eineObjektvariable mit dem Namen der Klasse als Typ:

Dim Objektvariable As Klasse

Statt Dim können natürlich auch die anderen Schlüsselwörter zur Variablendeklarationverwendet werden.

Im zweiten Schritt erzeugt man nun ein neues Objekt der Klasse mit dem SchlüsselwortNew und weist es der Objektvariablen zu:

Set Objektvariable = New Klasse

Nun kann man über die Objektvariable auf alle Eigenschaften und Methoden dereigenen Klasse zugreifen.

Abb.29: Erzeugen neuer Objekte einer Klasse

Einfügen

Eigenschaften undMethoden

Die beiden Schritte der Erstellung kann man auch zu einem Befehl zusammenfassen: Dim ObjektvariableAs New Klasse. Dies hat die gleiche Wirkung wie einzelne Dim- und Set-Anweisungen.

Neue Objekte

New

-


Exkurs: Benutzerdefinierte Eigenschaften und Methoden

Wie kann ich meinen Klassenmodulen eigene Eigenschaften und Methoden hinzufügen? Was sindEigenschaftsprozeduren?

Am einfachsten fügt man durch das Deklarieren einer globalen Variablen im Modul-kopf eine benutzerdefinierte Eigenschaft zu einer eigenen Klasse hinzu: PublicEigenschaftsname As Datentyp. Es handelt sich dabei immer um eine Lese/Schreib-Eigenschaft.

Eigene Methoden sind nichts anderes als Funktionen und Prozeduren in der Klasse.Diese können wie gewohnt deklariert werden. Der Aufruf erfolgt mit der gewohntenSyntax Objekt.Methode(). Auch Parameter sind selbstverständlich möglich.

Eigenschaftsprozeduren erlauben beim Setzen und Lesen von Eigenschaften weitereAktionen durchzuführen, wie z. B. Überprüfungen auf die Korrektheit der Einstellungoder das Setzen von anderen Eigenschaften.

Bei Schreib-/Lese-Eigenschaften benötigt man jeweils zwei Prozeduren mit demgleichen Namen. Die erste dient zum Setzen der Eigenschaft und wird entweder mitPublic Property Let Eigenschaftsname (Wertparameter) für normaleWert-Eigenschaften oder mit Public Property Set Eigenschaftsname(Objektparameter) für Objekt-Eigenschaften deklariert. Der Parameter dieserProzeduren enthält zur Laufzeit den Wert, der dieser Eigenschaft zugewiesen werdensoll.

Bei allen Eigenschaften benötigt man auf jeden Fall eine Funktion, die mit PublicProperty Get Eigenschaftsname () As Datentyp deklariert wird. Diese spezielleFunktion soll den Inhalt der Eigenschaft zurückgeben.

Abb.30: Beispiel eines Klassenmoduls

Öffentliche Variablen

Methoden

Nähere Informationen und Beispiele zu Property-Prozeduren erhalten Sie in der Hilfe unter dem StichwortProperty.

Property Set / Set

Property Get


Zusammenfassen und VertiefenModul 4: Objekte und Auflistungen

1. Mehrere gleichartige Objekte werden zu Klassen zusammengefaßt. Auflistungenenthalten Objekte einer Klasse. Jedes Objekt besitzt Eigenschaften, die das Objektvon anderen der gleichen Klasse unterscheidbar machen, und Methoden, die aufdas Objekt angewandt werden können.

2. Auf Objekte wird im allgemeinen über eine Auflistung zugegriffen. Je nachdem, obder Objektname bekannt ist und zu welchem Zeitpunkt er bekannt ist, greift manauf die Elemente von Auflistungen auf unterschiedliche Weise zu.

3. Auf Eigenschaften eines Objektes wird ähnlich zugegriffen wie auf Variablen. Diemeisten Eigenschaften können sowohl gelesen als auch geschrieben werden, esgibt aber auch Nur-Lese-Eigenschaften.

4. Methoden können auf Objekte angewandt werden. Man unterscheidet Funktions-Methoden, die ein Ergebnis zurückgeben, und Prozedur-Methoden, die ähnlichwie Prozeduren aufgerufen werden.

5. Im Objektkatalog können die Objekte und Klassen und deren Auflistungen,Eigenschaften und Methoden betrachtet werden.

6. Mit Hilfe der With-Anweisung können Zugriffe auf immer das gleiche Objektbeschleunigt und abgekürzt werden.

7. Mit dem Menübefehl Einfügen�Klassenmodul können eigene Klassen definiertwerden. Ein neues Objekt einer Klasse erzeugt man mit dem Schlüsselwort New.

8. Eigene Eigenschaften werden entweder über globale Variablen oder über Property-Prozeduren realisiert. Eigene Methoden werden über Prozeduren und Funktionenin einem Klassenmodul definiert.

ÜberblickSeite 34

-

WithSeite 39

ObjektkatalogSeite 38

MethodenSeite 37

EigenschaftenSeite 36

ZugriffsmöglichkeitenSeite 35

KlassenmoduleSeite 40

Eigene Methoden undEigenschaftenSeit 41


Modul 5Programmstrukturen

Wie kann ich Teile meines Programms wiederholt ausführen? Was ist eine Schleife? Welche Arten vonSchleifen gibt es? Was ist eine Verzweigung? Wie kann ich innerhalb eines Programms verzweigen?Gibt es eine Mehrfach-Verzweigung? Wie kann ich alle Objekte einer Auflistung bearbeiten? Wie kannich alle Elemente eines Datenfeldes bearbeiten?


� Überblick über Schleifen

� For � Next

� For Each � Next

� Do � Loop

� Überblick über Verzweigungen

� If � Then � Else

� Select Case � End Select

Lernziel

Der Anwender lernt Möglichkeiten kennen, Programmteile wiederholt ausführen zu lassen und innerhalb desProgramms zu verzweigen.

Voraussetzungen

Umgang mit Objekten und Auflistungen

-


Überblick über Schleifen

Was ist eine Schleife? Welche Arten von Schleifen gibt es? Wie oft wird eine Schleife ausgeführt?

Schleifen sind eines der wichtigsten Programmelemente. Mit ihnen ist es möglich,Programmteile wiederholt ausführen zu lassen.

Jede Schleife besteht aus einem Schleifenkopf mit einer einleitenden Anweisung,einem Schleifenkörper und einem Schleifenfuß mit einer abschließenden Anweisung.Der Schleifenkörper enthält die Anweisungen, die innerhalb der Schleife wiederholtausgeführt werden sollen.

Wie oft der Schleifenkörper wiederholt wird, hängt von einer Abbruchbedingung ab.Jede Schleife braucht eine Abbruchbedingung. Wenn diese erfüllt wird, wird dieSchleife beendet.

Grundsätzlich unterscheidet man zwei Arten von Schleifen: Post- und Pre-Check-Schleifen.

Bei Pre-Check-Schleifen wird die Abbruchbedingung bereits überprüft, bevor derSchleifenkörper das erste Mal ausgeführt wird, der Schleifenkörper kann also auch garnicht ausgeführt werden. Meist steht die Abbruchbedingung einer Pre-Check-Schleifeim Schleifenkopf.

Bei Post-Check-Schleifen wird die Abbruchbedingung erst überprüft, nachdem derSchleifenkörper das erste Mal ausgeführt wurde. Sie werden folglich zumindesteinmal ausgeführt. Meist steht die Abbruchbedingung bei einer Post-Check-Schleifeim Schleifenfuß.

Abb.31: Elemente einer Schleife

Wiederholungen

Elemente

Achten Sie beim Formulieren einer Schleife besonders auf die Abbruchbedingung. Sie ist eine der häufigstenQuellen für Programmierfehler.

Abbruchbedingung

Arten

Pre-Check

Post-Check

-


For�Next

Wie kann ich eine Schleife mit einer fixen Anzahl von Wiederholungen programmieren?

Die For�Next-Schleife ist eine sogenannte Zählschleife. Sie benötigt eine Zähler-variable, die bei jedem Durchlauf um eine bestimmte Schrittweite erhöht oderreduziert wird. Überschreitet sie ihren Endwert, wird die Schleife beendet. Merkmalvon Zählschleifen ist, daß die Anzahl der Wiederholungen vorher bekannt ist.

Die Zählvariable einer For�Next-Schleife sollte vorher deklariert werden und hatmeist einen ganzzahligen Datentyp, wie z. B. Byte, Integer oder Long.

So formulieren Sie eine For � Next-Schleife:

For Zählvariable = Startwert To Endwert Step _Schrittweite

� Schleifenkörper

Next Zählvariable

Wird das Schlüsselwort Step und die Schrittweite weggelassen, beträgt sie immer 1.Es sind auch negative Schrittweiten erlaubt. Beim Schlüsselwort Next kann der Nameder Zählvariablen auch weggelassen werden.

Die For�Next-Schleife ist eine Pre-Check-Schleife, das bedeutet, daß der Schleifen-körper nicht ausgeführt wird, wenn der Endwert kleiner oder gleich (positive Schritt-weite) bzw. größer oder gleich dem Startwert ist.

Soll die For-Next-Schleife noch vor Erreichen des Endwertes innerhalb des Schleifen-körpers verlassen werden, verwendet man die Anweisung Exit For.

Abb.32: Beispiel einer For�Next-Schleife

Zählschleife

Zählvariable

Beachten Sie: Der Inhalt der Zählvariablen ist am Ende der Schleife nicht gleich dem Endwert, sondern berechnetsich aus der Formel: Endwert + Schrittweite.

For�Next-Schleife

Step

Pre-Check-Schleife

Exit For

-


For Each�Next

Wie kann ich alle Objekte in einer Auflistung auf die gleiche Weise behandeln?

Eine Variante der For�Next-Schleife stellt die For Each�Next-Schleife dar. Sie wirdausschließlich zur Bearbeitung von Auflistungen eingesetzt.

An Stelle einer Zählervariable steht bei diesem Schleifentyp eine Objektvariable.Diese verweist bei jedem Durchlauf des Schleifenkörpers auf das jeweils nächsteObjekt in der Auflistung, solange bis alle Objekte der Auflistung durchlaufen wurden.

So formulieren Sie eine For Each�Next-Schleife:

For Each Objektvariable In Auflistung

Schleifenkörper

Next Objektvariable

Innerhalb des Schleifenkörpers können dann die Eigenschaften und Methoden desjeweiligen Objektes in der Auflistung wie gewohnt mit der Syntax Objekt-variable.Eigenschaft oder Objektvariable.Methode verwendet werden.

Auch bei der For Each�Next-Schleife kann die Objektvariable beim SchlüsselwortNext weggelassen werden.

Auch dieser Schleifentyp ist eine Pre-Check-Schleife. Sind in der Auflistung keineObjekte enthalten, wird der Schleifenkörper kein einziges Mal ausgeführt.

Wie die For�Next-Schleife kann auch diese Schleife mit der Anweisung Exit Forvorzeitig beendet werden.

Abb.33: Beispiel einer For Each-Next-Schleife

Auflistung

Objektvariable

Beachten Sie: For Each�Next-Schleifen können nicht dazu verwendet werden, alle Objekte aus einer Auflistungzu entfernen. Dazu muß die Auflistung rückwärts mit einer For�Next-Schleife durchlaufen werden.

Syntax

Schleifenkörper

Pre-Check-Schleife

Exit For

-


Do�Loop

Wie kann ich Schleifen mit allgemeiner Abbruchbedingung formulieren?

Die Do�Loop-Schleife ist der flexibelste Schleifentyp in VBA. Er erlaubt sowohl einepositive als auch eine negative Formulierung der Abbruchbedingung. Diese Schleifekann sowohl eine Pre- als auch eine Post-Check-Schleife sein. Allgemein sieht eineDo-Loop-Schleife so aus:

Do [Abbruchbedingung]

Schleifenkörper

Loop [Abbruchbedingung]

Will man eine Pre-Check-Schleife formulieren, schreibt man die Abbruchbedingungin den Schleifenkopf neben Do, bei einer Post-Check-Schleife in den Schleifenfußneben das Schlüsselwort Loop. Es ist nicht erlaubt, Abbruchbedingungen sowohl inden Schleifenkopf als auch in den Schleifenfuß zu schreiben.

Die Abbruchbedingung wird entweder mit dem Schlüsselwort While oder mit Untileingeleitet. Verwendet man While, wird die Schleife solange ausgeführt, solange dieBedingung neben While erfüllt, also True ist.

Verwendet man Until, wird die Schleife ausgeführt, bis die Bedingung neben Untilerfüllt, also True ist. Jede Formulierung mit Until läßt sich in eine While-Formulierungumkehren und umgekehrt.

Ähnlich wie die anderen Schleifen läßt sich eine Do�Loop-Schleife mit der AnweisungExit Do auch innerhalb des Schleifenkörpers vorzeitig beenden.

Abb.34: Beispiel von zwei verschachtelten Do-Loop-Schleifen

Do-Loop-Schleife

Abbruchbedingung

Die Do�Loop-Schleife ersetzt die in manchen älteren Basic-Dialekten verwendete While�Wend-Schleife. DieWhile�Wend-Schleife ist aber auch in VBA noch vorhanden.

While

Until

Exit Do

-


Überblick über Verzweigungen

Welche Arten von Verzweigungen gibt es? Wie formuliert man Bedingungen?

Bei einer Einfachverzweigung wird ein bestimmter Programmteil nur ausgeführt,wenn eine Bedingung erfüllt ist. Bei einer Zweifachverzweigung gibt es zusätzlichnoch einen zweiten Zweig, der dann ausgeführt wird, wenn die Bedingung nichterfüllt ist. Mehrfachverzweigungen stellen hingegen eine unbegrenzte Anzahl vonverschiedenen Zweigen zur Verfügung.

Ein- und Zweifachverzweigungen erfolgen so wie Do � Loop-Schleifen auf der Basisvon sogenannten Booleschen Ausdrücken. Boolesche Ausdrücke haben als Ergebnisimmer entweder True oder False. Boolesche Ausdrücke können auch Variablen vomTyp Boolean zugewiesen werden. Der einfachste Boolesche Ausdruck besteht auseiner Variablen vom Typ Boolean.

Die wichtigsten Vergleichsoperatoren in VBA sind: = (gleich), > (größer als), < (kleinerals), >= (größer oder gleich), <= (kleiner oder gleich) und <> (ungleich). Um zuüberprüfen, ob zwei Objektvariablen auf das gleiche Objekt verweisen, verwendetman den Operator Is.

Mehrere Vergleiche lassen sich logisch mit den Operatoren And (logisches Und) undOr (logisches Oder) verknüpfen. And hat dabei Vorrang vor Or, es sei denn, manverwendet Klammern. Der Operator Not invertiert das Ergebnis, das heißt aus Truewird False und aus False wird True.

Abb.35: Arten von Verzweigungen

Arten

Boolesche Ausdrücke

Für weitere Informationen und Beispiele suchen Sie in der Hilfe nach dem Stichwort Vergleichsoperatoren.

Vergleichoperatoren

Logische Operatoren

-


If�Then�Else

Wie kann ich Ein- und Zweifachverzweigungen in VBA realisieren? Können die Zweige auch mehrereBefehle enthalten?

Für Ein- und Zweifachverzweigungen steht in VBA die Anweisungsfolge If�Then�Elsezur Verfügung.

Wenn nur ein Befehl unter die Bedingung fällt, schreibt man:

If Boolescher Ausdruck Then Befehl oder Anweisung

Die zweite Möglichkeit kann auch dann eingesetzt werden, wenn mehrere Befehleunter die Bedingung fallen.

If Boolescher Ausdruck Then � Befehle oder AnweisungenEnd If

In beiden Fällen werden die Befehle oder Anweisungen nur ausgeführt, wenn derBoolesche Ausdruck True oder einen Wert ungleich 0 ergibt.

Bei Zweifachverzweigungen wird der zweite Zweig, der nur ausgeführt wird, wennder Boolesche Ausdruck False oder einen Wert gleich 0 ergibt, mit dem SchlüsselwortElse eingeleitet:

If Boolescher Ausdruck Then Befehl/Anweisung Else _Befehl/Anweisungbzw.If Boolescher Ausdruck Then � Befehle oder AnweisungenElse � Befehle oder AnweisungenEnd If

Abb.36: Rabatt in Prozentzahl umwandeln

Einfachverzweigung

Zweifachverzweigung

If�Then�Else-Anweisungen lassen sich natürlich auch schachteln.

-


Select Case�End Select

Wie kann ich in VBA eine Mehrfachverzweigung formulieren? Wie muß ich die Vergleichsausdrückeformulieren?

Mehrfachverzweigungen werden in VBA mit dem Konstrukt Select Case � Case � CaseElse � End gebildet, das etwa so aussieht:

Select Case Testausdruck

Case Vergleich1

� Befehle oder Anweisungen

Case Vergleich2


...

Case Else


End Select

Der Testausdruck ist kein Boolescher Ausdruck, sondern ein herkömmlicher Aus-druck, z. B. eine numerische Variable. Bei den Vergleichsausdrücken gibt man einenanderen Ausdruck an, normalerweise eine Zahl oder einen Text zwischen Anfüh-rungszeichen. Bei Gleichheit werden die Befehle oder Anweisungen ausgeführt. EinBereich, in dem der Testausdruck liegen kann, wird mit dem Schlüsselwort Toangegeben, z. B. 1 To 10. Um die Vergleichsoperatoren >, <, >=, <= und <> zuverwenden, muß das Schlüsselwort Is vorangestellt werden.

Der Case Else-Zweig kann weggelassen werden. Dieser Zweig wird nur ausgeführt,wenn kein einziger anderer Case-Zweig zutreffend war.

Abb.37: Beispiel einer Select Case-Struktur

Mehrfachverzweigung

Syntax

Für weitere Informationen und Beispiele suchen Sie in der Hilfe unter dem Stichwort Select-Anweisung.

Testausdruck

Case Else


Zusammenfassen und VertiefenModul 5: Programmstrukturen

1. Schleifen bestehen aus einem Schleifenkopf, einem Schleifenkörper und einemSchleifenfuß. Je nachdem, ob die Abbruchbedingung vor oder nach dem erstma-ligen Durchlauf des Schleifenkörpers überprüft wird, unterscheidet man Pre- undPost-Check-Schleifen.

2. For�Next-Schleifen werden dann eingesetzt, wenn die Anzahl der Wiederholun-gen vor Eintritt in die Schleife bekannt ist. For�Next-Schleifen sind Pre-Check-Schleifen.

3. Zur Bearbeitung von Auflistungen werden For Each�Next-Schleifen eingesetzt.Diese sind mit den For�Next-Schleifen eng verwandt.

4. Für allgemeine Schleifen, die Pre- oder Post-Check-Schleifen sein können, ver-wendet man die Schlüsselwörter Do�Loop.

5. Man unterscheidet Ein-, Zwei- und Mehrfachverzweigungen. Für die Bedingungbei Ein- und Zweifachverzweigungen verwendet man Boolesche Ausdrücke, dieTrue oder False ergeben.

6. Ein � und Mehrfachverzweigungen werden mit If�Then � Else�End If erzeugt. DerElse-Zweig ist dabei optional.

7. Für Mehrfachverzweigungen gibt es die Schlüsselwörter Select Case�Case�CaseElse�End Select. Auch hier ist der Case Else-Zweig optional.

SchleifenSeite 44

-

If�Then�ElseSeite 49

Select CaseSeite 50

VerzweigungenSeite 48

Do�LoopSeite 47

For Each�NextSeite 46

For�NextSeite 45


Modul 6Fehlerbehandlung

Wie kann ich auf Fehler überprüfen? Wie kann ich Laufzeitfehler abfangen? Wie kann ich eigeneLaufzeitfehler erzeugen? Wie werden Fehler behandelt?


� Benutzerdefinierte Fehlerroutinen

� Auslösen von benutzerdefinierten Fehlern

� Hierarchie der Fehlerroutinen

Lernziel

Der Anwender lernt Möglichkeiten kennen, Fehler abzufangen und eigene Fehler zu definieren.

Voraussetzungen

Prozeduren, Verzweigungen, Objekte und Eigenschaften.

-


Benutzerdefinierte Fehlerroutinen

Wie kann ich Laufzeitfehler abfangen? Wie werden Fehlerroutinen programmiert?

Um Laufzeitfehler abzufangen, muß man die Standard-Fehlerbehandlung mit derAnweisung On Error Goto Sprungmarke durch benutzerdefinierte Fehler-routinen ersetzen. Im Programm sieht das dann so aus:

On Error Goto Sprungmarke

Anweisungen und Befehle

Exit Sub � in Funktionen Exit Function

Sprungmarke:

� Anweisungen und Befehle zur Fehlerbehandlung

Resume � oder Resume Next

Die Fehlerroutine wird mit Resume oder Resume Next abgeschlossen. Resume führtden Befehl, der den Fehler verursacht hat, noch einmal aus, während Resume Nextmit dem nächsten Befehl weitermacht.

Um wieder die eingebaute Fehlerbehandlung zu aktivieren, verwendet man On ErrorGoto 0.

Das Objekt Err enthält u. a. die aktuelle Fehlernummer. Enthält Err den Wert 0, so istkein Fehler aufgetreten.

Man kann auf die Fehlerroutine auch verzichten. Dazu schreibt man in das Programmdie Anweisung On Error Resume Next. Nun kann man nach jedem Befehl, der einenFehler hervorrufen könnte, Err.Number auf einen Wert ungleich 0 überprüfen, z. B.If Err Then ...

Abb.38: Beispiel einer Fehlerbehandlung

On Error Goto

Resume

Um Fehlernummern schnell herauszufinden, erzeugen Sie den Fehler zunächst ohne aktivierte Fehlerroutine undnotieren die Fehlernummer, die VBA meldet.

On Error Goto 0

Err

On Error Resume Next

-


Exkurs: Auslösen von benutzerdefinierten Fehlern

Wie kann ich selbst Fehler auslösen? Was passiert mit meiner Prozedur, wenn ich selbst einen Fehlerauslöse?

Besonders in allgemein gültigen Prozeduren und Funktionen, die in vielen verschie-denen Projekten verwendet werden sollen, ist eine gute Fehlerprüfung notwendig.

Da solche Fehler meist vom Programmierer verursacht werden, der die Prozedur oderFunktion falsch verwendet, sollte der Anwender damit nicht in Form eines MsgBox-Befehls behelligt werden. Ebensowenig ist es sinnvoll, die Fehlermeldung im Direkt-fenster mit Debug.Print auszugeben, da sie dort leicht übersehen werden kann. Stattdessen sollte man wie bei eingebauten Befehlen einen Laufzeitfehler auslösen.

Dies geschieht mit der Raise-Methode des Err-Objekts. Die Syntax lautet: Err.RaiseFehlernummer. Die Fehlernummer kann sowohl eine schon vorhandene sein, dieden Fehler gut beschreibt, als auch eine neue. Die Raise-Methode besitzt noch weitereParameter, z. B. für einen Hilfetext oder eine Fehlerbeschreibung. Für nähereInformationen dazu suchen Sie in der Hilfe unter dem Stichwort Raise-Methode.

Eine Prozedur oder Funktion, die diese Raise-Methode auslöst, wird sofort beendet.Die Fehlerbehandlung sollte in der aufrufenden Prozedur oder Funktion erfolgen.

Abb.39: Auslösen eines benutzerdefinierten Fehlers

Fehlerprüfung

Laufzeitfehler

Für Informationen über die vordefinierten Fehlercodes aller auffangbaren Fehler suchen Sie in der Hilfe unter demStichwort Auffangbare Fehler.

Raise

Fehlerbehandlung

-


Hierarchie der Fehlerroutinen

Was passiert, wenn innerhalb einer Fehlerroutine wieder ein Fehler auftritt? Was passiert, wenn keineFehlerroutine definiert wurde?

Wenn man mit Hilfe der On Error Goto-Anweisung eine benutzerdefinierte Fehler-routine aktiviert hat, darf innerhalb dieser Fehlerroutine kein weiterer Fehler ausgelöstwerden. In diesem Fall reagiert VBA so, als ob keine Fehlerroutine definiert wäre.

Ist in einer Prozedur oder Funktion keine Fehlerroutine definiert und es tritt ein Fehlerauf, wird in jener Prozedur oder Funktion nach einer aktivierten Fehlerroutinegesucht. Wird eine solche gefunden, wird sie statt dessen ausgeführt. Nach Beendi-gung dieser Fehlerroutine springt VBA automatisch wieder in das Unterprogramm.Wird in der aufrufenden Prozedur wieder keine Fehlerroutine gefunden, so versuchtes VBA eine Stufe höher usw.

Ist in keiner Prozedur oder Funktion der Aufruf-Kette eine Fehlerroutine vorhanden,so springt VBA wieder zurück zu jenem Befehl, der den Fehler verursacht hat undstoppt mit einer Fehlermeldung.

Um nun Fehler in einer Fehlerroutine abzufangen, stehen zwei Möglichkeiten zurVerfügung:

� Behandlung des Fehlers in der Fehlerroutine der aufrufenden Prozedur oderFunktion

� Aufruf einer Prozedur zur Behandlung des Fehlers

Der Aufruf einer Prozedur innerhalb einer Fehlerroutine hat den Vorteil, daß dieseProzedur ihrerseits wieder eine eigene Fehlerroutine besitzen kann.

Abb.40: Programmablauf bei Fehlerbehandlung

Fehler in Fehlerroutine

Rücksprung zur Fehler-behandlung

Für weitere Informationen und Beispiele suchen Sie in der Hilfe nach dem Stichwort On Error-Anweisung.

Keine Fehlerroutine

Fehler abfangen


Zusammenfassen und VertiefenModul 6: Fehlerbehandlung

1. Benutzerdefinierte Fehlerroutinen werden mit On Error Goto definiert. Fehlerkönnen aber auch mit On Error Resume Next abgefangen werden. In jedem Fallenthält das Objekt Err die Fehlernummer des aufgetretenen Fehlers.

2. Mit Err.Raise können in Prozeduren benutzerdefinierte Fehler ausgelöst werden.

3. Kann ein Fehler in einer Prozedur nicht durch eine Fehlerroutine behandeltwerden, wird versucht, den Fehler in der aufrufenden Prozedur durch eineFehlerroutine zu beheben. Wenn es nirgends Fehlerroutinen gibt, stoppt VBA miteiner Standard-Fehlermeldung an der Stelle, die den Fehler ursprünglich verur-sacht hat.

Definierte FehlerroutinenSeite 53

-

FehlerbehandlungSeite 55

AuslösenSeite 54


Modul 7Formulare und Dialogfelder

Wie kann ich eigene Dialogfelder gestalten? Wie füge ich Steuerelemente zu Dialogfeldern hinzu? Wiekann ich das Layout von Dialogfeldern verändern? Welche Eigenschaften haben Steuerelemente? Wiekann ich die Eigenschaften von Steuerelementen verändern? Wie kann ich Dialogfelder aufrufen? Wielese ich Daten aus den Steuerelementen?


� Erstellen von Dialogfeldern

� Hinzufügen von Steuerelementen

� Ändern der Größe und Position von Steuerelementen

� Eigenschaften von Steuerelementen

� Ereignisprozeduren

� Anzeigen von Dialogfeldern

Lernziel

Der Anwender lernt, eigene Dialogfelder zu gestalten und zu programmieren. Dieses Modul ist nicht auf Accessanzuwenden.

Voraussetzungen

Umgang mit Objekten, Auflistungen, Eigenschaften und Methoden.

-


Erstellen von Dialogfeldern

Wie kann ich eigene Dialogfelder gestalten? Was sind die wichtigsten Eigenschaften von Dialog-feldern?

Für Dialogfelder in Word, Excel und Powerpoint steht die Bibliothek MSForms zurVerfügung. In Access werden zu diesem Zweck die in Access integrierten Formulareverwendet.

Um dem Projekt ein neues Dialogfeld hinzuzufügen, wählt man aus dem Menü desVisual Basic-Editors Einfügen�UserForm. Man kann dazu auch das Symbol UserFormeinfügen verwenden. Es erscheint daraufhin ein leeres Formular und die Werkzeug-sammlung. Die Werkzeugsammlung läßt sich mit dem Menübefehl Ansicht�Werkzeug-sammlung oder dem Symbol Werkzeugsammlung ein- und ausblenden. Das neueUserForm-Objekt erscheint im Projekt-Explorer in der Kategorie Formulare.

Im Eigenschaftenfenster lassen sich für das neue UserForm viele wichtige Eigenschaf-ten festlegen. Die wichtigsten sind:

Name der Name des UserForm-Objekts

Caption die Beschriftung in der Titelleiste

SpecialEffect 3D-Effekt für das Formular

BackColor Hintergrundfarbe

ForeColor Vordergrundfarbe

BorderColor Rahmenfarbe

BorderStyle ob ein Rahmen angezeigt wird

Abb.41: Erstellen eines UserForms

MS Forms

Einfügen eines UserForms

Weitere Informationen und Beispiele zu benutzerdefinierten Dialogfeldern finden Sie in der Hilfe unter demStichwort Erstellen von Dialogfeldern.

Eigenschaften

-


Hinzufügen von Steuerelementen

Welche Steuerelemente stehen in UserForms zur Verfügung? Wie füge ich Steuerelemente in meinUserForm ein?

In UserForms stehen folgende Steuerelemente zur Verfügung:

Bezeichnungsfeld Beschriftungen im Formular

Textfeld Eingabefelder

Kombinationsfeld Kombination aus Textfeld und Listenfeld

Listenfeld Auswahl aus mehreren Elementen

Kontrollkästchen Ja/Nein-Auswahl

Rahmen Gruppierung von Optionsfeldern

Optionsfeld Auswahl aus mehreren Optionen

Umschaltfläche Ja/Nein-Auswahl

Befehlsschaltfläche Aufruf von Programmen

Register Verschiedene Registerseiten in einem UserForm

Multiseiten Zusätzliche Formularseiten in einem UserForm

Bildlaufleiste Auswahl von Werten

Drehfeld Auswahl von Werten

Anzeige Grafik

Um ein Steuerelement dem Formular hinzuzufügen, ziehen Sie entweder das entspre-chende Element aus der Werkzeugsammlung in das UserForm, oder wählen Sie dasElement in der Werkzeugsammlung aus und ziehen anschließend einen Rahmen imUserForm auf, der die Größe des Steuerelements angibt.

Abb.42: Werkzeugsammlung

Steuerelemente

Hinzufügen

Je nach Steuerelement stehen im Eigenschaftenfenster eine Reihe von unterschiedlichen Eigenschaften zurVerfügung. Verwenden Sie diese Eigenschaften, um die Steuerelemente nach Ihren Bedürfnissen einzustellen.Vor allem sollten Sie die Eigenschaft Name bei jedem Steuerelement sinnvoll belegen.

-


Ändern der Größe und Position von Steuerelementen

Wie kann ich Steuerelemente auswählen? Wie kann ich Größe und Position von Steuerelementenändern?

Um ein Steuerelement anzuwählen, klickt man es mit der Maus einmal an. Dabei istzu beachten, daß das Symbol Objekte auswählen in der Werkzeugsammlung aktiviertist. Man kann aber auch die TABULATOR-Taste so oft betätigen, bis das gewünschteSteuerelement ausgewählt ist. Zum jeweils ausgewählten Steuerelement kann man imEigenschaften-Fenster verschiedene Einstellungen vornehmen.

Um mehrere Steuerelemente auszuwählen, gibt es zwei Möglichkeiten: Entwederman wählt das erste Steuerelement aus, hält dann die STRG-Taste gedrückt und wähltdann alle anderen Steuerelemente aus. Oder man zieht mit der Maus einen Rahmenum die Steuerelemente herum auf, die man auswählen will. Alle Steuerelemente, dievom Rahmen berührt werden, werden ausgewählt.

Hat man ein oder mehrere Steuerelemente ausgewählt, kann man es verschieben,indem man den Rahmen um das Steuerelement herum mit der Maus an eine anderePosition zieht. Waren dabei mehrere Steuerelemente ausgewählt, werden alle ande-ren Steuerelemente auch verschoben.

Um die Größe eines ausgewählten Steuerelements zu verändern, zieht man mit derMaus einen der 8 Ziehpunkte auf die gewünschte Größe.

Abb.43: Markierung eines Steuerelements

Markieren

Mehrfachmarkierung

Damit Sie bequem Steuerelemente sauber im Formular ausrichten können, stehen Ihnen im Menü Formatverschiedene Befehle zur Ausrichtung zur Verfügung.

Verschieben

Größe ändern

-


Eigenschaften von Steuerelementen

Was sind die wichtigsten Eigenschaften von Steuerelementen? Wie kann ich die Eigenschafteninnerhalb des Programms ändern?

Name Legt den Namen des Steuerelements fest.

Caption Legt die Beschriftung des Steuerelements fest.

Value Gibt den eigentlichen Wert des Steuerelements an.

Text Gibt den Text im Steuerelement an.

Enabled Legt fest, ob der Benutzer den Fokus auf das Steuerelement setzenkann.

Locked Gibt an, ob das Steuerelement bearbeitet werden kann.

Visible Gibt an, ob das Steuerelement sichtbar ist.

Font Legt die Schriftart des Steuerelements fest.

ForeColor Legt die Vordergrundfarbe fest.

BackColor Gibt die Hintergrundfarbe des Steuerelements an.

BackStyle Gibt an, ob der Hintergrund transparent ist oder nicht.

BorderColor Gibt die Rahmenfarbe an.

BorderStyle Gibt an, ob ein Rahmen gezogen werden soll.

SpecialEffect Legt einen 3D-Effekt für das Steuerelement fest.

ControlTipText Legt einen QuickTip für das Steuerelement fest.

TextAlign Gibt die Textausrichtung an.

GroupName Gibt bei Optionsfeldern einen gemeinsamen Gruppennamen an.

Abb.44: Eigenschaften eines Textfeldes

Eigenschaften

Für nähere Informationen zu einer Eigenschaft klicken Sie mit der Maus auf die Eigenschaft und drücken Sie dieF1-Taste.

-


Ereignisprozeduren

Welche Ereignisse können in einem Formular auftreten? Wie schreibt man Ereignisprozeduren?

Um zu einem Formular Ereignisprozeduren zu schreiben, wechselt man mit demMenübefehl Ansicht � Code in die Code-Ansicht des Formulars. Darin wählt man imlinken Listenfeld das Objekt, das ein Ereignis auslöst, und im rechten Listenfeld dasEreignis aus. VBA erstellt daraufhin automatisch den Rumpf für die Ereignisprozedur,die nur mehr mit Code gefüllt werden muß.

Die wichtigsten Ereignisse des UserForm-Objekts:

Initialize Tritt ein, wenn das Objekt geladen wird.

Terminate Tritt ein, wenn das Objekt entladen wird.

QueryClose Tritt ein, wenn der Benutzer versucht, das Formular zu schließen.

Die wichtigsten Ereignisse von Steurelementen:

BeforeUpdate Tritt ein, bevor die Value-Eigenschaft des Steuerelements durchden Benutzer geändert wird.

AfterUpdate Tritt ein, nachdem die Value-Eigenschaft des Steuerelements durchden Benutzer geändert wurde.

Change Tritt ein, wenn sich die Value-Eigenschaft geändert hat.

Enter Tritt ein, wenn das Steuerelement den Fokus erhält.

Exit Tritt ein, wenn das Steuerelement den Fokus verliert.

Click Tritt ein, wenn der Benutzer auf das Steuerelement klickt.

DblClick Tritt ein, wenn der Benutzer auf das Steuerelement doppelklickt.

Abb.45: Erstellen von Ereignisprozeduren

Code-Ansicht

Ereignisse

Einige Ereignisse übergeben automatisch Parameter. Für weitere Informationen zu Ereignissen suchen Sie in derHilfe nach dem Namen des jeweiligen Ereignisses.

-


Anzeigen von Dialogfeldern

Wie kann ich ein Dialogfeld anzeigen? Wie initialisiere ich ein Dialogfeld? Wie greife ich aufSteuerelemente im Formular zu?

Um ein UserForm programmgesteuert anzuzeigen, muß es zuerst mit Load UserForm-Name geladen werden. Anschließend zeigt die Methode Show das UserForm an, z. B.MeinErstesUserForm.Show. Das Programm, das das UserForm eingeblendethat, wird so lange angehalten, bis das UserForm durch Ereignisprozeduren ausgeblen-det oder vom Anwender geschlossen wird.

In Ereignisprozeduren des Formulars kann über die Eigenschaft Visible das Formularjederzeit ein- und ausgeblendet werden. Wenn Visible auf False gesetzt wird, wird dasFormular ausgeblendet, und VBA setzt mit jener Prozedur fort, die das Formular mitShow eingeblendet hat.

Sie können auf ein Steuerelement und seine Eigenschaften vom Programm auszugreifen, indem Sie die Syntax UserForm-Name!Steuerelementname verwenden.Die Value-Eigenschaft der Steuerelemente ist die Standardeigenschaft und brauchtdaher nicht angegeben zu werden.

Abb.46: Anzeigen eines Dialogfeldes

Anzeigen

Visible

Um die Steuerelemente in einem Formular zu initialisieren, verwenden Sie die Ereignisprozedur Initialize desFormulars.

Value


Zusammenfassen und VertiefenModul 7: Formulare und Dialogfelder

1. Eigene Dialogfelder werden dem Projekt über Menü Einfügen�UserForm hinzu-gefügt.

2. Die Werkzeugsammlung enthält Steuerelemente, die Formularen hinzugefügtwerden können.

3. Die Position eines Steuerelements kann verändert werden, indem man am Rahmenzieht. Die Größe kann an einem der 8 Ziehpunkte verändert werden.

4. Im Eigenschaften-Fenster müssen Steuerelemente konfiguriert werden. Besonderswichtig ist die Name-Eigenschaft, die den Namen festlegt, unter dem das Steuer-element angesprochen werden kann.

5. Ereignisprozeduren reagieren sowohl auf Ereignisse im Formular als auch aufEreignisse in Steuerelementen. Sie werden im Code-Modul eines UserFormsdefiniert.

6. Dialogfelder werden mit dem Schlüsselwort Load geladen und mit Show ange-zeigt. Dabei stoppt die Ausführung des aufrufenden Programms.

Eigene DialogfelderSeite 58

-

Dialogfenster anzeigenSeite 63

EreignisprozedurenSeite 62

Eigenschaften von Steuer-elementenSeite 61

SteuerelementeSeite 59, 60


Modul 8Datenaustausch mit anderen Anwendungen

Wie kann ich auf das Objektmodell anderer Anwendungen zugreifen? Wie kann ich neue Objektefremder Anwendungen erstellen? Wie kann ich Daten mittels DDE austauschen? Wie kann ichFunktionen in den Windows-APIs aufrufen?


� Zugriff auf Objekte anderer Anwendungen

� Datenaustausch mit DDE

� Zugriff auf Windows-Funktionen

Lernziel

Der Anwender lernt Möglichkeiten kennen, mit anderen Anwendungen über Objektmodelle zu kommunizierenund Windows-Funktionen einzusetzen.

Voraussetzungen

Umgang mit Objekten, Eigenschaften, Methoden und Auflistungen.

-


Zugriff auf Objekte anderer Anwendungen

Wie kann ich auf Objekte anderer Anwendungen zugreifen? Wie kann ich neue Objekte fremderAnwendungen erstellen?

Um mit Objekten anderer Anwendung zu arbeiten, sollte man zunächst einmal einenVerweis auf die Bibliothek der Anwendung erstellen. Dazu wählt man aus dem MenüExtras � Verweise... Im darauf folgenden Dialog aktiviert man das Kontrollkästchenneben jeder Bibliothek, die man in dem Projekt benutzen möchte. Man sollte hier auchjene Bibliotheken, die nicht benutzt werden, deaktivieren, da sie unnötig Speicher-platz verbrauchen.

Nun kann auf die Objekte der Anwendung zugegriffen werden. Dazu erstellt man ambesten zunächst einmal eine Objektvariable der jeweiligen Klasse. Bei Klassen, diekeine eindeutigen Namen tragen, wie z. B. Application, muß man den Namen derBibliothek gefolgt von einem Punkt voranstellen, z. B. Word.Application. Beispiele:

Dim appWord As Word.Application

Dim wkbMappe As Workbook

Um das Objekt dann wirklich neu zu erstellen, muß man es mit dem SchlüsselwortNew initialisieren. Beispiele:

Set appWord = New Word.Application

Set wkbMappe = New Workbook

Man kann die beiden Vorgänge auch gleich zu einem Befehl zusammenfassen, z. B.Dim appWord As New Word.Application.

Um ein solches Objekt wieder aus dem Speicher zu entfernen, weist man derObjektvariablen Nothing zu, z. B. Set appWord = Nothing.

Abb.47: Öffnen einer Excel-Arbeitsmappe

Verweise

Mit den Objekten in der fremden Anwendung können Sie wie gewohnt arbeiten: Sie können Eigenschaften setzen,Methoden anwenden und auf Auflistungen zugreifen. Sie sollten natürlich mit dem Objektmodell der anderenAnwendung vertraut sein.

Deklaration

Nothing

-


Exkurs: Datenaustausch mit DDE

Was ist DDE? Wie kann ich mit Hilfe von DDE Daten mit anderen Windows-Anwendungen austau-schen?

DDE steht für Dynamic Data Exchange und ist jener Kommunikationsmechanismus,der vor allem von älteren Windows-Anwendungen und Fax-Programmen unterstütztwird.

Um eine DDE-Kommunikation aufzubauen, muß die andere Anwendung bereitsgeladen sein. Man kann die Anwendung vorher mit Hilfe des Shell-Befehls starten.

Man muß zunächst mit der Funktion DDEInitiate den DDE Kanal öffnen. Die Syntaxlautet: intKanalnummer = DDEInitiate (Anwendungsname, Thema).IntKanalnummer ist eine beliebige Integer-Variable, der die Nummer des DDE-Kanalszugewiesen wird. Sie wird für die folgenden Befehle benötigt. Anwendungsname istmeist der Dateiname der Anwendung ohne Erweiterung, z. B. WinWord. Thema ist eingültiges DDE-Thema der Anwendung, meist ein Dateiname eines Dokuments.

Nachdem der DDE-Kanal initialisiert wurde, können mit Variable = DDERequest(intKanalnummer, Element) Daten angefordert werden bzw. mit DDEPoke(intKanalnummer, Element, Daten) Daten gesendet werden. DDEExecute(intKanalnummer, Befehls-String) sendet Befehle an die Anwendung.

Nach Abschluß der Kommunikation muß der DDE-Kanal mit DDETerminate(intKanalnummer) geschlossen werden.

Abb.48: Drucken eines Word-Dokumentes über DDE

Für weitere Informationen und Beispiele suchen Sie bitte in der Hilfe und Dokumentation der jeweiligenAnwendung unter dem Stichwort DDE.

Dynamic Data Exchange

Shell

DDEInitiate

Kommunikation

DDETerminate

-


Exkurs: Zugriff auf Windows-Funktionen

Wie kann ich auf eingebaute Windows-Funktionen zugreifen? Wo finde ich Informationen zu diesenFunktionen?

Eingebaute Windows-Funktionen müssen vor Ihrer Verwendung als Prozeduren oderFunktionen auf Modulebene deklariert werden. Dazu dient die folgende Syntax:

Public Declare Sub Prozedurname Lib "Bibliotheksname" _(Parameterliste)

Public Declare Function Funktionsname Lib _"Bibliotheksname" (Parameterliste) As Datentyp

Der Prozedurname und der Funktionsname muß exakt dem Namen der Windows-Funktion entsprechen. Ebenso muß die Parameterliste und bei Funktionen derRückgabe-Datentyp genau mit der Definition der Funktion übereinstimmen. DerBibliotheksname ist der Name der Programmierschnittstelle, normalerweise eineDLL- oder EXE-Datei. Statt Public kann auf Wunsch natürlich auch Private verwendetwerden.

Um der Prozedur oder Funktion in ihrem Projekt einen anderen Namen zu geben, soverwendet man das Schlüsselwort Alias, z. B.:

Declare Sub MessageBeep Lib "User32" Alias "Signal1" _(ByVal N As Integer)

Die so deklarierten Prozeduren und Funktionen können dann wie normale Prozedu-ren und Funktionen verwendet werden.

Abb.49: Deklaration von Windows-Funktionen

Deklaration

Alias

Für Informationen über die Windows-Programmierschnittstellen lesen Sie bitte die Dokumentation zu system-nahen Programmiersprachen, wie z. B. Visual C++. Die Programmierschnittstellen sind auch auf den quartals-mäßig erscheinenden CDs des Microsoft Developer Network dokumentiert.

Verwendung


Zusammenfassen und VertiefenModul 8: Datenaustausch mit anderen Anwendungen

1. Mit Menü Extras�Verweise... können Objektbibliotheken anderer Anwendungengeladen werden. Neue Objekte anderer Anwendungen werden mit dem Schlüs-selwort New erzeugt.

2. Mit Hilfe von DDE kann mit älteren Windows-Anwendungen und Fax-Program-men kommuniziert werden.

3. Mit dem Schlüsselwort Declare können Windows-Funktionen als Prozeduren undFunktionen deklariert werden. Man kann dann auf sie wie auf herkömmlicheProzeduren und Funktionen zugreifen.

Objekte in anderenAnwendungenSeite 66

-

Windows-FunktionenSeite 68

Datenaustausch mit DDESeite 67


Wichtige Tastenkombinationen

Wie kann ich meine Arbeit mit VBA beschleunigen?

Taste(n) FunktionF5 Ausführen einer Sub-Prozedur oder eines UserForm-Formulars

F8 Zeilenweises Ausführen von Code

UMSCHALT + F8 Zeilenweises Ausführen von Code mit Prozedurschritten

STRG + PAUSE Unterbrechen der Ausführung einer Visual Basic-Anwendung

STRG + G Anzeigen des Direktfensters

F7 Code-Fenster anzeigen

F2 Objektkatalog anzeigen

STRG + F Suchen

STRG + H Ersetzen

F3 Weitersuchen

UMSCHALT + F3 Vorheriges suchen

STRG + NACH-UNTEN Nächste Prozedur

STRG + NACH-OBEN Vorherige Prozedur

STRG + Z Rückgängig

STRG + Y Aktuelle Zeile löschen

TAB Einzug vergrößern

UMSCHALT + TAB Einzug verkleinern

STRG + UMSCHALT + F9 Alle Haltepunkte löschen

-


Index

Symbole? ................................ 13

AAbbruchbedingung ... 44Abfrage ............... 28, 29Access 6, 28, 29, 37, 58AfterUpdate .............. 62Algorithmus ................ 8Alias ......................... 68And ........................... 48Anweisung ................ 10Anzeige .................... 59Application ......... 34, 35Array ......................... 17As ..... 18, 22, 23, 26, 28Auflistung ........... 34, 35Auflistungsobjekt ...... 36Ausgabe ...................... 8

BBackColor ........... 58, 61BackStyle .................. 61Befehl ....................... 10Befehlsschaltfläche ... 59BeforeUpdate............ 62Benutzerformular ........ 7Benutzerschnitt-

stelle .................. 8, 10Berechnungen ........... 10Bericht ................ 28, 29Bezeichnungsfeld ..... 59Bibliothek ..... 38, 58, 66Bildlaufleiste ............. 59Boolean .............. 19, 48Boolescher

Ausdruck ... 48, 49, 50BorderColor ........ 58, 61BorderStyle ......... 58, 61ByRef ........................ 27Byte .......................... 19ByVal ........................ 27

CCall ........................... 11Call by Reference ..... 27Call by Value ............ 27Caption ............... 58, 61Case .......................... 50Case Else ................... 50Change ..................... 62Click ......................... 62Const ........................ 22

Controls .................... 34ControlTipText .......... 61Count .................. 35, 36Currency ................... 19CVError ..................... 19

DDate .................... 10, 19Datenfeld ............ 17, 23Datentyp ................... 19Datum/Uhrzeit .......... 19DblClick ................... 62DDE .......................... 67DDEExecute ............. 67DDEInitiate ............... 67DDEPoke .................. 67DDERequest ............. 67DDETerminate .......... 67Debug ....................... 12Debug.Print .............. 12Decimal .................... 19Declare ..................... 68Deklarationsteil .......... 8Dialogbox ................... 7Dialogfeld ........... 58, 63Dim ........ 18, 20, 21, 23Direktbereich ............ 13DLL-Datei ................. 68Do ............................ 47Do-Loop ............. 47, 48Document ................. 19Dokument ................... 7Double ..................... 19Drehfeld ................... 59Dynamic Data

Exchange ............... 67

EEigenschaft ..... 7, 34, 36,

41, 61Eigenschaftenfenster .. 7,

40, 58, 59Eigenschaftsprozedur 41Einfachverzwei-

gung ................ 48, 49Eingabe ....................... 8Einzelschritt .............. 14Einzelschrittmodus .... 14Else ........................... 49Empty ....................... 19Enabled ..................... 61End Function ............. 28End If ........................ 49

End Select ................. 50End Sub .................... 11End With................... 39Enter ......................... 62Ereignis ..................... 11Ereignisprozedur ....... 62Err ....................... 53, 54Err.Number ............... 53Err.Raise.................... 54Error .......................... 19Ersetzen ...................... 9Excel ... 6, 28, 29, 38, 58EXE-Datei .................. 68Exit ........................... 62Exit Do ...................... 47Exit For ............... 45, 46Exit Function ............. 28Exit Sub............... 11, 21

FFalse ................... 19, 48Fehlernummer .... 53, 54Fehlerroutine ...... 53, 55Festkommazahl ......... 19Fließkommazahl ....... 19Flußdiagramme ........... 8Fokus ........................ 62Font .................... 36, 61For ............................ 45For - Next ..... 31, 45, 46For Each.................... 46For Each - Next ......... 46ForeColor............ 58, 61Form ................... 19, 34Forms .................. 34, 35Formular ............. 28, 29Function ............. 28, 68Funktion . 10, 28, 41, 68Funktionsmethode .... 37

GGanzzahl .................. 19GroupName.............. 61Grundrechnungsarten 10Gültigkeitsbereich 20, 29Gültigkeitsdauer ....... 21

HHaltepunkt ................ 14

IIf ............................... 49If-Then-Else ............... 49

In .............................. 46Index .................. 23, 35Indexnummer ..... 23, 31Initialize .............. 62, 63InputBox ................... 12Int ....................... 10, 13Integer ...................... 19Internet Explorer ......... 6Is ......................... 48, 50IsEmpty ..................... 19IsError ....................... 19IsMissing ................... 30IsNull ........................ 19

KKlasse ........... 19, 34, 40Klassenmodul ..... 40, 41Kombinationsfeld ...... 59Kommentar ................. 9Kompilieren .............. 21Konstante ............ 17, 22Kontrollkästchen ....... 59

LLaufzeitfehler ............ 53LBound ..................... 23Lib ............................ 68Listenfeld .................. 59Load ......................... 63Locked ...................... 61Lokal-Fenster ............ 13Long ......................... 19Loop ......................... 47

MMakro . 7, 11, 13, 26, 29Mehrfachverzwei-

gung ................ 48, 50Meldungsbox ............ 12MessageBeep ............ 68Methode ....... 34, 37, 41Microsoft Developer

Network ................ 68Modul ......... 7, 9, 20, 29Modulebene ....... 20, 29Modulkopf .... 18, 20, 22MSForms............. 38, 58MsgBox..................... 12Multiseiten ................ 59

NName ...... 34, 36, 58, 61New .................... 40, 66


Next .................... 45, 46Not ........................... 48Nothing .............. 19, 66Null .......................... 19

OObject ................ 18, 19Objekt 19, 34, 35, 40, 66Objektkatalog ........... 38Objektmodell ...... 38, 66Objektvariable .......... 34Office ....................... 38OLE-Automatisierungs-

Server ...................... 6On Error Goto ..... 53, 55On Error Goto 0 ........ 53On Error Resume Next 53OpenRecordset ......... 37Operator ................... 48Option Explicit .......... 18Optional ................... 30Optionale Parameter . 30Optionsfeld ............... 59Or ............................. 48Outlook ...................... 6

PParamArray ............... 31Parameter .... 10, 26, 28,

31, 37, 62Parameterfeld............ 31Post-Check-

Schleife ............ 44, 47Potenzieren ............... 10Powerpoint ..... 6, 29, 58Pre-Check-Schleife .. 44,

45, 46, 47Preserve .................... 23Print .......................... 13

Private .... 18, 20, 22, 29Project ........................ 6Projekt .................. 7, 21Projekt-Explorer .......... 7Projektebene ....... 20, 29Property Get ............. 41Property Let .............. 41Property Set .............. 41Prozedur 11, 26, 27, 29,

30, 31, 37, 41, 68Prozedurebene.......... 20Prozedurkopf 26, 29, 31Prozedurmethode ..... 37Prozedurschrittt ......... 14Public .... 18, 20, 21, 22,

23, 29, 41

QQueryClose ............... 62

RRahmen .................... 59Raise ......................... 54Range ....................... 36Recordset .................. 19ReDim ...................... 23Referenz ................... 27Referenzübergabe ..... 27Register ..................... 59Resume ..................... 53Resume Next ............ 53

SSchleife ..................... 44Schleifenfuß .............. 44Schleifenkopf ............ 44Schleifenkörper ......... 44Schnittstelle ................ 8Schrittweite ............... 45

Select Case ............... 50Set ...................... 18, 19Shell ......................... 67Show ........................ 63Single ........................ 19Size........................... 36SpecialEffect ....... 58, 61Sprungmarke............. 53Standard-Fehler-

behandlung............ 53Standardmodul ........... 9Static....... 18, 20, 21, 23Step .......................... 45Steuerelement .... 59, 60,

61, 62, 63String ........................ 19Struktogramme............ 8Sub ..................... 11, 68Suchen ........................ 9

TTabellenblatt ....... 28, 29Terminate ................. 62Text .......................... 61TextAlign .................. 61Textfeld..................... 59Then ......................... 49To ................. 23, 45, 50True .............. 19, 47, 48

UÜberwachungsfenster 13UBound .............. 23, 31Umschaltfläche ......... 59Until ......................... 47UserForm 58, 59, 62, 63

VValue ............ 61, 62, 63

Variable ....... 17, 18, 19,20, 27

Variablendeklarationerforderlich ............ 18

Variablenname ... 17, 18Variant ...................... 19VarType .................... 19VB-Skript .................... 6Verarbeitung ............... 8Vergleichsoperator .... 48Verweis................. 7, 66Verzweigung ............ 48Visible ................ 61, 63Visual Basic für

Applikationen .......... 6Visual Basic-Editor ...... 6Visual C++ ............ 6, 68Vorlage ....................... 7

WWend ........................ 47Werkzeugsammlung . 58Wert ......................... 27While ........................ 47While Wend ............ 47With.......................... 39Word ........ 6, 29, 38, 58Word.Application ..... 66Workbook........... 19, 66Workbooks ......... 35, 36Worksheets ............... 35

ZZählervariable .......... 45Zählschleife .............. 45Zeichenkette ............. 19Ziehpunkt ................. 60Zweifachver-

zweigung ......... 48, 49

easy2know-how

Erhard Closs – Ihr PC-Coach

Franz-Fackler-Str. 6

80995 München

Telefon: 089/ 910 72 813

Telefax: 089/ 910 72 814

[email protected]

www.easy2know-how.de

Dieses Werk ist urheberrechtlich geschützt.

Alle dadurch begründeten Rechte, insbesondere der Nachdruck, die Übersetzung, die Wiedergabe auf photomechanischen oder ähnlichen Wegen, die Speicherung und Ver-arbeitung mit Hilfe der EDV bleiben auch auszugsweise ausdrücklich dem Urheber vorbehalten.

Die in den Beispielen verwendeten Namen von Firmen, Produkten, Personen, Zeichen oder sonstigen Daten sind frei erfunden. Ähnlichkeiten mit tatsächlichen Personen, Firmen, Produkten oder Ereignissen sind rein zufällig und nicht beabsichtigt.

easy2know-how

Documents

VBA - w3- · PDF fileVBA Programmieren mit ... können mit VBA gesteuert wer-den. In Word, Excel und Powerpoint können Sie den Visual Basic-Editor auf die gleiche Weise aufrufen