Rubrik: OOP / Tools | VB-Versionen: VB5, VB6 | 01.11.02 |
OOP - Objektorientierte Programmierung In 15 Schritten eine Collection Class in VB6 erstellen! Anhand eines kleinen Beispiels zur Speichung von Personendaten wird Ihnen in diesem Workshop das Klassenkonzept von VB ein wenig näher gebracht. | ||
Autor: Dieter Otter / Martin Riedl | Bewertung: | Views: 47.769 |
In 15 Schritten eine Collection Class in VB6 erstellen! Anhand eines kleinen Beispiels zur Speichung von Personendaten wird Ihnen in diesem Workshop das Klassenkonzept von VB ein wenig näher gebracht.
Klassenmodul
1. Klassenmodul erstellen
Starten Sie die VB-IDE, erstellen ein neues Projekt und fügen dem Projekt gleich danach ein neues Klassenmodul hinzu (Menü Projekt - Klassenmodul hinzufügen).
2. Klassennamen vergeben
Die Klassenname lautet standardmäßig "Class1". Um später mehr Übersicht zu bekommen, ändern Sie den Namen in Personen, indem Sie im Eigenschaften-Fenster von "Class1" für Name die Bezeichnung "Personen" eintragen. Der neue Klassennamen wird darauf sofort im Projekt-Explorer angezeigt.
3. Empfehlenwert: Option Explicit
Im Code-Fenster (Allgemein-Teil) darauf achten, dass hier Option Explicit steht, was bedeutet, dass alle im Klassenmodul verwendeten Variablen vorher deklariert werden müssen (hiermit kann man sich sehr viel Ärger sparen
Option Explicit
OOP - Objektorientierte Programmierung
4. Jetzt beginnt das OOP
Für unser kleines Beispiel sollen Personendaten verwaltet werden - und zwar Nachname, Vorname und Geburtsdatum.
5. Variablen deklarieren
Hierzu müssen die entsprechenden Variablen im Allgemein-Teil des Klassenmoduls deklariert werden - und zwar als Private, so dass diese "außerhalb" der Klasse nicht "sichtbar" sind.
Private mvarVorname As String Private mvarNachname As String Private mvarGebDat As Date
6. Schnittstelle nach "außen"
Damit wir später Zugriff auf die Variablen auch von außerhalb haben, brauchen wir entsprechende Eigenschaften, mit denen wir dann auf die als "Private" deklarierten Variablen zugreifen können. Eigenschaften werden über das Schlüsselwort Property erstellt, wobei man hier zwischen Eigenschaften mit "nur Lesezugriff", "nur Schreibzugriff" oder "Lese-/ und Schreibzugriff" unterscheidet. Sollen Eigenschaften von außen gelesen werden können, stellt man dem "Property" das Schlüsselwort Get voraus. Um eine Eigenschaft von außen ändern zu können, deklariert man zusätzlich eine Let Property Prozedur.
' Geburtsdatum: Schreibzugriff Public Property Let GeburtsDatum(ByVal vData As Date) mvarGebDat = vData End Property ' Geburtsdatum: Lesezugriff Public Property Get GeburtsDatum() As Date GeburtsDatum = mvarGebDat End Property
' Vorname: Schreibzugriff Public Property Let Vorname (ByVal vData As String) mvarVorname = vData End Property ' Vorname: Lesezugriff Public Property Get Vorname() As String Vorname = mvarVorname End Property
' Nachname: Schreibzugriff Public Property Let Nachname(ByVal vData As String) mvarNachname = vData End Property ' Nachname: Lesezugriff Public Property Get Nachname () As String Nachname = mvarNachname End Property
7. Die Klasse "Personen" im ersten Test
So jetzt haben wir schon mal die Eigenschaften, über die wir einen Personen-Datensatz in der Klasse speichern können. Wechseln Sie in den Code-Teil der Form1 und deklarieren dort eine Variable wie folgt:
Option Explicit Dim Person As Personen
Im Form_Load Ereignis erstellen wir dann einmal testweise einen Personen-Datensatz:
Private Sub Form_Load() ' Neue "Personen"-Klasse erstellen Set Person = New Personen ' Personendaten speichern With Person .Vorname = "Vampire" .Nachname = "666" .GeburtsDatum = Date End With End Sub
Ziehen Sie auf die Form eine Schaltfläche (Command1), über die die gespeicherten Daten abgerufen werden sollen:
Private Sub Command1_Click() ' Personen-Daten in MsgBox ausgeben Dim sData As String With Person sData = "Vorname: " & .Vorname & vbCrLf & _ "Nachname: " & .Nachname & vbCrLf & _ "Geburtsdatum: " & .GeburtsDatum End With ' MsgBox anzeigen MsgBox sData End Sub
Collection - Sammlung von Daten
Jetzt können wir zwar schon die Daten einer Person speichern, aber: Wir wollen ja nicht nur einen Datensatz verwalten, sondern mehrere! Klar könnte man jetzt hergehen und ein Array der Klasse Personen anlegen. Das wäre aber nicht im Sinne von OOP. Und aus diesem Grund kommt jetzt das Collection-Objekt ins Spiel. Hierzu benötigen wir eine weitere neue Klasse mit dem Collection-Objekt, so dass wir dann später beliebig viele Personen-Datensätze verwalten können.
8. Die Klasse "col_Personen
Fügen Sie dem Projekt ein neues Klassenmodul hinzu (Menü "Projekt - Klassenmodul hinzufügen") und nennen Sie die neue Klasse col_Personen. Eine Collection ist ein wenig vergleichbar mit einem Array, jedoch lassen sich in einer Collection Objekte speichern und zudem verfügt das Collection-Objekt über weitere Eigenschaften, wie Add, Remove und Count.
9. Speichern der Objekte in der Klasse
Für das Speichern der Objekte benötigen wir wieder eine Private Variable - diesmal aber kein String, sondern eine Collection:
Option Explicit Private mCol As Collection
10. Hinzufügen von Daten zur Collection
Als nächstes brauchen wir eine Funktion, um die Daten in der Collection speichern zu können. Diese Funktion muss natürlich von außerhalb der Klasse aufrufbar sein, weshalb sie logischerweise dann als Public deklariert werden muss. Die Funktion selbst nennen wir Add. Als Parameter erwartet die Funktion die zu speichernden Daten. Der Rückgabewert der Funktion entspricht unserer Klasse Personen, die wir dann wiederum im Collection-Objekt speichern.
Public Function Add(ByVal Vorname As String, _ ByVal Nachname As String, _ ByVal Geburtsdatum As Date) As Personen ' Neues Personen-Objekt erstellen Dim objNewMember As Personen Set objNewMember = New Personen ' Daten an das erstellte Objekt zuweisen With objNewMember .Vorname = Vorname .Nachname = Nachname .Geburtsdatum = Geburtsdatum End With ' das Objekt schließlich zur Collection hinzufügen mCol.Add objNewMember ' das neu erstellte Objekt zurückgeben Set Add = objNewMember ' Objekt löschen Set objNewMember = Nothing End Function
11. Zugriff auf die Daten
Mit der Add-Funktion lassen sich jetzt zwar beliebig viele Datensätze speichern, aber irgendwie müssen wir ja auch wieder an die Daten kommen. Dafür legen wir uns jetzt eine Property (Eigenschaft) an, die uns die Daten eines bestimmten Datensatzes zurückgibt. Von welchem Typ muss die Eigenschaft jetzt sein? Let oder Get oder Set ??? Korrekt: GETItem:
Public Property Get Item(ByVal Index As Long) As Personen ' Bestimmten Datensatz der Collection zurückgeben. ' Der Datensatz wird über die Position (Index) "angesprochen". Set Item = mCol(Index) End Property
12. Anzahl der gespeicherten Daten ermitteln
Das Speichern und Abrufen der Daten aus dem Collection-Objekt funktioniert soweit. Wir wollen aber auch jederzeit die bisherige Anzahl gespeicherten Daten abfragen können.
Public Property Get Count() As Long ' Anzahl Collections-Einträge Count = mCol.Count End Property
Da das Collection-Objekt von Haus aus eine Count-Eigenschaft besitzt, geben wir diese einfach über unsere eigene Count-Eigenschaft nach außen weiter. Die Count-Eigenschaft soll nur gelesen erden können, weshalb wir auch nur die Get Count Eigenschaft zur Verfügung stellen (kein "Property Let Count" !!!).
13. Löschen von Datensätzen
Neben dem Hinzufügen von neuen Daten soll es auch möglich sein, gezielt einen Datensatz aus der Collection zu löschen. Hierfür verwenden wir die Remove-Methode des Collection-Objekts, die wir jetzt nur wieder nach außen hin zugänglich machen müssen:
Public Sub Remove(ByVal Index As Integer) ' Löschen eines Eintrags aus dem Collection-Objekt mCol.Remove Index End Sub
14. Class_Initialize und Class_Terminate
Abschließend brauchen wir noch eine Funktion, die beim Erstellen der Klasse das Collection-Objekt initialisiert und beim Beenden der Klasse den belegten Speicher wieder freigibt. Dies erfolgt in den Ereignisse Initialize und Terminate des Klassenmoduls.
Private Sub Class_Initialize() ' Erstellt das Collection-Objekt beim ersten Zugriff ' auf die Klasse Set mCol = New Collection End Sub
Private Sub Class_Terminate() ' Zerstört das Collection-Objekt, ' wenn die Klasse beendet wird Set mCol = Nothing End Sub
Zusammenfassendes Beispiel
Unsere Klassen sind nun erstellt und einsatzbereit. Wir müssen nun nur noch in unserem Hauptprogramm die Klasse benutzen
Hierzu wird die "Collection-Klasse" wie folgt deklariert:
' Deklarieren der Collection-Klasse "Personen" Dim Personen As col_Personen
Private Sub Form_Load() ' Neues Collection-Objekt erstellen Set Personen = New col_Personen End Sub
Hinzufügen von neuen Daten:
Das Hinzufügen neuer Datensätze erfolgt über die öffentliche Funktion Add:
' Neuen Datensatz hinzufügen Personen.Add "Dieter", "Otter", "05.05.1973" ' Weiteren Datensatz hinzufügen Personen.Add "Vampire", "666", Date ' und noch ein Datensatz Personen.Add "Moni", "Knödel", "01.01.1980"
Anzahl gespeicherter Datensätze ermitteln:
Dim nCount As Long ' Anzahl Datensätze nCount = Personen.Count MsgBox CStr(nCount) & " Datensätze gespeichert."
Ändern eines Datensatzes
Über die Item-Eigenschaft der col_Personen-Klasse lassen sich die Daten eines Datensatzes wie folgt ändern:
' 3. Datensatz ändern With Personen.Item(3) ' Geburtsdatum ändern .GeburtsDatum = "10.07.1965" End With
Einzelnen Datensatz löschen:
Das Löschen eines einzelnen Datensatzes erfolgt durch Aufruf der Remove-Methode unter Angabe der Position (Index):
' 2. Datensatz löschen Personen.Remove 2 ' Neue Anzahl Datensätze anzeigen MsgBox CStr(Personen.Count)
Durchlaufen der Datensätze
Über eine For..Next-Anweisung können wir alle Datensätze durchlaufen und die Namen z.B. in eine ListBox übertragen:
Dim oItem As Person ' alle Datensätze durchlaufen Dim i As Integer With Personen For i = 1 To .Count List1.AddItem .Item(i).Nachname & " " & .Item(i).Vorname Next i End With
Jetzt sollte das alles laufen. Wir hoffen, es hat Ihnen genauso viel Spaß gemacht, wie es uns Spaß gemacht hat diesen kleinen OOP-Workshop zu schreiben und hoffen weiterhin, dass Sie der Workshop ein wenig dazu bringt, auch in Visual Basic 6 objektorientiert zu programmieren und das Klassenkonzept einzusetzen.