© TRAC Optische Computer Sensorik, Stuttgart 2002, em@il: trac@n.zgs.de

Inhalt

1. Einführung

   1. Historische Entwicklung

   2. Ziel der Programmierung

   3. Grundprinzipien der Programmierung

      1. EVA- Prinzip

      2. Ereignisgesteuerte Programmierung

   4. Compiler vs. Interpreter

2. Grundlegende Sprachelemente

   1. Literale

   2. Operatoren

   3. Variablen

      1. Deklaration in VB

   4. VB- Datentypen

      1. Option Explicit

      2. Typ bestimmen

      3. Zeichenkettenliterale auf Typ prüfen

      4. Variantvariablen und der Wert Empty

      5. Null- Werte

      6. Werte in Formularelementen vom Typ INPUT

      7. Umwandlungsfunktionen/Konvertierungen

   5. Zahlen in Zeichenketten mit Format umwandeln

   6. Verarbeiten von Zeichenketten (Strings)

   7. Datum und Uhrzeit

   8. Arrays

      1. Option Base

      2. Dynamische Arrays

   9. Assoziative Arrays (Dictionary)

      1. Erzeugen

      2. Elemente hinzufügen

      3. Durchlaufen einer Dictionary

   10. Konstanten

3. Gültigkeitsbereiche von Deklarationen

4. Steuerung der Programmausführung

   1. Bedingte Ausdrücke

   2. Bedingt ausführbarer Programmabschnitt

   3. Bedingt wiederholbarer Programmabschnitt

5. Fehlerbehandlung

6. Klassen und Objekte

   1. Objekt

   2. Objektdiagramm

7. Klasse

   1. Klassenmodule

   2. Konstruktor und Destruktor

   3. Konstruktoren und Destruktoren in VB

   4. Eigenschaften

   5. Methoden

   6. Collections

8. Instanziierung von Com- Objekten

9. Ereignisgesteuerte Programmierung

10. Steuerelemente

    1. TextBox

    2. ListBox

    3. Weitere Steuerelemente

11. Formulare

    1. Lebenszyklus eines Formulars

    2. Objektmodell der Klasse UserForm

    3. Eigenschaften eines Formulares

    4. Formulare Anzeigen und Verdecken

    5. Beenden Anwendung mit einem Formular

    6. MIDI- Fenster

    7. Beenden einer MidiForm (UnloadAll)

12. Datei IO

    1. Prozeduraler Datei IO

       1. Ablauf des Dateizugriffs

       2. Dateitypen

    2. Objektorientierter Datei IO

13. Datenbankprogrammierung

    1. Objektmodell von ADO

    2. Typen von ADO- Kommandos

    3. Cursor-Typen für Recordsets

    4. Lock- Typen

    5. Beispiel: Abfragen der Produkte aus der Artikeldatenbank und Ausgabe in einer Listbox

    6. Beispiel: Abfragen der Produkte aus der Artikeldatenbank und editieren in einem DataGrid

    7. Ergebnismengen in Recordsets filtern

    8. Nach einem Datensatz im Recordset suche

    9. Datensätze hinzufügen, aktualisieren und löschen

    10. Requery

    11. Recordsets persistent auf Festplatte speichern und zurückladen

    12. AdoDc: Verbindung mit Datenbank und Datensatznavigation

14. Grafikprogrammierung

    1. Objekte mit Grafikmethoden

    2. Grafikmethoden

15. Anwendungen Verpacken und Weitergeben

Einführung

BASIC ist ein Akronym (Beginner’s All-purpose Symbolic Instruction Code = Allzweck-Symbolbefehlssprache für Anfänger) und bezeichnet eine Programmiersprache, die Mitte der 60-er von den US- Amerikanern John Kemeny und Thomas Kurtz entwickelt wurde. Sie diente ursprünglich für Schulungszwecke.

Ursprünglich war BASIC als Interpretersprache konzipiert. Ein geringer Umfang an Befehlen, die Insensitivität gegenüber der Groß/Kleinschreibung und die Interaktivität durch den Interpreter führten dazu, daß BASIC inbesondere unter Anfängern beliebt wurde.

Historische Entwicklung

Ziel der Programmierung

Standardsoftware anpassen

Beispiel: EXCEL wird als Kalkulationssoftware eingesetzt. Bestimmte Kalkulationen sollen online auf einem Webserver veröffentlicht werden, indem Inhalte aus Tabellenzellen in Datenbanktabellen auf dem Webserver übertragen werden. Für den Anwender soll die Übertragung genauso einfach wie ein Speichern des Arbeitsblattes sein. Als Werkzeug bietet sich hier VB und VBA an.

Automatisierung

Sich wiederholende, komplexe Arbeitsabläufe können in einem Script erfasst, und auf Knopfdruck gestartet werden. Beispiele: Backup von Datenbanken/Festplatten, Wiederherstellen von Arbeitsoberflächen (Anmeldescripte). Als Werkzeuge bieten sich hier Scriptsprachen wie PERL ound VBScript an.

Individualsoftware erstellen

Auf einer Plattform (PC oder Microcontroller) wird eine völlig neue Anwendung erstellt. Als Werkzeuge bieten sich hier Entwicklungsumgen wie Visual C++ oder Visual.NET an. Dies ist der kompliziteste Fall. Die Entwicklung von Individualsoftware kann sogar zur entwicklung völlig neuer Programmierwerkzeuge führen (UNIX-> C, DHTML-> JavaScript)

Grundprinzipien der Programmierung

EVA- Prinzip

Ereignisgesteuerte Programmierung

Die Welt besteht aus Objekten, die miteinander kommunizieren. Die Kommunikation erfolgt über Botschaften, die in den meisten objektoriantierten Sprachen als Methoden realisiert sind. Botschaften können Produkte von Ereignissen im System sein wie z.B. das Anklicken einer Schalftfläche durch einen Benutzer. Anderseits können Botschaften programmgesteuert an Objekte gesendet werden. Damit lassen sich Verarbeitungsformen wie Stapelverarbeitung (übergabe der Kontrolle an ein weiteres Objekt) und Client/Server (Ausfrufen eines Dienstes im Objekt) realisieren.

Compiler vs. Interpreter

Grundlegende Sprachelemente

Literale

Operatoren

Variablen

Unsere Programme realisieren Algorithmen, mit denen wir Daten verarbeiten. Um Zugriffe auf die Daten im Computerspeicher zu formulieren, muß uns die Programmiersprache entsprechende Ausdrucksmittel zur Verfügung stellen.

Ein elementares Ausdrucksmittel für Speicherzugriffe sind Variabeln.

Unter Variabeln können wir uns benannte Speicherplätze vorstellen. Variabeln sind immer vor ihrer Verwendung im Programmtext mittels einer Deklaration zu vereinbaren. In der Deklaration wird der zu verwendende Name für den Speicherplatz und der Datentyp festgelegt.

Deklaration in VB

Dim Variabelname As Datentyp

Der Datentyp steht für eine Klasse von Daten. Beispielsweise verbirgt sich hinter dem Datentyp Integer die Menge aller ganzen Zahlen im Intervall [-32768, 32767]. Der Datentyp bestimmt, wie die Informationen als Dualzahlen im Speicher zu verschlüsseln sind, und wieviel Speicherplatz für die Variabel benötigt wird. So werden Variabeln vom Typ Integer vom Dezimal- ins Dualsystem konvertiert, und für sie ein Speicherplatz von 16bit = 2Byte reserviert.

VB- Datentypen

(VB-Dok:Referenz/Zusätzliche Informationen/Datentypen)

Im der folgenden Tabelle werden alle elemntaren Datentypen der Programmiersprache VBA aufgelistet:

Option Explicit

VB ermöglicht aus Gründen der Abwärtskompatibilität, auf die explizite Deklaration von Variablen zu verzichten. Die Deklaration erfolgt dann implizit durch Zuweisen eines Wertes an einen Variablenamen. Damit werden allerlei exotische Fehler, die sich oft erst zur Laufzeit outen, ermöglicht. Um diesen offensichtlichen Unsinn abzustellen, muß an den Beginn eines jeden Moduls die Compileranweisung

Option Explicit

gesetzt werden. In der VB- Entwicklungsumgebung kann unter Extras\Optionen\Editor eingestellt werden, daß jedes neu erzeugte Modul am Anfang ein solches Option Explicit gestempelt bekommt.

Typ bestimmen

Der aktuelle Typ einer Variantvariabel kann mittels der Type- Name Funktion bestimmt werden:

x = 123
typ_x = TypeName(x)     ' typ_x = "Integer"

Zeichenkettenliterale auf Typ prüfen

Mit den Prädikaten IsNumeric und IsDate kann getestet werden, ob eine Zeichenkette in einen nummerischen- oder einen Datumswert gewandelt werden kann.

Dim eingabe As Variant, test As Boolean
eingabe = "einundzwanzig"
    
test = IsNumeric(eingabe)
eingabe = "21a"
    
test = IsNumeric(eingabe)
eingabe = "21,1"
    
test = IsNumeric(eingabe)
eingabe = "21#1"
    
test = IsNumeric(eingabe)

'---------------------------------------------------------------- 
eingabe = "2003-01-31"  ' Datumsangabe im ODBC- Format
test = IsDate(eingabe)
    
eingabe = "2003-31-01"  ' Datumsformat im SQL- Server Format
test = IsDate(eingabe)
    
eingabe = "2003-14-07 15:12:00"
test = IsDate(eingabe)
    
eingabe = #7/14/2003 3:12:00 PM#
test = IsDate(eingabe)

Variantvariablen und der Wert Empty

Wurde einer Variantvariabel noch kein Wert zugewiesen, dann befindet sich das Typcodefeld in einem Startzustand EMPTY. Dieser Besondere Zustand kann mittels des Prädikates IsEmpty geprüft werden.

Null- Werte

Bei der Datenbank-Programmierung trifft man sehr häufig auf Null-Felder, also Felder, die absolut leer sind. VB kennt für diesen Zustand die Konstante Null, welche nur selten für sinnvolle Operationen benutzt werden kann, im Gegensatz zu Empty, das sich wie ein neutrales Element (bzgl. Addition) verhält.

So ergibt z.B. Null + 5 einfach nur Null. Eine Zuweisung von Null an einen nicht-Variant erzeugt sogar einen Fehler. Mittels des Prädikates IsNull kann auf einen Null- Wert geprüft werden.

Werte in Formularelementen vom Typ INPUT

Input- Formularelemente speichern Werte immer als Zeichenketten.

Umwandlungsfunktionen/Konvertierungen

Übung

Implementieren Sie das Prädikat IsInteger(test as Variant) welches true zurückgibt, wenn test ein Integer- Literal ist, und sonst false.

Variablen vom Typ Decimal erzeugen

 Dim grosse_zahl As Variant  'Decimal kann nicht dierekt deklariert werden
    
' Durch Zuweisen des Ergebnisses der Typumwandlungsfunktion CDec an
' eine Variantvariable wird ein Decimalwert erzeugt
grosse_zahl = CDec("123456789012345678901234567")
grosse_zahl = 2 * grosse_zahl

Zahlen in Zeichenketten mit Format umwandeln

Mittels der Format(Zahl, "Formatstring") Funktion kann ein Zahlenwert in eine Formatierte Zeichenkette umgewandelt werden.

dim ztxt as string

ztxt = Format(1234,5678, "###.##") 
'ztxt hat jetzt den Wert 1234,57

Verarbeiten von Zeichenketten (Strings)

Zeichenketten können mit den Operatoren + und & zu einer neuen Verbunden werden.

Ü: Romzahl

Datum und Uhrzeit

Datumsangaben werden als Variant- Subtyp Date gespeichert.

Dim dat As Date

Etwas problematisch sind die Literale für Datumsangaben. Sie müssen stets im amerikanischen Format vorliegen (Monat/Tag/Uhrzeit) wobei sie in #-Symbolen geklammert werden

weihnachten = #12/24/2003#

Möchte man lieber das europäische Datumsformat verwenden, dann kann die Cdate- Funktion verwendet werden:

silvester = Cdate(31.12.2003 00:00)

Aus einzelnen Partikeln wie Jahr, Monat und Tag kann ein Datumswert mittels der Funktion DateSerial gewonnen werden:

silvester = DateSerial(2003, 12, 31)

Das aktuelle Datum wird mittels der eingebauten Funktion Now bestimmt

dat = Now   ' Bestimmt aktuelles Datum und Uhrzeit

Au einem Datum sind Partikel wie Tag, Monat und Jahr herauslösbar

Dim tag As Integer, monat As Integer, jahr As Integer
    
tag = Day(dat)
monat = Month(dat)
jahr = Year(dat)

Zur Bestimmung von Wochentagnummer und Name gibt es wiederum spezielle Funktionen

' Wochentagnummer und Wochentagname
Dim wtagnr As Integer, wtagname As String
    
wtagnr = Weekday(dat, vbMonday)
wtagname = WeekdayName(wtagnr, , vbMonday)    

Der Zeitraum zwischen zwei Zeitpunkten kann mittels der Funktion DateDiff berechnet werden:

' Seit wieviel Tagen gibt es Unix
Dim unixzeit_in_tagen As Integer
unixzeit_in_tagen = DateDiff("d", DateSerial(1970, 1, 1), Now)

Zeitpunkte in der Zukunftund in der Vergangenheit können mittels DateAdd berechnet werden:

' Berechnen des Fälligkeitsdatums mittels DateAdd
    
Dim faelligkeit As Date
faelligkeit = DateAdd("m", 1, Now)    

Ü: Gbt-Wochentag, Wieviel Tage lebe ich

Arrays

Zur Verarbeitung tabelarischer dienen in VB Arrays. Durch die Deklaration eines Arrays werden im RAM n Speicherplätze zur Aufnahme von Werten des Typs x reserviert.

Deklaration eines Arrays hat folgenden Aufbau:

dim a(3) as Integer
    | |       +----- Typ der Einträge
    | +------------- größter Index eines Eintrages
    +--------------- Name des Arrays

Nach einer Arraydeklaration ergibt sich folgendes Format im Arbeitspeicher:

Der Zugriff auf die Elemente eines Arrays erfolgt über den Namen und den Indize:

dim x as Integer

' x hat nach Ausführung dieser Anweisung den Wert 2
x = a(2)
    | +--- Indize (Platznummer)
    +----- Arrayname

Die Indizes können dynamisch zur Laufzeit festgelegt werden. Damit ist eine komfortable Verarbeitung der Arraydaten in Schleifen möglich:

dim i as Integer, s as Long

' s enthält nach der Schleife die Summe aller Einträge
for i = 0 to 3
   s = s + a(i)
next

Ü: Min/Max- Suche, Sortieren

Option Base

Normalerweise beginnen die Indizes in Arrays bei 0. Mittels

Option Base 1

Kann der Compiler veranlasst werden, die Indizes im betreffenden Modul bei 1 beginnen.

Bereichsgrenzen mit To

Der Indexbereich eines Arrays kann auch völlig Flexibel mittels To Direktive definiert werden:

Dim Umsatzprognose(5, 10) as Currency

Dynamische Arrays

Die Anzahl der Plätze eines gewöhnlichen Arrays wird bei der Deklaration fest definiert. Wird ein Array mit Daten kontinuierlich gefüllt, dann läuft es irgend wann einmal voll. Sollen weitere Daten im Array abgelegt werden, dann muß es vergrößert werden.

Gewöhnliche Arrays sind nicht vergrößerbar. VB bietet einen zweiten Typ von Arrays, die sog. dynamischen Arrays. Sie werden mit einem unbestimmten max. Index wie folgt deklariert:

dim a() as Integer

Zur Laufzeit können die Dimensionen eines dynamischen Arrays mit der Prozedur ReDim <arrayName>( <neuerMaxIndex>) vergrößert und verkleinert werden wie folgt:

:
ReDim Preserve a(6) ' Das Array wird um 3 Elemente vergrößert, wobei der alte Inhalt erhalten bleibt
:
ReDim a(9) ' Das Array wird wiederum um 3 Elemente vergrößert. Diesmal wird der alte Inhalt jedoch nicht
           ' erhalten (Preserve fehlt)

Ü: Prog. Messwerterfassung (akt. Wert, dyn. Mittelwert)

Assoziative Arrays (Dictionary)

S.124

Erzeugen

Dim telbuch as New Dictionary

Elemente hinzufügen

telbuch.add "Schlüssel-1", wert1
:
telbuch.add "Schlüssel-N", wertN

Durchlaufen einer Dictionary

dim key as String
for each key in telbuch
  MsgBox telbuch(key)
next key

Konstanten

Eine spezielle Form von Variabeln sind Konstanten. Eine Konstante erhält bei der Deklarartion einen Wert zugewiesen. Im weiteren Programmablauf kann der Konstanten kein neuer Wert zugewiesen werden.

Const Name_der_Konstante = Wert 

Beispiel

Const Pi = 3.142

Der Typ der Konstante wird automatisch bei der Zuweisung des Wertes aus diesem bestimmt.

Gültigkeitsbereiche von Deklarationen

Public eingabezeile as String

Private akku as Double 

Private Sub addiere_click()

  Dim wert as Double

  wert = Val(eingabezeile)

  akku = akku + wert

End Sub

Private arabzahl as Integer

Private Sub M_Click()

  arabzahl = arabzahl + 1000

  eingabezeile = Str$(arabzahl)

End Sub

Steuerung der Programmausführung

In seiner Grundbetriebsart lädt der Computer eine Anweisung nach der anderen aus dem Arbeitsspeicher und führt sie aus. Viele Algorithmen erfordern jedoch, daß einige Abschitte aus den Anweisungslisten nur unter bestimmten Bedingungen auszuführen sind (z.B. „Wenn bis zum Tag X kein Zahlungseingang erfolgte, dann Mahnung abschicken“) oder wiederholt werden müssen. Um dies zu ermöglichen, verfügt der Computer über spezielle Anweisungen, die den Befehlszählerstand manipulieren. Sie bewirken, daß nach ihrer Ausführung das Programm an einer beliebigen neuen Adresse fortgesetzt wird. Aufgrund dieser Wirkung werden sie Sprunganweisungen genannt.

In VBA sind die Sprunganweisungen in Form von bedingt ausführbaren, oder bedingt wiederholbaren Programmabschnitten implementiert.

Bedingte Ausdrücke

Bedingte Ausdrücke haben die Form

IIF(Bedingung, ExprA, ExprB)

Zuerst wird die Bedingung evaluiert. Ergibt sie den Wert true, dann wird ExprA evaliuiert und deren Wert ersetzt den kompletten bedingten Ausdruck. Sonst wird ExprB evaluiert, und deren Wert ersetzt den Ausdruck.

Bedingt ausführbarer Programmabschnitt

Der bedingt ausführbare Programmabschnitt entspricht einer Wenn ... dann Regel.

IF Bedingung Then
   Anweisung 1
   Anweisung 2
       :
   Anweisung n
End IF

Trifft die Bedingung nicht zu, dann kann anschließend mit dem Schlüsselwort Else ein Programmabschnitt als Alternative formuliert werden:

IF Bedingung Then
   Anweisung 1
       :
   Anweisung n
Else
   Anweisung n+1
       :
   Anweisung n+m
End IF

Gibt es mehrere Alternativen, die von Zusatzbedingungen abhängig sind, dann können diese in ElseIf- Blöcken formuliert werden:

IF Bedingung Then
   Anweisung 1
       :
   Anweisung n
ElseIF Bedingung2
   Anweisung n+1
       :
   Anweisung n+m
End IF

Ist die Ausführung mehrerer Programmabschnitte vom Wert eines einzigen Ausdrucks abhängig, dann kann alternativ zu ElseIf eine vereinfachte Schreibweise mittels Select Case Block gewählt werden:

Select Case Ausdruck
Case Wert1
     Anweisung 1
         :
     Anweisung n
Case Wert2
     Anweisung n+1
         :
     Anweisung n+m
Case Wert3
  :
Case Else
     Anweisung 
End Select 

Bedingt wiederholbarer Programmabschnitt

Es handelt sich hierbei um Programmabschnitte, die sooft wiederholt werden, solange eine Bedingung zutrifft (wahr ist). Sie werden gewöhnlich als Schleifen bezeichnet. Zwei elementare Formen der Schleifen werden unterschieden: die abweisende, und die nichtabweisende Schleife.

Bei der abweisenden Schleife wird stets am Anfang des Programmabschnittes geprüft, ob die Bedingung für eine Ausführung des Abschnittes erfüllt ist. Wenn ja, dann wird der Programmabschnitt ausgeführt, und am Ende der Befehlszähler wieder auf die Startadresse des Programmabschnittes gesetzt. Gilt die Bedingung weiterhin, dann erfolgt eine wiederholte Ausführung des Programmabschnittes. Trifft die Bedingung nicht zu, dann wird der Programmabschnitt übersprungen.

DO Bedingung
   Anweisung 1
   Anweisung 2
       :
   Anweisung n
Loop

Bei der nichtabweisenden Schleife wird die Bedingung erst am Ende des Programmabschnittes überprüft. Trifft sie zu, dann wird der Befehlszähler auf den Abschnittanfang gesetzt, und dieser wiederholt. Sonst wird mit der nachfolgenden Anweisung fortgesetzt.

Da die Bedingung erst am Ende des Abschnittes überprüft wird, wird der Abschnitt immer mindestens einmal ausgeführt.

DO
   Anweisung 1
   Anweisung 2
       :
   Anweisung n
Loop Bedingung

Sind Datenfelder fester Länge zu durchlaufen, oder Berechnung mit einer vorgegebenen Zahl wiederholt auszuführen, dann bietet sich die For...to ... next Schleife an:

FOR i = <Startwert> TO <Endwert> [STEP <Schrittweite>]
   Anweisung 1
   Anweisung 2
       :
   Anweisung n
Next

Zum Durchlaufen aller Felder eines Arrays kann die For Each - Schleife benutzt werden.

Fehlerbehandlung

Fehler werden ignoriert:

On Error Resume Next

Nach Auftreten eines Fehlers wird zu einer Sprungmarke gesprungen, und das Programm dort fortgesetzt:

On Error Goto Sprungmarke

Informationen zum Fehler sind über das Fehlerobjekt Err abrufbar:

Err.Number         ' Fehlernummer
Err.Description    ' Fehlerbeschreibung

Funktionen und Prozeduren

Sub vs Function

Call by Referenc vs Call by Value

Übung

Implementieren Sie einen Rechner, der Klammerausdrücke in Postfixschreibweise analysieren kann. Bsp.:

(5(3 4)+)*

Klassen und Objekte

Objekt

Durch die Einführung des Objektbegriffes in VB können Systeme mit komplexer innerer Struktur direkt beschrieben werden. Jedes Objekt wird mit einem Namen gekennzeichnet, jeder Prozess in einem Objekt durch eine sogenannte Methode ausgedrückt, und jeder Zustand durch eine Eigenschaft dokumentiert. Beziehungen und Prozesse, an denen mehrere Objekte beteiligt sind, können durch Methoden, die Objekte als Parameter erwarten, und Eigenschaften, die wiederum Objekte sind, ausgedrückt werden.

Objektdiagramm

Beschreibung des Sonnensystems durch Objekte

Das gesamte Sonnensystem wird als Superobjekt dargestellt

sonnensystem

Das Sonnensystem besteht aus Zentralstern, Planeten und Kometen. Diese drei Kategorieen können wiederum durch die die beiden Superobjekte planeten und kometen und dem Objekt zentralkoerper dargestellt werden, die Elemente des Superobjektes sonnensystem sind.

sonnensystem.zentralkoerper.name = „Sonne“
sonnensystem.planeten
sonnensystem.kometen

Planeten beschreibt die Menge aller Himmelskörper. Diese werden jeweils durch Objekte dargestellt werden, die Datenelemente und Prozeduren enthalten, durch welche die astronomischen Daten dieser Himmelskörper dargestellt werden können:

sonnensystem.planeten(0).name = "merkur"
sonnensystem.planeten(0).tagestemperatur = einheit_C(430)

sonnensystem.planeten(1).name = "venus"
sonnensystem.planeten(1).tagestemperatur = einheit_C(500)

sonnensystem.planeten(1).name = "erde"
sonnensystem.planeten(1).tagestemperatur = einheit_C(15)

Aufgaben:

Beschreiben Sie folgende Systeme durch Objektmengen

1. Bankkonto

2. Vektorrechnung

Klasse

Klassenmodule

VB sieht für die Deklaration und Definition von Klassen sog. Klassenmodule vor. Eigenschaften werden durch private Modulvariabeln, die über Eigenschaftsprozeduren gelesen und gesetzt werden können, manipuliert.

Beispiel:

Es wird ein Spiel entwickelt, welches eine Seeschalcht simuliert. Die Spielfiguren werden durch folgendes Objektmodell dargestellt:

Für dieses Objektmodell könnte folgendes Klassenmodul mit dem Namen Cschiff erzeugt werden:

Option Explicit

' Eigenschaften eines Kriegsschiffes

Dim p_anz_leben As Integer

' Positionsangabe des Schiffes in Pixel
Dim p_x As Integer, p_y As Integer

' Geschwindigkeit in x und y - Richtung
' Einheit ist 1 sm/h = 1 kn entspricht
' hier im Spiel 1 Pixel/Takt
Dim p_vx As Integer, p_vy As Integer
 :

' Zugriffsfunktionen auf die Eigenschaften

Property Let vx(wert As Integer)

    p_vx = wert

End Property
Property Get vx() As Integer

    vx = p_vx

End Property

Property Let vy(wert As Integer)

    p_vy = wert

End Property
Property Get vy() As Integer

    vy = p_vy

End Property

Property Let x(wert As Integer)

    p_x = wert

End Property
Property Get x() As Integer

    x = p_x

End Property
Property Let y(wert As Integer)

    p_y = wert

End Property
Property Get y() As Integer

    y = p_y

End Property


Private Sub Class_Initialize()
' Konstruktor der Klasse CKSchiff

    p_x = 500
    p_y = 500
    
End Sub

Private Sub Class_Terminate()
' Destruktor

    MsgBox "Hilfe, ich saufe ab"
    
End Sub

' Methode fahrt
Public Sub fahrt()

    ' Aus Gewschwindigkeit und aktueller Position wird eine
    ' neue Position errechnet
    
    p_x = p_x + p_vx
    p_y = p_y + p_vy
    
End Sub

Konstruktor und Destruktor

Konstruktoren und Destruktoren in VB

Eigenschaften

Methoden

Collections

Instanziierung von Com- Objekten

Ereignisgesteuerte Programmierung

Private Sub sf1_click()

   Dim meldung as String
   meldung = „Hallo Welt“

   MessageBox meldung

End Sub

Steuerelemente

Alle Steuerelemente verfügen über einen gemeinsamen Satz an Methoden und Eigenschaften. Das folgende Objektdiagramm gibt eine Überblick über die wichtigsten:

TextBox

ListBox

Weitere Steuerelemente

Unter Weitere Steuerelemente kann aus dem großen Angebot von ActiveX- Controls ausgewählt werden. Bsp.: MSCAL- Kalender Steuerelement.

Formulare

Lebenszyklus eines Formulars

Objektmodell der Klasse UserForm

Jedes selbstdefinierte Formular in Excel folgt dem Bauplan der Klasse UserForm. Im Folgenden ein Ausschnitt aus dem Objektmodell der Klasse UserForm.

Eigenschaften eines Formulares

Formulare Anzeigen und Verdecken

Durch die Methoden show und hide können Formulare angezeigt und wieder verdeckt vwerden:

Private Sub btnFormularVerdecken_Click()
    UserForm1.Hide
End Sub

Private Sub btnStarteFormular_Click()
    UserForm1.Show (False)
End Sub

Beenden Anwendung mit einem Formular

Eine Anwendung mit einem einzigen Formular wird mittels der Systemroutine Unload beendet:

Unload Me

Alternativ kann eine Anwendung auch mit der Anweisung End beendet werden:

End

MIDI- Fenster

Beenden einer MidiForm (UnloadAll)

Um eine MidiForm explizit zu beenden ist folgender Code notwendig:

Public Sub UnloadAll()
'------------------------------------------------------------
' Procedure: UnloadAll
' Purpose: To Unload all forms once the program finishes
' Input parameters: None
'
' Output parameters:None
'
' Return Value:None
' Author: PETER PILUK
' Date: 06/11/00
'------------------------------------------------------------


   Dim f As Integer
   f = Forms.Count
   Do While f > 0
       Unload Forms(f - 1)
       If f = Forms.Count Then Exit Do
       f = f - 1
   Loop
End Sub

Datei IO

Es gibt zwei Varianten des Zugriffs auf Dateien: IO über die VB- eigenen Funktionen (prozedural) und über eine COM- Klassse des Betriebssystems (objektorientiert)

Prozeduraler Datei IO

Ablauf des Dateizugriffs

Dateitypen

'nur lesen
Open <Dateiname> For Input As #<DatNr>

'nur schreiben
Open <Dateiname> For Output As #<DatNr>

'Anhängen von Text
Open <Dateiname> For Append As #<DatNr>

'lesen und schreiben
Open <Dateiname> For Random As #<DatNr>

'Zeilenweise einlesen
Dim s as String
Line Input #1, s

'Anz Zeichen lesen (z.B. 3)
s = Input(3, 1)

' N-ten Datensatz lesen
Get #1, N, <Datensatzvariabel>

Print #1, "Auszugebender Text"

'N-ten Datensatz schreiben
Put #1, N, <Datensatzvariabel>

Dim laenge as Integer

laenge = LOF(1)

Dim datenstzende as Boolean

datensatzende = EOF(1)

Dim anz_datensaetze as Integer

anz_datensaetze = LOF(1)/LEN(<datensatz>)

Seek #1, <neue_position>

Dim akt_pos as Integer
akt_pos = Seek(#1)

Objektorientierter Datei IO

Beispiel:

' 14.10.2003
'
' Prog. zum Auflisten eines Ordnerinhaltes

' 1) Einlesen des Pfades von einer Dialogbox

Dim pfad_txt
pfad_txt = InputBox("Bitte geben Sie einen Pfad ein!", "Folder")

MsgBox pfad_txt


' Zugreifen auf den Ordner über die ActivX- Komponente Scripting.FileSystemObject
Dim fso
Set fso = CreateObject("Scripting.FileSystemObject")

if fso.FolderExists(pfad_txt) then

   MsgBox "Der Ordner " & pfad_txt & " existiert"

   ' 2) Ordnerinhalt ausgeben

   ' Anzeige aller Unterverzeichnisse vom Ordner

   Dim uvz_liste_txt
   uvz_liste_txt = "Uvz von Ordner:" & vbCrLf  ' vbCrLf = Zeilenumbruchszeichen

   for each el in fso.GetFolder(pfad_txt).subfolders

       ' el ist jetzt ein Folder (Unterverzeichnis-) Objekt
       uvz_liste_txt = uvz_liste_txt & el.name & vbCrLf

   next

   MsgBox uvz_liste_txt

   '---------------------------------------------------------------------------------
   ' Anzeige aller Dateien von LW C:

   Dim dateien_liste_txt
   dateien_liste_txt = "Datein von Ordner:" & vbCrLf

   for each el in fso.GetFolder(pfad_txt).files

        ' el ist jetzt ein Folder (Unterverzeichnis-) Objekt
          dateien_liste_txt = dateien_liste_txt & el.name & " " & el.size & vbCrLf

   next

   MsgBox dateien_liste_txt

else

  MsgBox "Der Ordner " & pfad_txt & " existiert nicht"

end if

Datenbankprogrammierung

Zugriff auf Datenbanken erfolgt über die ADO- Bibliothek.

Objektmodell von ADO

Typen von ADO- Kommandos

Cursor-Typen für Recordsets

Recordsets kapseln den Zugriff auf die Daten via Server- oder Clientseitiger Cursor. Standard ist ein Forward- Only- Cursor, bei dem die Datensätze nicht verändert werden können. Dies ist die effizienteste Form eines Cursors für den Datenbankserver. Soll das Recordset als DataSource für ein DataGrid dienen, so muß mindestens ein adOpenKeyset Cursor eingesetzt werden.

Lock- Typen

Locks sind Datensatzsperren, durch die der gleichzeitige Zugriff auf die Datensätze durch mehrere Benutzer gesteuert wird.

Beispiel: Abfragen der Produkte aus der Artikeldatenbank und Ausgabe in einer Listbox

     ' Verbindung zum server aufbauen
    Dim con As Connection
    Set con = New Connection
    
    con.ConnectionString = "DSN=DBArtikel"
    ' Verbindung öffnen
    con.Open
    
    Dim cmd As Command
    Set cmd = New Command
    
    ' Einstellen der Verbindung, über die Kommandos gesendet werden
    Set cmd.ActiveConnection = con
    
    ' Das zu sendende SQLKommando definieren
    
    cmd.CommandType = adCmdText
    cmd.CommandText = "select pnr, name from dbo.produkte"
    
    Dim rec As Recordset
    Set rec = cmd.Execute
    
    rec.MoveFirst
    
    ' Ausgabe des Tabellenkopfes
    Dim kopfzeile As String
    For i = 0 To rec.Fields.Count - 1
        kopfzeile = kopfzeile & rec.Fields.Item(i).Name & vbTab
    Next
    
    lbxDaten.Clear
    lbxDaten.AddItem kopfzeile
    
    While Not rec.EOF
    
        Dim zeile As String
        zeile = ""
    
        For i = 0 To rec.Fields.Count - 1
            zeile = zeile & rec.Fields.Item(i).Value & vbTab
        Next
        
        lbxDaten.AddItem zeile        
        rec.MoveNext
    
    Wend
    
    con.Close 

Beispiel: Abfragen der Produkte aus der Artikeldatenbank und editieren in einem DataGrid

Über ein Datagrid kann das Resultset auf einfache Weise tabellarisch dargestellt und editiert werden:

Wichtig ist hierbei, daß die Verbindung mit dem Datenbankserver während des gesamten Zeitraumes geöffnet ist. Beispielcode:

    Dim cmd As Command
    Set cmd = New Command
    
    ' Einstellen der Verbindung, über die Kommandos gesendet werden
    Set cmd.ActiveConnection = con
    
    ' Das zu sendende SQLKommando definieren
    
    cmd.CommandType = adCmdText
    cmd.CommandText = "select pnr, name from dbo.produkte"
    
    Dim rec As Recordset
    'Set rec = cmd.Execute
    Set rec = New Recordset
    rec.Open cmd, , adOpenKeyset, adLockOptimistic
    
    Set DataGrid1.DataSource = rec
    ' Achtung: con darf nicht geschlossen werden

Ergebnismengen in Recordsets filtern

Die Ergenismenge kann durch Filter nachträglich reduziert werden. Erlaubt sind alle SQL- Bedingungen.

Beispiel: Nach einer Abfrage auf die Artikel- Tabelle der Artikeldatenbank wird die Ergebnismenge auf alle Datensätze eingeschränkt, deren Vorrat kleiner 2 Stück ist:

rec.Filter = "Vorrat < 2"

Nach einem Datensatz im Recordset suche

In einer durch Recordset verwalteten Ergebnismenge kann mittels der Find- Methode nach einem bestimmten Datensatz gesucht werden. Der Cursor ist nach ausführen von Find auf den gesuchten Datensatz plaziert oder am Ende des Recordsets.

rec.Find = "lfnr = 2"

Datensätze hinzufügen, aktualisieren und löschen

Hinzufügen eines Datensatzes

rec.AddNew
...
rec.Update

Löschen eines Datensatzes

rec.Delete

Requery

Mittels Requery können Datensätze erneut abgefragt werden um die Konsistenz zwischen Recordset und Datenbank zu wahren.

rec.requery

Recordsets persistent auf Festplatte speichern und zurückladen

Der Inhalt von Recordsets kann als XML- Datei auf der Festplatte gesichert werden wie folgt:

rec.Save "c:\daten\rec1.xml", adPersistXML

Später (z.B. nach erneuten Programmstart) können die Daten in das Recordset wieder zurückgeladen werden:

Dim rec As Recordset

Set rec = New Recordset
rec.Open "c:\daten\rec1.xml", "Provider=MSPersist"
    
Set DataGrid1.DataSource = rec

AdoDc: Verbindung mit Datenbank und Datensatznavigation

AdoDc ist ein AktiveX- Control, welches über Projekt\Komponenten\Microsoft ADO Data Control 6.0 eingebunden werden muß. Es kann als Datasource für DataGrid etc. genutzt werden.

Die wichtigsten Eigenschaften von AdoDc sind

1. ConnectionString: definiert die Verbindungszeichenfolge und damit ein Connection- Objekt zum Zugriff auf die Datenbank

2. CommandType: Definiert, ob RecordSource einen Tabellennamen, eines gespeicherte Prozedur oder eine SQL- Anweisung ist

3. RecordSource: In Abhängigkeit von CommandType ein Tabellenname, eine gespeicherte Prozedur oder eine SQL- Anweisung.

Grafikprogrammierung

Objekte mit Grafikmethoden

• Form

• PictureBox

Grafikmethoden

Anwendungen Verpacken und Weitergeben

1. Über Add-Ins\AddInn- Manager den Verpackungs- und Weitergabeassistenten einbinden

2. Im Projektexplorer zum Projekt das Kontextmenü aufrufen, und hier den Paket- und Weitergabeassistenten aufrufen