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:     [ Jetzt bewerten ]	Views:  46.944

Geben Sie hier Ihre persönliche Bewertung ab! Anzahl Bewertungen bisher: 11 Bewertung insgesamt: sehr gut Durchschnittliche Bewertung: 4.9 von 5 Sternen

sehr gut     gut     nützlich     mittelmäßig     mangelhaft

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.