{"id":55000423,"date":"2024-04-01T00:00:00","date_gmt":"2024-04-23T12:48:18","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=423"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Klassen_programmieren_unter_VBA","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Klassen_programmieren_unter_VBA\/","title":{"rendered":"Klassen programmieren unter VBA"},"content":{"rendered":"

\"\"<\/p>\n

Neben den Standardmodulen gibt es in VBA-Projekten auch noch einen weiteren Typ von Modulen, nämlich die Klassenmodule. Diese kommen wiederum in zwei Ausführungen: Es gibt alleinstehende Klassenmodule und eingebaute Klassenmodule, die den Code zu bestimmten Objekten enthalten – wie beispielsweise die Klassenmodule zu Formularen und Berichten in Access, zu Word-Dokumenten für das Dokument oder in Excel für Worksheet und Workbook. Auch in Outlook gibt es Klassenmodule. Wir wollen uns an dieser Stelle jedoch auf die alleinstehenden Klassenmodule konzentrieren, also auf solche, die wir selbst anlegen müssen. Hier schauen wir uns an, warum man diese überhaupt nutzen sollte, welche Anwendungszwecke es gibt und welche Best Practices sich für uns etabliert haben.<\/b><\/p>\n

Unterschied zwischen Standardmodulen, eingebauten Klassenmodulen und benutzerdefinierten Klassenmodulen<\/h2>\n

Zunächst einmal wollen wir den Unterschied zwischen den verschiedenen Typen von Modulen erläutern. <\/p>\n

Standardmodule<\/h2>\n

Wir beginnen mit den Standardmodulen:<\/p>\n

    \n
  • Standardmodule sind einfache Container für VBA-Code, die in einer VBA-Projektdatei enthalten sind und die selbst hinzufügen müssen.<\/li>\n
  • Sie enthalten normalerweise Funktionen, Prozeduren und Variablen, die in verschiedenen Teilen des Projekts verwendet werden können.<\/li>\n
  • Ein Standardmodul kann Funktionen und Prozeduren enthalten, die unabhängig voneinander sind und direkt vom Rest des Codes aufgerufen werden können.<\/li>\n
  • Standardmodule werden oft verwendet, um allgemeine Funktionen und Hilfsroutinen zu speichern, die von verschiedenen Teilen des Projekts benötigt werden.<\/li>\n<\/ul>\n

    Klassenmodule allgemein<\/h2>\n

    Wir schauen uns erst einmal die allgemeinen Eigenschaften an, die allen Klassenmodulen gemein sind:<\/p>\n

      \n
    • Klassenmodule ermöglichen die Definition benutzerdefinierter Datenstrukturen, die als Objekte bezeichnet werden.<\/li>\n
    • Sie dienen dazu, spezifische Arten von Objekten zu definieren, die Eigenschaften, Methoden und Ereignisse haben können.<\/li>\n
    • Klassenmodule ermöglichen die Erstellung von Objekten mit spezifischen Verhaltensweisen und Datenstrukturen, was die Codeorganisation und -wiederverwendbarkeit verbessert.<\/li>\n
    • Sowohl eingebauten als auch alleinstehenden Klassenmodulen können wir benutzerdefinierte Eigenschaften, Methoden und Ereignisse hinzufügen.<\/li>\n<\/ul>\n

      Eingebaute Klassenmodule<\/h2>\n

      Unter eingebauten Klassenmodulen verstehen wir solche Klassenmodule, wie sie beispielsweise in Word, Excel, Outlook oder Access automatisch mit den dortigen Objekten angelegt werden oder dort bereits vorhanden sind, wenn wir den VBA-Editor erstmalig öffnen.<\/p>\n

      Bild 1 zeigt ein Klassenmodul eines Word-Dokuments.<\/p>\n

      \"Ein<\/p>\n

      Bild 1: Ein eingebautes Klassenmodul, hier in Word.<\/span><\/b><\/p>\n

        \n
      • Klassenmodule können Ereignisse enthalten, die es Objekten ermöglichen, auf bestimmte Aktionen zu reagieren, wie das Öffnen oder Schließen einer Arbeitsmappe in Excel, das Öffnen eines Word-Dokuments oder das Anzeigen eines Formulars in Access.<\/li>\n
      • Sie enthalten vorgefertigte Ereignisse, auf deren Basis wir Ereignisprozeduren implementieren können.<\/li>\n<\/ul>\n

        Alleinstehende Klassenmodule<\/h2>\n

        Im Gegensatz zu den eingebauten Klassenmodulen können wir beliebig viele alleinstehende Klassenmodule erstellen. Dazu nutzen wir den Kontextmenübefehl Einfügen|Klassenmodul <\/b>des Projekt-Explorers (siehe Bild 2) oder den gleichnamigen Befehl der Menüleiste des VBA-Editors.<\/p>\n

        \"Hinzufügen<\/p>\n

        Bild 2: Hinzufügen eines Klassenmoduls<\/span><\/b><\/p>\n

        Damit erzeugen wir erst einmal einen neuen Eintrag im Projekt-Explorer, der standardmäßig Klasse1 <\/b>genannt und direkt als neues Fenster im VBA-Editor angezeigt wird (siehe Bild 3).<\/p>\n

        \"Das<\/p>\n

        Bild 3: Das neue Klassenmodul im Projekt-Explorer<\/span><\/b><\/p>\n

        In dieses Fenster können wir nun Code schreiben, genau wie in einem Standardmodul. Wir können den dort enthaltenen Code aber nicht so einfach ausführen in einem Standardmodul. Wir müssen die Klasse erst in Form eines Objekts instanziieren und dieses einer Objektvariablen zuweisen, damit wir auf seine Eigenschaften, Methoden oder Ereignisse zugreifen können.<\/p>\n

        Klassenmodul umbenennen<\/h2>\n

        Als Erstes erledigen wir allerdings eine wichtige Aufgabe: Das Klassenmodul soll einen anderen Namen als Klasse1 <\/b>erhalten (siehe Bild 4). <\/p>\n

        \"Umbenennen<\/p>\n

        Bild 4: Umbenennen eines Klassenmoduls<\/span><\/b><\/p>\n

        Zu Beispielzwecken wollen wir die Klasse clsAdresse <\/b>nennen. Das Präfix cls <\/b>steht für Class<\/b>, also Klasse. Mit der Klasse wollen wir die typischen Eigenschaften einer Adresse aufnehmen und abfragen können. Nach dem Umbenennen sehen wir den neuen Klassennamen gleich an mehreren Stellen (siehe Bild 5).<\/p>\n

        \"Der<\/p>\n

        Bild 5: Der neue Klassenname tritt gleich an drei Stellen in Erscheinung.<\/span><\/b><\/p>\n

        Welche Elemente machen eine Klasse nach außen hin aus?<\/h2>\n

        Es gibt drei verschiedene Elemente, die wir von außen nutzen können, die eine Klasse charakterisieren:<\/p>\n

          \n
        • Eigenschaften<\/b>: Eigenschaften erscheinen als lesbare und\/oder schreibbare Eigenschaften. Wir können für Klassen beliebig viele Eigenschaften festlegen und durch bestimmte Schreibweisen angeben, ob man diese bei der Programmierung der Klasse lesend, schreibend oder lesend und schreibend zugreifbar möchte.<\/li>\n
        • Methoden<\/b>\/Funktionen<\/b>: Dies sind im Prinzip Sub<\/b>– und Function<\/b>-Prozeduren wie in Klassenmodulen, nur dass sie nur aufgerufen werden können, wenn es eine Objektvariable mit einem Verweis auf eine Instanz der Klasse gibt, über die wir auf diese Methoden und Funktionen zugreifen können. Was Instanzen und Objektvariablen sind, erläutern wir weiter unten.<\/li>\n
        • Ereignisse<\/b>: Ereignisse sind eine echte Besonderheit von Klassenmodulen gegenüber Standardmodulen. Die Ereignisse von eingebauten Standardmodulen werden meist durch Benutzeraktionen ausgelöst. Wir können dann Ereignisprozeduren programmieren, die als Reaktion auf solche Benutzeraktionen gestartet werden sollen – zum Beispiel beim Öffnen eines Dokuments, beim Anklicken einer Schaltfläche, beim Absenden einer E-Mail et cetera. Bei Klassenmodulen können wir allerdings selbst genau festlegen, wann ein solches Ereignis ausgelöst werden soll. Wie das gelingt und wozu wir das nutzen können, zeigen wir ebenfalls weiter unten.<\/li>\n<\/ul>\n

          Welche Elemente gibt es noch innerhalb einer Klasse?<\/h2>\n

          Innerhalb von Klassenmodulen können wir all die von herkömmlichen Modulen bekannten Elemente nutzen – Prozeduren, Funktionen, Variablen, Konstanten und so weiter.<\/p>\n

          Es gibt allerdings einen wichtigen Unterschied zwischen den Eigenschaften, Methoden und Ereignissen, die wir bei Vorhandensein einer Instanz der Klasse nutzen können, und den übrigen Elementen: Die Eigenschaften, Methoden und Ereignisse sind öffentliche Elemente, wir müssen diese daher mit dem Schlüsselwort Public <\/b>deklarieren. Die Elemente, die wir nur innerhalb des Klassenmoduls nutzen wollen, deklarieren wir mit dem Schlüsselwort Private<\/b>. Diese sind nicht von außerhalb sichtbar.<\/p>\n

          Instanziieren einer Klasse<\/h2>\n

          Da unsere Klasse noch keine Elemente enthält, also keine Eigenschaften, Methoden oder Ereignisse, behelfen wir uns für die Beschreibung der Instanziierung einer Klasse einer eingebauten Klasse. In diesem Fall wollen wir uns die Klasse Collection <\/b>ansehen. Diese ist eine Klasse, die den Umgang mit Auflistungen vereinfacht. Wir können dieser Klasse mit der Add<\/b>-Methode Elemente hinzufügen, mit Remove <\/b>Elemente entfernen, mit Count <\/b>die enthaltenen Elemente zählen und mit Item(i) <\/b>auf das Element mit dem Index i <\/b>zugreifen.<\/p>\n

          Vor allem aber müssen wir, bevor wir das alles erledigen können, eine Instanz der Klasse erstellen und diese mit einer Objektvariablen referenzieren. Umgangssprachlich redet man auch von Speichern eines Objekts in einer Objektvariablen, was aber nicht ganz korrekt ist: Tatsächlich wird in einer Objektvariablen nämlich nur eine Zahl als Zeiger auf die Speicherposition des Objekts gespeichert. Das Objekt selbst befindet sich an der angegebenen Stelle im Speicher.<\/p>\n

          Doch schreiten wir zur Tat. Wir benötigen zwei Schritte, um eine Objektvariable mit einer neuen Instanz eines Objekts zu füllen:<\/p>\n

            \n
          • das Deklarieren der Objektvariablen und<\/li>\n
          • das Instanziieren des Objekts auf Basis der Klasse und Zuweisen an die Objektvariable.<\/li>\n<\/ul>\n

            Bei der Deklaration verwenden wir den Namen der Klasse als Datentyp:<\/p>\n

            Dim <\/span>objCollection As <\/span>Collection<\/pre>\n
            Das Instanziieren erfolgt mit dem Schlüsselwort New <\/b>mit dem Typ des zu erzeugenden Elements, hier Collection<\/b>, und dem Zuweisen an die Objektvariable:<\/p>\n
            Set<\/span> objCollection = New<\/span> Collection<\/pre>\n
            Wir können diese beiden Anweisungen sogar in einer einzigen Anweisung zusammenfassen:<\/p>\n
            Dim <\/span>objCollection As <\/span>New<\/span> Collection<\/pre>\n
            Wo deklarieren und wo instanziieren wir Klassen?<\/h2>\n
            Bevor wir das Instanziieren anhand der Collection-Klasse ausprobieren, benötigen wir ein Modul, dem wir den Code hinzufügen können. Dazu erstellen wir ein neues Standardmodul, das wir unter dem Namen mdlBeispiele <\/b>speichern. Warum ein Standardmodul und nicht etwa ein alleinstehendes Klassenmodul, wo wir doch schon über diesen Modultyp reden? Weil wir diese Anweisungen direkt ausprobieren wollen, und das gelingt am einfachsten in Standardmodulen. Hier legen wir eine Prozedur an, welche die beiden oben genannten Schritte enthält:<\/p>\n
            Public Sub <\/span>CollectionInstanziieren()\r\n     Dim <\/span>col As <\/span>Collection\r\n     Set<\/span> col = New<\/span> Collection\r\nEnd Sub<\/span><\/pre>\n
            Wenn wir diese Prozedur ausführen, geschieht nichts Sichtbares. Dazu benötigen wir noch einige weitere Anweisungen wie hier:<\/p>\n
            Public Sub <\/span>CollectionInstanziieren()\r\n     Dim <\/span>objCollection As <\/span>Collection\r\n     Dim <\/span>i As Integer<\/span>\r\n     Set<\/span> objCollection = New<\/span> Collection\r\n     objCollection.Add \"Element 1\"\r\n     objCollection.Add \"Element 2\"\r\n     For i = 1 To objCollection.Count\r\n         Debug.Print<\/span> objCollection.Item(i)\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
            Dies erstellt ein neues Collection<\/b>-Objekt in der Variablen objCollection<\/b>, fügt mit der Add<\/b>-Methode zwei Elemente hinzu und durchläuft anschließend eine Schleife über alle Elemente, wobei sie deren Inhalt im Direktbereich des VBA-Editors ausgibt. Die Objektvariable wird nach dem Verlassen der Prozedur automatisch zerstört, weil sich der Gültigkeitsbereich durch die Deklaration innerhalb der Prozedur auf diese beschränkt. Um das zu ändern, können wir nun noch die Deklaration von objCollection <\/b>aus der Prozedur herausziehen und diese im Kopf des Standardmoduls speichern:<\/p>\n
            Dim <\/span>objCollection As <\/span>Collection<\/pre>\n
            Dadurch verlängern wir die Lebenszeit dieses Objekts. Wir instanziieren es wieder und fügen zwei Elemente hinzu:<\/p>\n
            Public Sub <\/span>CollectionFuellen()\r\n     Set<\/span> objCollection = New<\/span> Collection\r\n     objCollection.Add \"Element 1\"\r\n     objCollection.Add \"Element 2\"\r\nEnd Sub<\/span><\/pre>\n
            Da die Variable nun außerhalb der Prozedur gespeichert wurde, können wir von einer weiteren Prozedur aus, die wir anschließend aufrufen, immer noch auf die Inhalte der Collection zugreifen:<\/p>\n
            Public Sub <\/span>CollectionAuslesen()\r\n     Dim <\/span>i As Integer<\/span>\r\n     For i = 1 To objCollection.Count\r\n         Debug.Print<\/span> objCollection.Item(i)\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
            Nun wissen wir schon einmal, wie wir Objekte auf Basis von eingebauten Klassen instanziieren. Nun wollen wir eine eigene Klasse programmieren und diese instanziieren und nutzen.<\/p>\n
            Sichtbarkeit der Elemente einer Klasse<\/h2>\n
            Dazu kehren wir zu der Klasse clsAdresse<\/b> zurück, die wir bereits weiter oben erstellt haben. Dieser Klasse fügen wir nun eine erste öffentliche Eigenschaft namens Vorname <\/b>hinzu. Diese deklarieren wir einfach als öffentliche Variable des Typs String<\/b>:<\/p>\n
            Public <\/span>Vorname As String<\/span><\/pre>\n
            Die Klasse sieht bisher also wie in Bild 6 aus. Dennoch können wir die Klasse bereits als vollwertige Klasse einsetzen. Dazu erstellen wir ein weiteres Modul, dem wir die Deklaration einer Objektvariablen auf Basis unserer Klasse hinzufügen:<\/p>\n
            \"Der<\/p>\n
            Bild 6: Der bisherige Code der Klasse<\/span><\/b><\/p>\n
            Dim <\/span>objAdresse As <\/span>clsAdresse<\/pre>\n
            Instanziieren wir die Klasse nun in einer Prozedur, können wir anschließend nach Eingabe des Variablennamens und des Punkts per IntelliSense auf die bisher einzige Eigenschaft der Klasse zugreifen – siehe Bild 7.<\/p>\n
            \"Instanziieren<\/p>\n
            Bild 7: Instanziieren und Verwenden einer benutzerdefinierten Klasse<\/span><\/b><\/p>\n
            Wir weisen der Eigenschaft wie folgt einen Wert zu:<\/p>\n
            Public Sub <\/span>AdresseInstanziieren()\r\n     Set<\/span> objAdresse = New<\/span> clsAdresse\r\n     objAdresse.Vorname = \"André\"\r\nEnd Sub<\/span><\/pre>\n
            In einer weiteren Prozedur können wir nun immer noch auf die Eigenschaft zugreifen, da das Objekt in der Variablen objAdresse <\/b>des Standardmoduls gespeichert und somit immer noch gültig ist:<\/p>\n
            Public Sub <\/span>AdresseAuslesen()\r\n     Debug.Print<\/span> objAdresse.Vorname\r\nEnd Sub<\/span><\/pre>\n
            Damit haben wir unsere erste benutzerdefinierte Klasse programmiert, ein Objekt auf seiner Basis instanziiert und eine Eigenschaft zugewiesen und ausgelesen.<\/p>\n
            Zerstören eines Objekts<\/h2>\n
            In einer weiteren Prozedur sorgen wir nun dafür, dass die Objektvariable geleert und somit auch die enthaltene Instanz der Klasse clsAdresse <\/b>zerstört wird:<\/p>\n
            Public Sub <\/span>AdresseZerstoeren()\r\n     Set<\/span> objAdresse = Nothing\r\nEnd Sub<\/span><\/pre>\n
            Wenn wir danach erneut die Prozedur AdresseAuslesen <\/b>aufrufen, erhalten wir die Fehlermeldung aus Bild 8. Die Objektvariable objAdresse <\/b>ist leer, daher können wir nicht mehr auf ihre Eigenschaften zugreifen.<\/p>\n
            \"Fehler<\/p>\n
            Bild 8: Fehler beim Zugriff auf eine leere Objektvariable<\/span><\/b><\/p>\n
            Testen, ob eine Objektvariable leer ist<\/h2>\n
            Wenn wir prüfen wollen, ob die Objektvariable ein Objekt enthält, können wir diese wie folgt mit dem Operator Is Nothing <\/b>untersuchen. <\/p>\n
            Public Sub <\/span>AdresseAuslesen()\r\n     If <\/span>Not<\/span> objAdresse Is Nothing Then<\/span>\r\n         Debug.Print<\/span> objAdresse.Vorname\r\n     Else<\/span>\r\n         Debug.Print<\/span> \"objAdresse ist leer.\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
            Weitere Eigenschaften<\/h2>\n
            Unsere Klasse soll nun nicht nur eine Eigenschaft anbieten, sondern gleich mehrere. Dazu fügen wir die Eigenschaften zunächst als öffentliche Variablen hinzu, zum Beispiel so:<\/p>\n
            Public <\/span>Firma As String<\/span>\r\nPublic <\/span>Anrede As String<\/span>\r\nPublic <\/span>Vorname As String<\/span>\r\nPublic <\/span>Nachname As String<\/span>\r\nPublic <\/span>Strasse As String<\/span>\r\nPublic <\/span>PLZ As String<\/span>\r\nPublic <\/span>Ort As String<\/span>\r\nPublic <\/span>Land As String<\/span><\/pre>\n
            Eigenschaften schreib- und\/oder lesbar machen<\/h2>\n
            Mit den auf diese Weise deklarierten Eigenschaften können wir jede Eigenschaft sowohl lesen als auch schreiben. Das ist nicht immer gewünscht. Auch bei den eingebauten VBA-Klassen gibt es einige Eigenschaften, die nur gelesen, aber nicht geschrieben werden dürfen. Aber wie realisieren wir das? Gibt es bestimmte Schlüsselwörter, mit denen wir dies angeben können? Nein, das ist nicht der Fall. Wir müssen dazu einen anderen Weg gehen und schauen uns das anhand der Eigenschaft Firma <\/b>an. Wir gehen in zwei Schritten vor. Im ersten Schritt stellen wir den Gültigkeitsbereich von Public <\/b>auf Private <\/b>um. Außerdem fügen wir dieser nun privaten Variablen das Präfix m_ <\/b>hinzu:<\/p>\n
            Private <\/span>m_Firma As String<\/span><\/pre>\n
            Nun können wir diese Eigenschaft nach dem Erstellen eines Objekts auf Basis der Klasse clsAdresse <\/b>weder lesen noch schreiben. Um dies umzusetzen, legen wir zwei sogenannte Property<\/b>-Prozeduren an. Die erste verwendet neben Public Property <\/b>das Schlüsselwort Let<\/b>, was bedeutet, dass wir mit dieser Prozedur Werte zuweisen können. Diese landen zunächst im Parameter str<\/b>, den wir dann innerhalb der Prozedur der privaten Variablen m_Firma <\/b>zuweisen:<\/p>\n
            Public Property Let <\/span>Firma(str As String<\/span>)\r\n     m_Firma = str\r\nEnd Property<\/span><\/pre>\n
            Damit können wir der privaten Variablen aber lediglich Werte zuweisen. Um den Wert von m_Firma <\/b>auch noch auslesen zu können, benötigen wir eine weitere Property<\/b>-Prozedur, diesmal mit dem Schlüsselwort Get<\/b>. Diese hat keinen Parameter, sondern gibt wie eine herkömmliche Funktion den Wert zurück, den wir dem Prozedurnamen innerhalb der Prozedur zuweisen -hier also m_Firma<\/b>:<\/p>\n
            Public Property Get <\/span>Firma() As String<\/span>\r\n     Firma = m_Firma\r\nEnd Property<\/span><\/pre>\n
            Das ist leider ein wenig Aufwand. Der Code für die restlichen Eigenschaften, umgewandelt in private Variablen mit Property Let<\/b>– und Property Get<\/b>-Prozeduren, ist recht umfangreich. Im Artikel VBA-Editor: Klasseneigenschaften per Mausklick <\/b>(www.vbentwickler.de\/422<\/b>) beschreiben wir allerdings, wie Du mit einem Mausklick die Zeile Public Firma As String <\/b>in das obige Konstrukt umwandeln kannst. Das Ergebnis sieht wie folgt aus:<\/p>\n
            Private <\/span>m_Anrede As String<\/span>\r\nPrivate <\/span>m_Vorname As String<\/span>\r\nPrivate <\/span>m_Nachname As String<\/span>\r\nPrivate <\/span>m_Strasse As String<\/span>\r\nPrivate <\/span>m_PLZ As String<\/span>\r\nPrivate <\/span>m_Ort As String<\/span>\r\nPrivate <\/span>m_Land As String<\/span>\r\nPublic Property Let <\/span>Anrede(str As String<\/span>)\r\n     m_Anrede = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Anrede() As String<\/span>\r\n     Anrede = m_Anrede\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Vorname(str As String<\/span>)\r\n     m_Vorname = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Vorname() As String<\/span>\r\n     Vorname = m_Vorname\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Nachname(str As String<\/span>)\r\n     m_Nachname = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Nachname() As String<\/span>\r\n     Nachname = m_Nachname\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Strasse(str As String<\/span>)\r\n     m_Strasse = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Strasse() As String<\/span>\r\n     Strasse = m_Strasse\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>PLZ(str As String<\/span>)\r\n     m_PLZ = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>PLZ() As String<\/span>\r\n     PLZ = m_PLZ\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Ort(str As String<\/span>)\r\n     m_Ort = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Ort() As String<\/span>\r\n     Ort = m_Ort\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Land(str As String<\/span>)\r\n     m_Land = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Land() As String<\/span>\r\n     Land = m_Land\r\nEnd Property<\/span><\/pre>\n
            Was haben wir damit erreicht? Wir können nun wie in Bild 9 auf alle Eigenschaften lesend und schreibend zugreifen.<\/p>\n
            \"Nun<\/p>\n
            Bild 9: Nun können wir auf alle Eigenschaften per IntelliSense zugreifen.<\/span><\/b><\/p>\n
            Das ist allerdings wenig spektakulär, wenn man bedenkt, dass dies auch mit einer Deklaration wie der folgenden möglich ist:<\/p>\n
            Public <\/span>Firma As String<\/span><\/pre>\n
            Wozu also all die zusätzlichen Anweisungen? Wir gewinnen dadurch mindestens die folgenden Möglichkeiten:<\/p>\n