<\/p>\n
Christoph Spielmann, Düsseldorf<\/b><\/p>\n
Die Entwicklung von Anwendungen auf der .NET-Plattform gewinnt immer mehr an Bedeutung. Auch für Access-Entwickler stellt sich daher die Frage, ob bestimmte Anwendungen nicht besser mit .NET als mit Access entwickelt werden sollten. Dies trifft insbesondere auf moderne Anwendungen zu, die beispielsweise per Web-Service mit anderen Systemen kommunizieren, auf unterschiedliche Datenbank-Server zugreifen und das Benutzer-Interface im Web präsentieren. In diesem Artikel stellen wir Ihnen die .NET-Plattform genauer vor und zeigen Ihnen, wie Sie als VBA-Programmierer möglichst einfach auf VB.NET umsteigen können.<\/b><\/p>\n
Wenn Sie eventuell schon einmal innerhalb von Access mit ActiveX-Steuerelementen gearbeitet haben, wurden Sie sicherlich mit Problemen bei der Weitergabe Ihrer Anwendung konfrontiert. Zum einen ist es erforderlich, dass der Ziel-PC das Microsoft-Office-Paket oder Access in der passenden Version installiert hat. Sollte dies nicht der Fall sein, bleibt Ihnen nur der Erwerb der Entwickler-Version von Access, die auch eine Laufzeitumgebung enthält. <\/p>\n
Zudem ist es erforderlich, dass der Ziel-Rechner ebenfalls die bei der Entwicklung verwendeten ActiveX-Steuerelemente enthält. Da diese – anders als bei einer Access-Datenbankdatei – nicht einfach auf den Ziel-Rechner kopiert, sondern vorschriftsmäßig installiert und in der Registry eingetragen werden müssen, ist die Erstellung eines Setup-Programms erforderlich. Dies verursacht natürlich zusätzlichen Aufwand und bringt auch wieder Probleme mit sich, falls die ActiveX-Controls bereits auf dem Ziel-Rechner vorhanden sind, aber eine andere Versionsnummer haben. Sollte die vorhandene Version kleiner als die von Ihnen benötigte sein, funktioniert Ihre Anwendung eventuell nicht richtig. Wenn Sie die Version dagegen durch eine neuere ersetzen, könnten damit bereits vorhandene Anwendungen auf dem Ziel-Rechner unbrauchbar werden, da sie eine spezielle Version voraussetzen. Diese Problematik wird allgemein auch als „DLL-Hölle“ bezeichnet. Sie führt dazu, dass viele Access-Entwickler komplett auf den Einsatz von Komponenten verzichten, sodass sie lediglich eine einfache MDB-Datei weitergeben müssen. Sie nehmen hierbei oft in Kauf, dass sie Funktionen, die von Komponenten zur Verfügung gestellt werden könnten, lieber in VBA nachprogrammieren, da dies das geringere übel bedeutet.<\/p>\n
Alle beschriebenen Einschränkungen haben ihren Ursprung in dem Komponentenmodell „COM“ (Component Object Model) von Windows. Dies ist Basis aller klassischen Anwendungen aus dem Hause Microsoft wie zum Beispiel Word, Excel, Outlook oder Access. <\/p>\n
Microsoft hat sich die Aufgabe gestellt, das komplette COM-Objektmodell durch ein neues Komponentenmodell zu ersetzen. Herausgekommen ist nach fast zehn Jahren Forschungs- und Entwicklungsarbeit die .NET-Plattform.<\/p>\n
Das Besondere an der .NET-Plattform ist, dass sie in weiten Zügen unabhängig vom Betriebssystem und der darunter liegenden Hardware ist. Lediglich einige Kernbereiche nutzen Betriebssystemfunktionen. Dazu gehören beispielsweise der Zugriff auf das Dateisystem, die Kommunikation über das Netzwerk sowie die Darstellung der Benutzeroberfläche von Windows-Anwendungen.<\/p>\n
Tatsächlich ist es so, dass ein Tochterunternehmen der Firma Novell bereits eine Version des .NET-Frameworks für Linux entwickelt hat. Ziel des Projekts „Mono“ ist es, dass Anwendungen zwischen Linux und Windows ohne Neukompilierung ausgetauscht werden können.<\/p>\n
Damit dies funktioniert, besetzt das .NET-Framework ein Modul namens „Common Language Runtime“, kurz CLR. Die CLR besitzt die Fähigkeit, einen Programmcode kurz vor der Ausführung in Anweisungen für das jeweilige Betriebssystem zu übersetzen. Die übersetzung wird auch als „Just In Time“-Kompilierung (kurz JIT) bezeichnet. Hierbei kann der Compiler den Programmcode zum Beispiel auf Ausführungsgeschwindigkeit oder auf geringen Platzbedarf optimieren. Wenn Sie also auf Ihrem PC etwa Word und Access gestartet haben, also wenig Hauptspeicher zur Verfügung steht, kann die CLR eine neu gestartete Anwendung möglichst Platz sparend kompilieren.<\/p>\n
Das „Jitten“ spielt auch beim Komponentenmodell eine wesentliche Rolle. Kurz vor dem Start prüft .NET, welche Komponenten von der Anwendung benötigt werden und ob diese in passenden Versionen zur Verfügung stehen. Sollte dies der Fall sein, wird die Anwendung kompiliert und fest mit den Komponenten verknüpft.<\/p>\n
Dies benötigt zwar etwas Zeit beim Start der Anwendung, garantiert jedoch eine hohe Ausführungsgeschwindigkeit. Wird die Anwendung beendet und neu gestartet, beginnt der Vorgang von Neuem. Sollten nun neuere Komponenten zur Verfügung stehen, werden diese natürlich beim Neustart berücksichtigt.<\/p>\n
Die bereits angesprochenen Komponenten werden unter .NET als „Assemblies“ bezeichnet. Hierbei handelt es sich um Dateien, die aus zwei wesentlichen Bereichen bestehen: Dem Manifest und dem eigentlichen Programmcode. Das Manifest enthält hierbei Informationen zu dem Assembly. Dazu gehören etwa die Versionsnummer, die Namen der enthaltenen Klassen und deren Mitglieder sowie Text- und Grafik-Ressourcen. Jedes Assembly beschreibt sich selbst also möglichst gut, damit es von anderen Assemblies verwendet werden kann.<\/p>\n
Assemblies haben in der Regel die Dateiendung DLL, obwohl sie nichts mehr mit den klassischen DLLs aus der COM-Welt zu tun haben. Ausnahme bilden direkt ausführbare Programme, die die Dateiendung EXE haben. .NET-EXE-Dateien enthalten im Kopf einen Boot-Bereich. Dieser teilt dem Betriebssystem mit, dass die EXE-Datei nicht auf herkömmlichem Wege gestartet, sondern an die CLR weitergeleitet werden soll. Diese nimmt dann den Start vor.<\/p>\n
Vorher prüft sie noch die Herkunft des Assemblies und aktiviert entsprechende Sicherheitsfunktionen. Beispielsweise haben Assemblies, die aus dem Internet stammen, standardmäßig nur sehr wenig Rechte. Sie dürfen nicht auf das Dateisystem oder die Registry zugreifen, was die Ausbreitung von .NET-Viren zusammen mit den anderen Sicherheitsfunktionen von .NET nahezu unmöglich macht.<\/p>\n
Wie bereits erwähnt, enthalten Assemblies neben dem beschreibenden Manifest auch den eigentlichen Programmcode; dieser liegt jedoch nicht in einer Hochsprache vor, sondern in einer Zwischen-Sprache. Diese trägt den Namen „Intermediate Language“ – kurz „IL“.<\/p>\n
Diese Sprache kann sehr einfach in Ausführungsanweisungen für den Prozessor übersetzt werden, was vom JIT-Compiler erledigt wird und eine hohe Performance garantiert.<\/p>\n
Die Sprache ist daher sehr hardwarenah, was für den normalen Programmierer wenig Komfort bedeutet. Ein Beispiel finden Sie in Abb. 1.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{1BB7F714-1E34-4936-8CDB-37450C5C7355}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 1: Beispiel für IL-Code<\/b><\/p>\nPraxis-Tipp<\/h3>\n
Wenn Sie selbst einmal einen Blick auf den IL-Code eines Assemblies werfen möchten, verwenden Sie das Tool ILDASM.EXE (s. Abb. 2), das zum Lieferumfang des .NET-SDKs gehört. Sie finden es im BIN-Ordner. Mit dem Menüpunkt File\/Open können Sie ein beliebiges Assembly öffnen und das Manifest begutachten. Bei einem Klick auf einen Klassen-Member wird der IL-Code angezeigt. <\/p>\n
Zur Vereinfachung der IL kommen Hochsprachen wie C# oder VB.NET ins Spiel. Ein mit diesen Sprachen erstellter Programm-Code wird mit Hilfe eines Kompilers zunächst in die IL übersetzt und zusammen mit dem Manifest in ein Assembly gepackt.<\/p>\n
Dieses Assembly kann schließlich vom JIT-Kompiler in Maschinen-Code übersetzt und ausgeführt werden.<\/p>\n
Andere Anbieter wie etwa Borland stellen ebenfalls Kompiler zur Verfügung, die beispielsweise die Programmiersprache „Delphi“ in die IL übersetzen.<\/p>\n
Da dies relativ einfach ist, gibt es inzwischen sehr viele unterschiedliche Sprachen für die .NET-Plattform. Die übersetzung der Hochsprache in die IL findet auf dem PC des Entwicklers statt, sodass dieser den Quellcode seiner Anwendung nicht weitergeben muss. Auf diese Weise kann er sein geistiges Eigentum schützen.<\/p>\n
Hierbei gibt es jedoch eine Einschränkung: Microsoft wollte das Komponentenmodell möglichst effizient gestalten.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{1BB7F714-1E34-4936-8CDB-37450C5C7355}\/pic002.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 2: Der Disassembly ILDASM<\/b><\/p>\n
Zu diesem Zweck war es erforderlich, sehr viele Informationen über die Komponente im Manifest unterzubringen. Dazu zählen beispielsweise auch Namen von Klassen, Prozeduren und Eigenschaften. <\/p>\n
Zusammen mit dem IL-Code ist es relativ einfach möglich, den originalen Quelltext zu rekonstruieren. Hierbei fehlen zwar einige Elemente wie etwa die Namen der lokalen Variablen; die Arbeitsweise des Quellcodes lässt sich jedoch gut nachvollziehen. Wenn Ihr Quellcode also zum Beispiel schützenswerte Algorithmen enthält, sollten Sie hierauf achten.<\/p>\n
Da die CLR nur die rudimentären Funktionen zur Entwicklung einer Anwendung zur Verfügung stellt, enthält die .NET-Plattform eine Bibliothek aus über 4.000 Klassen. Diese können von Programmierern zur Lösung der verschiedensten Aufgaben eingesetzt werden. Diese Bibliothek wird häufig auch als „.NET-Framework“ bezeichnet.<\/p>\n
Das Framework erledigt neben einfachen Funktionen wie zum Beispiel die Umwandlung einer Zahl in einen Text auch komplexe Aufgaben wie die Kommunikation mehrerer Systeme untereinander mittels Web-Service.<\/p>\n
Microsoft hat Wert darauf gelegt, dass für fast alle Alltagsaufgaben eine passende Klasse zur Verfügung steht. Wenn Sie also beispielsweise eine Liste aus Texten sortieren möchten, müssen Sie nicht zuerst einen Quick-Sort- oder Bubble-Sort-Algorithmus programmieren, sondern können direkt auf eine passende Klasse zurückgreifen. Der Nachteil: Es gibt so viele Klassen, dass Sie einige Zeit benötigen, bis Sie einen groben überblick über alle Funktionsbereiche erhalten. Um Ordnung in die Klassen zu bringen, hat Microsoft diese in „Namespaces“ organisiert. Der Namespace „System.IO“ enthält beispielsweise alle Klassen, die sich mit dem Lesen und Schreiben von Dateien beschäftigen. In „System.Windows.Forms“ finden Sie dagegen alles Nötige, um Windows-Benutzeroberflächen zu entwerfen.<\/p>\n
Das .NET-Framework ist komplett objektorientiert aufgebaut. Um dies zu verstehen, ist die Unterscheidung zwischen den Begriffen „Klasse“ und „Objekt“ wichtig: Eine Klasse existiert nur ein einziges Mal pro Anwendung. Sie dient als Schablone zur Erstellung eines Objekts. Wenn Sie also beispielsweise in einer Adressverwaltung zehn Personen mit den gleichen Attributen (Namen, Vorname, Ort, PLZ, …) verwalten möchten, programmieren Sie nicht zehn Objekte, sondern nur eine einzige Klasse, und erzeugen auf Basis dieser Klasse zehn Objekte.<\/p>\n
Synonym für den Begriff „Objekt“ steht auch der Begriff „Instanz“. <\/p>\n
Das Erstellen einer eigenen Klasse können Sie zum Beispiel mit SharpDevelop ausprobieren. Dazu gehen Sie wie folgt vor:<\/p>\n
Auf dem Bildschirm ist nun ein neues, leeres Projekt sichtbar. Starten Sie das Projekt testweise mit der Taste F5. <\/p>\n
Es erscheint ein Konsolenfenster auf dem Bildschirm, in dem der Text „Hello World“ ausgegeben wird.<\/p>\n
Konsolen-Anwendungen bieten nur eine eingeschränkte Benutzeroberfläche nach dem Vorbild von DOS. Der Vorteil ist, dass die komplexen Benutzeroberflächen-Klassen zunächst außen vor bleiben und der Einstieg in .NET damit leichter fällt. <\/p>\n
Zur Anlage der ersten Klasse gehen Sie wie folgt vor:<\/p>\n
Im Quellcode-Editor erscheint nun der folgende Programmcode:<\/p>\n
Imports System\nNamespace Personenverwaltung\n Public Class Person\n Public Sub New()\n End Sub\n End Class\nEnd Namespace<\/pre>\nDie eigentliche Klasse beginnt mit der Zeile Public Class Person und endet mit End Class.<\/p>\n
Die komplette Klasse ist eingekapselt durch die Zeilen Namespace Personenverwaltung und End Namespace. Dies bedeutet, dass die neue Klasse zum Namespace Personenverwaltung gehört. Zur Erinnerung: Namespaces dienen der besseren Organisation von Klassen. So könnten Sie beispielsweise alle Klassen, die sich mit der Verwaltung von Personen beschäftigen, in den Namespace Personenverwaltung einordnen und alle Klassen zum Thema Projektverwaltung in den Namespace Projektverwaltung.<\/p>\n
Zu Beginn ist noch eine Imports-Anweisung angegeben. Diese bewirkt eine Abkürzung bei dem Verweis auf Klassen. Wenn Sie beispielsweise auf die Klasse System.IO.FileInfo zugreifen möchten, können Sie im Programmcode entweder mit <\/p>\n
System.IO.FileInfo<\/pre>\nden kompletten Pfad angeben oder den Namespace System.IO mit<\/p>\n
Imports System.IO<\/pre>\nimportieren. In Zukunft reicht dann die einfache Angabe<\/p>\n
FileInfo<\/pre>\naus, um auf die Klasse zu verweisen.<\/p>\n
Sinn und Zweck der neuen Klasse soll es sein, die Anschrift-Daten einer Person zu verwalten. Zu diesem Zweck werden der Klasse nun entsprechende Variablen hinzugefügt, die von außen zugänglich sind. Solche Variablen werden auch als Felder bezeichnet.<\/p>\n
Ergänzen Sie die Klasse wie folgt:<\/p>\n
Public Class Person\n Public Nachname As String\n Public Vorname As String\n Public Straße As String\n Public PLZ As String\n Public Ort As String\n Public Geburtsdatum As DateTime\n Public Sub New()\n End Sub\nEnd Class\nImports System\nImports Personenverwaltung\nModule Main\n Sub Main()\n Dim ErstePerson As Person\n ErstePerson = new Person()\n ErstePerson.Nachname = \"Mustermann\"\n ErstePerson.Vorname = \"Hans\"\n ErstePerson.Straße = \"Musterstraße 1\"\n ErstePerson.PLZ = \"40211\"\n ErstePerson.Ort = \"Düsseldorf\"\n End Sub\nEnd Module<\/pre>\nQuellcode 1<\/b><\/p>\n
Wechseln Sie danach durch einen Doppelklick im Projekt-Explorer auf Main.vb zurück und ändern Sie den Programmcode wie in Quellcode 1 ab.<\/p>\n
Die Zeile Dim ErstePerson As Person definiert zunächst die neue Variable ErstePerson, die eine Objektinstanz des Typs Person repräsentieren könnte. Das Objekt existiert jedoch zum jetzigen Zeitpunkt noch nicht.<\/p>\n
Die folgende Zeile legt das Objekt schließlich mit Hilfe des Schlüsselworts New an und weist es der Variablen ErstePerson zu.<\/p>\n
Abschließend erfolgt die Zuweisung des Namens sowie der Adressdaten.<\/p>\n
Um zu prüfen, ob Sie alles korrekt eingegeben haben, starten Sie das Programm mit der Taste F5. Sollten Fehler vorhanden sein, werden diese im Fenster Aufgaben von SharpDevelop aufgelistet. Gegebenenfalls müssen Sie das Fenster zuerst über das Register Aufgaben im unteren linken Bereich sichtbar machen.<\/p>\n
Zum guten Stil objektorientierter Programmierung gehört es, den inneren Aufbau einer Klasse vor dem Nutzer zu verbergen.<\/p>\n
Auf diese Weise kann der interne Aufbau beliebig geändert werden – beispielsweise um eine bessere Performance zu erzielen -, ohne dass die Nutzer der Klasse hiervon betroffen sind oder deren Aufrufe geändert werden müssen.<\/p>\n
Grundlage hierzu ist, dass die Variablen der Klasse nicht direkt von außen zugänglich sind. Im Falle der Personenklasse bedeutet dies, dass die einzelnen Personenangaben nicht als Public, sondern als Private definiert werden. Dadurch kann man nur noch von innerhalb der Klasse auf die Variablen zugreifen:<\/p>\n
Private m_Nachname As String\nPrivate m_Vorname As String\nPrivate m_Straße As String\nPrivate m_PLZ As String\nPrivate m_Ort As String<\/pre>\nUm diese Variablen besser von nach außen sichtbaren Klassenmitgliedern zu unterscheiden, sind die Namen mit dem Präfix „m_“ für „Member“ versehen. Diese Konvention ist allerdings nicht zwingend, da die Namensgebung im Verantwortungsbereich des Programmierers liegt.<\/p>\n
Doch wie kann man nun von außen zum Beispiel auf den Nachnamen zugreifen? Dieses Problem löst die folgende öffentliche Property-Prozedur:<\/p>\n
Public Property Nachname As String\n Get\n Return m_Nachname\n End Get\n Set(ByVal Value As String)\n If Value.Length = 0 Then\n m_Nachname = \"(Unbekannt)\"\n Else\n m_Nachname = Value\n End If\n End Set\nEnd Property<\/pre>\nDie Prozedur besteht aus einem Get- und einem Set-Teil. Der Get-Teil wird beim lesenden Zugriff, der Set-Teil beim schreibenden Zugriff aufgerufen. Im ersten Fall wird der Wert der privaten Variablen m_Nachname mittels Return-Anweisung zurückgeliefert. Im zweiten Fall wird dagegen der Wert der privaten Variablen verändert. Sollte ein Leerstring übergeben werden, wird der Text „(Unbekannt)“ eingetragen, ansonsten der übergebene Name.<\/p>\n
Public Function AnschriftErmitteln As String\n Dim Anschrift As String\n Anschrift = (m_Vorname + \" \" + m_Nachname).Trim\n Anschrift += Microsoft.VisualBasic.ControlChars.CrLf\n Anschrift += m_Straße\n Anschrift += Microsoft.VisualBasic.ControlChars.CrLf\n Anschrift += m_PLZ + \" \" + m_Ort\n Return Anschrift\nEnd Function<\/pre>\nQuellcode 2<\/b><\/p>\n
Alle weiteren privaten Variablen müssen ebenfalls entsprechend gekapselt werden. Das folgende Beispiel zeigt dies exemplarisch für den Vornamen, wobei auf die Leerstring-Prüfung verzichtet wird:<\/p>\n
Public Property Vorname As String\n Get\n Return m_Vorname\n End Get\n Set(ByVal Value As String)\n m_Vorname = Value\n End Set\nEnd Property<\/pre>\nIm jetzigen Zustand hat die Klasse Person noch eine Schwachstelle: Sobald ein Objekt erzeugt wurde, enthalten alle Variablen Null-Werte.<\/p>\n
Das Objekt hat damit keinen sinnvollen Zustand und es ist darauf angewiesen, dass der Nutzer der Klasse beispielsweise irgendwann einen Nachnamen und einen Vornamen zuweist.<\/p>\n
Besser wäre es, wenn der Nutzer direkt bei der Anlage dazu gezwungen wäre, einen Nachnamen und einen Vornamen anzugeben. Dieses Problem löst der Konstruktor. Bei der Anlage der Klasse Person hat SharpDevelop automatisch einen leeren Konstruktor angelegt:<\/p>\n
Public Sub New()\nEnd Sub<\/pre>\nErgänzen Sie diesen Konstruktor wie folgt:<\/p>\n
Public Sub New(Nachname As String, _ Vorname As String)\n m_Nachname = Nachname\n m_Vorname = Vorname\nEnd Sub<\/pre>\nWenn Sie nun eine neue Instanz der Klasse Person anlegen, müssen Sie den Nachnamen und den Vornamen direkt mit angeben, wie das folgende Beispiel zeigt (ohne Zeilenumbruch):<\/p>\n
ErstePerson = New Person(\"Mustermann\", \"Hans\")<\/pre>\nDementsprechend müssen Sie auch das Hauptmodul Ihrer Anwendung anpassen:<\/p>\n
Sub Main()\n Dim ErstePerson As Person\n ErstePerson = New _ Person(\"Mustermann\", \"Hans\")\n ErstePerson.Straße = \"Musterstraße 1\"\n ErstePerson.PLZ = \"40211\"\n ErstePerson.Ort = \"Düsseldorf\"\nEnd Sub<\/pre>\nBis jetzt hat die erstellte Klasse lediglich das Speichern von Adressdaten ermöglicht. Die Klasse erledigt jedoch noch keine konkrete Aufgabe. Solche Aufgaben werden mit Hilfe von Methoden implementiert.<\/p>\n
Die folgende Methode ermittelt beispielsweise aus den Adressangaben eine vollständige Anschrift, die zum Beispiel auf einen Brief gedruckt werden könnte (s. Quellcode 2).<\/p>\n
Fügen Sie die Methode innerhalb der Klasse hinter den bereits existierenden Property-Prozeduren ein.<\/p>\n
Sub Main()\n Dim ErstePerson As Person\n ErstePerson = new Person(\"Mustermann\", \"Hans\")\n ErstePerson.Straße = \"Musterstraße 1\"\n ErstePerson.PLZ = \"40211\"\n ErstePerson.Ort = \"Düsseldorf\"\n Console.WriteLine(ErstePerson.AnschriftErmitteln())\nEnd Sub<\/pre>\nQuellcode 3<\/b><\/p>\n
Public Class Mitarbeiter: Inherits Person\n Private m_Personalnummer As Integer\n Public Sub New(Nachname As String, Vorname As String, Personalnummer As Integer)\n MyBase.New(Nachname, Vorname)\n m_Personalnummer = Personalnummer\n End Sub\n Public Readonly Property Personalnummer As Integer\n Get\n Return m_Personalnummer\n End Get\n End Property\n Public Shadows Function AnschriftErmitteln As String\n Dim Anschrift As String\n Anschrift = \"Personalnummer \" + m_Personalnummer.ToString()\n Anschrift += Microsoft.VisualBasic.ControlChars.CrLf\n Anschrift += MyBase.AnschriftErmitteln()\n End Function\nEnd Class<\/pre>\nQuellcode 4<\/b><\/p>\n
Praxis-Tipp<\/h3>\n
Der Operator += bewirkt, dass .NET der Variablen den nachfolgenden Text anhängt. <\/p>\n
Zum Einsatz der neuen Methode ergänzen Sie die Hauptprozedur wie in Quellcode 3. Die Zeile vor End Sub ruft die neu erstellte Methode auf und gibt das Ergebnis im Konsolenfenster aus.<\/p>\n
Eines der wichtigsten Konzepte der objektorientierten Programmierung ist die Möglichkeit der Vererbung. Hierbei kann eine Klasse alle Eigenschaften und Methoden einer Basisklasse erben und weitere Funktionen hinzufügen. Ein Beispiel hierfür ist eine Klasse namens Mitarbeiter. Ein Mitarbeiter hat generell alle Methoden und Eigenschaften der Klasse Person, soll aber zusätzlich noch eine Personalnummer besitzen.<\/p>\n
Um eine entsprechende Klasse anzulegen, gehen Sie wie folgt vor:<\/p>\n
Klicken Sie im Projekt-Explorer von SharpDevelop den Eintrag Personenverwaltung mit der rechten Maustaste an und wählen Sie den Menüpunkt Hinzufügen\/Neue Datei aus.<\/li>\n Klicken Sie auf die Kategorie VB und die Schablone Klasse.<\/li>\n Geben Sie unter Dateiname den Text Mitarbeiter.vb ein.<\/li>\n Bestätigen Sie mit Erstellen.<\/li>\n Ergänzen Sie die Klasse wie in Quellcode 4 abgebildet. (<\/li>\n Im Kopf der Klasse wird über das Schlüsselwort Inherits definiert, dass diese Klasse von der Klasse Person abstammt.<\/p>\n
Sub Main()\n Dim ErstePerson As Person\n ErstePerson = new Person(\"Mustermann\", \"Hans\")\n ErstePerson.Straße = \"Musterstraße 1\"\n ErstePerson.PLZ = \"40211\"\n ErstePerson.Ort = \"Düsseldorf\"\n Console.WriteLine(ErstePerson.AnschriftErmitteln())\n Dim ZweitePerson As Mitarbeiter\n ZweitePerson = new Mitarbeiter(\"Angestellter\", _ \"Hans\", 24334)\n ZweitePerson.Straße = \"Steinstraße 5\"\n ZweitePerson.PLZ = \"50233\"\n ZweitePerson.Ort = \"Köln\"\n Console.WriteLine(ZweitePerson.AnschriftErmitteln())\nEnd Sub<\/pre>\nQuellcode 5<\/b><\/p>\n
Der Konstruktor wurde um die Personalnummer erweitert, sodass diese bei der Anlage eines neuen Mitarbeiters mit angegeben werden muss. Innerhalb des Konstruktors wird mit Hilfe der MyBase.New-Anweisung als Erstes der Konstruktor der Basisklasse Person aufgerufen und der Nachname sowie der Vorname übergeben. Anschließend erfolgt die Zuweisung der Personalnummer.<\/p>\n
Die Property-Prozedur Personalnummer ist mit dem Schlüsselwort ReadOnly definiert. Außerdem ist nur der Get-Teil implementiert. Dies bewirkt, dass die Personalnummer nach der Anlage des Objekts nur noch gelesen, jedoch nicht mehr verändert werden kann.<\/p>\n
Die Methode AnschriftErmitteln wurde so erweitert, dass zu Beginn der Text „Personalnummer“ gefolgt von der Personalnummer ausgegeben wird. Die Umwandlung der Personalnummer von einer Zahl in einen Text erfolgt hierbei mit der ToString-Methode, die bei allen .NET-Objekten standardmäßig zur Verfügung steht.<\/p>\n
Nachdem die Personalnummer hinzugefügt wurde, ruft die Prozedur die gleichnamige Prozedur der Basisklasse auf und lässt sich von dieser den restlichen Teil der Adresse übergeben.<\/p>\n
Praxis-Tipp<\/h3>\n
Da die Prozedur AnschriftErmitteln in der Person-Klasse und in der Mitarbeiter-Klasse den gleichen Namen hat, muss die Methode in der abgeleiteten Klasse mit dem Schlüsselwort Shadows deklariert werden. Ansonsten kommt es zu einem Namenskonflikt. <\/p>\n
Zum Test der neuen Klasse ergänzen Sie die Hauptprozedur wie in Quellcode 5.<\/p>\n
Neben der ersten wird nun noch eine zweite Person definiert, diesmal jedoch vom Typ Mitarbeiter.<\/p>\n
Per Konstruktor werden die Mitarbeiterdaten übergeben und danach die Anschrift ergänzt. Zuletzt erfolgt eine Ausgabe der Anschrift im Konsolenfenster.<\/p>\n
Sie haben in diesem Artikel den grundsätzlichen Aufbau der .NET-Plattform sowie die Grundzüge der objektorientierten Programmierung kennen gelernt.<\/p>\n
Insbesondere die Einarbeitung in die Objektorientierung bedeutet für viele Programmierer eine wichtige und oftmals nicht einfache Umstellung in der Denkweise. Wir werden Sie hierbei noch durch weitere Artikel unterstützen, die anhand von Praxisbeispielen den Umgang mit .NET vertiefen.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die Entwicklung von Anwendungen auf der .NET-Plattform gewinnt immer mehr an Bedeutung. Auch für Access-Entwickler stellt sich daher die Frage, ob bestimmte Anwendungen nicht besser mit .NET als mit Access entwickelt werden sollten. Dies trifft insbesondere auf moderne Anwendungen zu, die beispielsweise per Web-Service mit anderen Systemen kommunizieren, auf unterschiedliche Daten-bank-Server zugreifen und das Benutzer-Interface im Web präsentieren. In diesem Artikel stellen wir Ihnen die .NET-Plattform genauer vor und zeigen Ihnen, wie Sie als VBA-Programmierer möglichst einfach auf VB.NET umsteigen können.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[44000017,662004,66052004,44000025],"tags":[],"class_list":["post-55000234","post","type-post","status-publish","format-standard","hentry","category-NET","category-662004","category-66052004","category-VBA_und_Programmiertechniken"],"yoast_head":"\n
Von VBA zu VB.NET - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Von VBA zu VB.NET\" \/>\n<meta property=\"og:description\" content=\"Die Entwicklung von Anwendungen auf der .NET-Plattform gewinnt immer mehr an Bedeutung. Auch für Access-Entwickler stellt sich daher die Frage, ob bestimmte Anwendungen nicht besser mit .NET als mit Access entwickelt werden sollten. Dies trifft insbesondere auf moderne Anwendungen zu, die beispielsweise per Web-Service mit anderen Systemen kommunizieren, auf unterschiedliche Daten-bank-Server zugreifen und das Benutzer-Interface im Web präsentieren. In diesem Artikel stellen wir Ihnen die .NET-Plattform genauer vor und zeigen Ihnen, wie Sie als VBA-Programmierer möglichst einfach auf VB.NET umsteigen können.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2023-02-10T14:47:27+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-19T08:17:02+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"17\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Von VBA zu VB.NET\",\"datePublished\":\"2023-02-10T14:47:27+00:00\",\"dateModified\":\"2024-02-19T08:17:02+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/\"},\"wordCount\":3206,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg07.met.vgwort.de\\\/na\\\/0098d0e628f24d24b1fd4231924d6417\",\"articleSection\":[\".NET\",\"2004\",\"5\\\/2004\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/\",\"name\":\"Von VBA zu VB.NET - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg07.met.vgwort.de\\\/na\\\/0098d0e628f24d24b1fd4231924d6417\",\"datePublished\":\"2023-02-10T14:47:27+00:00\",\"dateModified\":\"2024-02-19T08:17:02+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg07.met.vgwort.de\\\/na\\\/0098d0e628f24d24b1fd4231924d6417\",\"contentUrl\":\"http:\\\/\\\/vg07.met.vgwort.de\\\/na\\\/0098d0e628f24d24b1fd4231924d6417\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/von_vba_zu_vbnet\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Von VBA zu VB.NET\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Von VBA zu VB.NET - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/","og_locale":"de_DE","og_type":"article","og_title":"Von VBA zu VB.NET","og_description":"Die Entwicklung von Anwendungen auf der .NET-Plattform gewinnt immer mehr an Bedeutung. Auch für Access-Entwickler stellt sich daher die Frage, ob bestimmte Anwendungen nicht besser mit .NET als mit Access entwickelt werden sollten. Dies trifft insbesondere auf moderne Anwendungen zu, die beispielsweise per Web-Service mit anderen Systemen kommunizieren, auf unterschiedliche Daten-bank-Server zugreifen und das Benutzer-Interface im Web präsentieren. In diesem Artikel stellen wir Ihnen die .NET-Plattform genauer vor und zeigen Ihnen, wie Sie als VBA-Programmierer möglichst einfach auf VB.NET umsteigen können.","og_url":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/","og_site_name":"Access im Unternehmen","article_published_time":"2023-02-10T14:47:27+00:00","article_modified_time":"2024-02-19T08:17:02+00:00","og_image":[{"url":"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"17\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Von VBA zu VB.NET","datePublished":"2023-02-10T14:47:27+00:00","dateModified":"2024-02-19T08:17:02+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/"},"wordCount":3206,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#primaryimage"},"thumbnailUrl":"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417","articleSection":[".NET","2004","5\/2004","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/","url":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/","name":"Von VBA zu VB.NET - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#primaryimage"},"thumbnailUrl":"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417","datePublished":"2023-02-10T14:47:27+00:00","dateModified":"2024-02-19T08:17:02+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#primaryimage","url":"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417","contentUrl":"http:\/\/vg07.met.vgwort.de\/na\/0098d0e628f24d24b1fd4231924d6417"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/von_vba_zu_vbnet\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Von VBA zu VB.NET"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000234","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000234"}],"version-history":[{"count":1,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000234\/revisions"}],"predecessor-version":[{"id":88075292,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000234\/revisions\/88075292"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000234"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000234"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000234"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}