Informationen zum Erstellen und Weitergeben eines Beispiel-XML-Web-Service, der mit Microsoft Visual Studio .NET programmiert wurde. Auf den XML Web Service wird mithilfe eines Microsoft Access-2002-Formulars zugegriffen.
Betrifft:
Microsoft® Visual Studio® .NET
Microsoft Access 2002
Microsoft Office XP Web Services Toolkit
| Einführung | |
| XML Web Services - Grundlagen | |
| XML Web Services in Visual Studio .NET | |
| Erstellen eines XML Web Service | |
| Erstellen einer Clientanwendung | |
| Testen des XML Web Service | |
| Zusammenfassung |
Mithilfe von XML Web Services können Anwendungen Daten austauschen und Datenverarbeitungsfähigkeiten zur Verfügung stellen. Ein XML Web Service ist in der Regel eine Dynamic Link Library (DLL), die sich auf einem Webserver befindet und deren Methoden über das Internet aufgerufen werden können. In diesem Szenario kommuniziert eine Clientanwendung mit einem XML Web Service durch Senden und Empfangen von SOAP-Meldungen über Hypertext Transfer Protocol (HTTP).
In diesem Artikel wird das Programmieren und die Weitergabe eines XML Web Service sowie der Zugriff auf einen XML Web Service mithilfe von Microsoft Visual Studio .NET veranschaulicht. Zuerst werden wir die Internet Information Services (IIS) auf dem Webserver eingerichtet, auf dem der XML Web Service gehostet wird.
Anmerkung IIS 4.0 ist mit Microsoft Windows NT® 4.0 Server kompatibel. IIS 5.0 ist mit Windows® 2000 Server kompatibel und wird standardmäßig mit Windows® 2000 Server installiert.
Anschließend wird mit Visual Studio .NET ein ASP.NET-Web-Service-Projekt erstellt. Dann wird dem Projekt Code hinzugefügt, um den XML Web Service zu implementieren. Der Beispiel XML Web Service nimmt den zweistelligen Namen eines US-Bundesstaats entgegen und gibt Informationen über den Bundesstaat zurück, um den vollständigen Namen des Bundesstaats, dessen Hauptstadt, das Datum, an dem der Bundesstaat der Union beigetreten ist, und die Beitrittsreihenfolge einzufügen. Anschließend wird der XML Web Service in Visual Studio .NET getestet. Schließlich wird eine Clientanwendung mithilfe eines Microsoft Access-2002-Fomulars erzeugt, um auf den XML Web Service zuzugreifen und die Ergebnisse anzuzeigen.
Was muss beim Anlegen und Verwenden eines XML Web Service berücksichtigt werden? Normalerweise beginnt ein Benutzer damit, zu einer Website zu navigieren, die ein XML Web Service Verzeichnis hostet, z.B. den UDDI-Registrierungsdienst (Universal Description, Discovery and Integration), um zu sehen, welche XML Web Services zur Verfügung stehen.
Dieser Registrierungsdienst stellt Informationen zu den verschiedenen verfügbaren XML Web Services bereit, wie den Namen des Hostunternehmens des XML Web Service, den URL der Website des Unternehmens und den Speicherort der WSDL-Datei, die der Benutzer zur Bestimmung der Details des XML Web Service verwendet.
Ein Entwickler wird dann die in der WSDL-Datei gelesenen Informationen verwenden, um eine Clientanwendung zu entwickeln, auf den XML Web Service zuzugreifen und die Ergebnisse zu verarbeiten. Der Entwickler legt zuerst einen Verweis auf die Microsoft SOAP-Bibliothek (mssoap1.dll) fest, die man durch Installation des SOAP Toolkit 2.0 erhält.
Anmerkung Der Microsoft SOAP Toolkit 2.0 SP2 (in Englisch) steht auf der MSDN-Website zum Download bereit.
Die Microsoft SOAP-Bibliothek enthält clientseitige (und serverseitige) Komponenten, die es einer Anwendung ermöglichen, XML-Web-Service-Methoden aufzurufen. Der Entwickler legt dann (mithilfe des Web-Service-References-Tool) einen Webverweis auf die WSDL-Datei fest.
Anmerkung Das Web Service References Tool ist im Office XP Web Services Toolkit (in Englisch) verfügbar, das auf der MSDN-Website zum Download bereitsteht.
Das Web Service References Tool erzeugt eine Proxyklasse (lokale Darstellung des XML Web Service in der Clientanwendung), die eine unkomplizierte Kommunikation mit dem XML Web Service über HTTP ermöglicht. Diese Kommunikation besteht aus SOAP-Anforderungen von der Clientanwendung und SOAP-Antworten vom XML Web Service.
Der Server, der den XML Web Service implementiert, verwendet einen "Empfänger" (Code, der sich in der WSDL-Datei befindet, oder eine ASP-Datei, die einen Handler implementiert), um die SOAP-Anforderung zu empfangen und zu bearbeiten. Sobald der Empfänger eine SOAP-Anforderung aus der Clientanwendung erkennt, analysiert er die Anforderung, ruft die XML-Web-Service-Methode auf und übergibt alle Parameter und empfängt anschließend die Ergebnisse der Methodenaufrufe. Der Empfänger schließt die Antwort in eine weitere SOAP-Meldung ein und sendet die Antwort zu der Clientanwendung, wo die Ergebnisse analysiert und durch die clientseitige Komponente verarbeitet werden.
Bisher wurde die clientseitige Verwendung von XML Web Services erläutert. Um einen XML Web Service auf einem Webserver zu erstellen und zu implementieren, ist Folgendes erforderlich:
| • | Eine DLL, die die Funktionen (Methoden) enthält, die Sie als XML Web Service zur Verfügung stellen möchten. |
| • | Eine Methode, um Kunden, die sich für den XML Web Service interessieren, über die bereitgestellten Funktionen, die Namen der Methoden, die verwendeten Ein- und Ausgabeparameter und weitere Angaben zu den XML Web Service zu informieren. Eine WSDL-Datei stellt diese Informationen bereit. |
Um einen XML Web Service zu verwenden, müssen Sie die Clientanwendung erstellen, die auf den XML Web Service zugreift, wobei Sie die in der WSDL-Datei enthaltenen Informationen verwenden, und sicherstellen, dass die Microsoft SOAP-Bibliothek auf jedem Clientcomputer installiert ist. Die von Ihnen für das Erstellen des Client verwendete Entwicklungsumgebung bestimmt, welche zusätzlichen Tools eventuell erforderlich sind.
Microsoft Visual Studio .NET vereinfacht das Erstellen und Weitergeben von XML Web Services durch Automatisierung der Erstellung vieler der Dateien, die für die Implementierung des XML Web Service erforderlich sind. Visual Studio .NET stellt beispielsweise ein ASP.NET-Web-Service-Projekt bereit, um Sie beim Erstellen von und Arbeiten mit XML Web Services zu unterstützen.
Wenn Sie in Visual Studio ein ASP.NET-Web-Service-Projekt erstellen, legt Visual Studio .NET automatisch ein Projekt und die Dateien auf dem Webserver (vorausgesetzt, Sie entwickeln den XML Web Service auf dem Webserver) an, die für das Implementieren des XML Web Service erforderlich sind. Darüber hinaus erstellt Visual Studio .NET automatisch eine .ASMX-Datei, die die Klassen und Methoden enthält, um zusätzliche Funktionen zum XML Web Service hinzuzufügen.
Anmerkung XML-Web-Service-Klassen ähneln standardmäßigen Klassen mit der Ausnahme, dass einer Webklasse ein [WebMethod]-Attribut vorangestellt ist.
Visual Studio .NET erstellt außerdem die WSDL- und WSML-Dateien für Sie und stellt darüber hinaus eine Informationsseite bereit, auf der die Methoden und Parameter angezeigt werden, die in Ihrem XML Web Service verwendet werden. Sie können diese Seite auch zum Testen Ihres XML Web Service verwenden.
Auf dem Client können Sie entweder Microsoft Visual Basic 6.0, Visual Studio .NET oder eine Office-Anwendung wie Access oder Microsoft Excel verwenden, um die Clientanwendung zur Verwendung des XML Web Service zu erstellen. Zunächst legen Sie einen Verweis auf die WSDL-Datei fest. In einem in Visual Studio .NET implementierten XML Web Service wird dies durch Verweisen auf die .ASMX-Datei mit einer Abfragezeichenfolge wie http://localhost/StatesInformationWS/StatesInformation.asmx?wsdl durchgeführt. In Visual Basic oder einer Office-Anwendung legen Sie den Webverweis auf eine WSDL-Datei mithilfe des Web Service References Tool fest. Das Web Service References Tool ist im Office XP Web Services Toolkit verfügbar, das auf der MSDN-Website zum Download bereitsteht.
Das Web Service References Tool verwendet die Informationen in der WSDL-Datei und erstellt eine VBA-Proxyklasse (Microsoft Visual Basic für Applikationen). Die Proxyklasse stellt eine lokale Darstellung des XML Web Service in der Clientanwendung bereit. Da die XML-Web-Service-Klasse mit dem Proxy in der Clientanwendung verknüpft ist, ist Microsoft IntelliSense verfügbar, wenn Sie die Objekte im Client erstellen. Fügen Sie Ihrer Anwendung den Code hinzu, der die Methoden in der Proxyklasse aufruft. Anschließend können Sie den XML Web Service verwenden.
Nun setzen wir diese Informationen um und erstellen den XML Web Service.
Für die Weitergabe des XML Web Service ist ein Webserver wie Microsoft Windows 2000 Server erforderlich, der IIS ausführt. Sie müssen ein virtuelles Stammverzeichnis auf dem Webserver einrichten, in dem Sie die XML-Web-Service-Dateien, die Sie erstellen, speichern können.
Einrichten der Internet Information Services
1. | Fügen Sie dem Webserver einen Ordner hinzu. Sie können einen vorhandenen Ordner verwenden oder einen neuen Ordner auf dem Server erstellen. Für dieses Beispiel schlage ich vor, einen neuen Ordner zu erstellen (z.B. C:\StatesInfoWS). |
2. | Richten Sie nun ein virtuelles Stammverzeichnis in IIS ein. Doppelklicken Sie in der Systemsteuerung auf Verwaltung, und doppelklicken Sie anschließend auf Internetdienste-Manager, der die Internet Information Services-Konsole anzeigt. |
3. | Erweitern Sie im linken Teilfenster den Knoten, der den Namen Ihres Webservers enthält, klicken Sie mit der rechten Maustaste auf den Knoten Standardwebsite, zeigen Sie auf Neu, und klicken Sie auf Virtuelles Verzeichnis. Dadurch wird der Assistent zum Erstellen von virtuellen Verzeichnissen geöffnet. |
4. | Klicken Sie im Bildschirm Willkommen auf Weiter. |
5. | Geben Sie StatesInfoWS im Bildschirm Alias für virtuelles Verzeichnis ein, und klicken Sie auf Weiter. |
6. | Geben Sie im Bildschirm Verzeichnis des Websiteinhalts den Pfad ein, den Sie in Schritt 1 erstellt haben, und klicken Sie auf Weiter. |
7. | Aktivieren Sie im Bildschirm Zugriffsberechtigungen die Kontrollkästchen Lesen und Skripts ausführen, und klicken Sie auf Weiter. Klicken Sie auf Fertig stellen. |
Erstellen des ASP.NET-Projekts
Nun erstellen wir ein neues Visual Basic .NET ASP.NET-Web-Service-Projekt namens StatesInformationWS und ein Klassenmodul namens StatesInformation mit der Methode GetStateInfo.
1. | Starten Sie Visual Studio .NET. Klicken Sie auf der Startseite auf Neues Projekt. |
2. | Wählen Sie im Dialogfeld Neues Projekt in der Liste Projekttypen die Option Visual Basic-Projekte aus, und klicken Sie auf ASP.NET-Webdienst. |
3. | Geben Sie http://localhost/StatesInfoWS im Feld Adresse ein. Beachten Sie, dass standardmäßig alle XML Web Service-Projekte im virtuellen Verzeichnis des lokalen Hosts des Webservers gespeichert werden. |
4. | Klicken Sie auf OK. Das Projekt wird ein Modul mit dem Namen Service1.asmx, eine Konfigurationsdatei und eine Discovery-Datei (.vsdisco) enthalten. Die Konfigurationsdatei enthält Konfigurationsdaten für den Webserver, und die Discovery-Datei enthält Informationen, die es anderen mit Ihrem Server verbundenen Anwendungen ermöglichen, Ihren XML Web Service zu finden und die Namen und Syntax seiner Members anzuzeigen. |
5. | Löschen Sie zuerst das Modul Service1.asmx, da Sie im nächsten Schritt Ihre eigene Datei erstellen werden. Wählen Sie die Datei aus, klicken Sie mit der rechten Maustaste, und klicken Sie auf Löschen. Klicken Sie im Bestätigungsdialogfeld auf OK. |
6. | Erstellen Sie nun Ihre eigene .ASMX-Datei. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf StatesInformationWS, wählen Sie Hinzufügen aus, und klicken Sie anschließend auf Neues Element hinzufügen. |
7. | Wählen Sie im Dialogfeld Neues Element hinzufügen unter Webprojektelement das Symbol Webdienst aus, und geben Sie StatesInformation.asmx ein. Klicken Sie auf OK. |
8. | Klicken Sie mit der rechten Maustaste auf StatesInformation.asmx, und wählen Sie Code anzeigen aus. |
9. | Fügen Sie folgenden Code unter der vom Webdienst-Designer generierten Codeanweisung hinzu. Diese Methode wird verwendet, um Ihrem XML Web Service Funktionen hinzuzufügen:
<WebMethod()> Public Function GetStateInfo(ByVal strAbbreviatedName
As String) As String
'Zweck: Diese Prozedur wird verwendet, um einen
' XML Web Service zu simulieren. Die Prozedur akzeptiert
' den zweistelligen Namen für einen Bundesstaat und
' gibt Informationen über diesen Staat zurück.
'Akzeptiert: strAbbreviatedName - den zweistelligen Namen des Bundesstaats.
'Gibt zurück:Informationen über den Bundesstaat einschließlich
' dessen vollständigen Namen, das Beitrittsdatum
' zur Union und der Beitrittsreihenfolge.
'
Select Case UCase(Trim(strAbbreviatedName))
Case "AL"
Return "Name: Alabama " & _
"Hauptstadt: Montgomery " & _
"Beitrittsdatum: 14. Dezember 1819 " & _
"Reihenfolge: 22"
Case "AK"
Return "Name: Alaska " & _
"Hauptstadt: Juneau " & _
"Beitrittsdatum: 3. Januar 1959 " & _
"Reihenfolge: 49"
Case "AZ"
Return "Name: Arizona " & _
"Hauptstadt: Phoenix " & _
"Beitrittsdatum: 14. Februar 1912 " & _
"Reihenfolge: 48"
Case "AR"
Return "Name: Arkansas " & _
"Hauptstadt: Little_Rock " & _
"Beitrittsdatum: 15. Juni 1836 " & _
"Reihenfolge: 25"
Case "CA"
Return "Name: California " & _
"Hauptstadt: Sacramento " & _
"Beitrittsdatum: 9. September 1850 " & _
"Reihenfolge: 31"
Case "CO"
Return "Name: Colorado " & _
"Hauptstadt: Denver " & _
"Beitrittsdatum: 1. August 1876 " & _
"Reihenfolge: 38"
Case "CT"
Return "Name: Connecticut " & _
"Hauptstadt: Hartford " & _
"Beitrittsdatum: 9. Januar 1788 " & _
"Reihenfolge: 5"
Case "DC"
Return "Name: District_of_Columbia " & _
"Hauptstadt: -" & _
"Beitrittsdatum: -" & _
"Reihenfolge: -"
Case "DE"
Return "Name: Delaware " & _
"Hauptstadt: Dover " & _
"Beitrittsdatum: 7. Dezember 1787 " & _
"Reihenfolge: 1"
Case "FL"
Return "Name: Florida " & _
"Hauptstadt: Tallahassee " & _
"Beitrittsdatum: 3. März 1845 " & _
"Reihenfolge: 27"
Case "GA"
Return "Name: Georgia " & _
"Hauptstadt: Atlanta " & _
"Beitrittsdatum: 2. Januar 1788 " & _
"Reihenfolge: 4"
Case "HI"
Return "Name: Hawaii " & _
"Hauptstadt: Honolulu " & _
"Beitrittsdatum: 21. August 1959 " & _
"Reihenfolge: 50"
Case "ID"
Return "Name: Idaho " & _
"Hauptstadt: Boise " & _
"Beitrittsdatum: 3. Juli 1890 " & _
"Reihenfolge: 43"
Case "IL"
Return "Name: Illinois " & _
"Hauptstadt: Springfield " & _
"Beitrittsdatum: 3. Dezember 1818 " & _
"Reihenfolge: 21"
Case "IN"
Return "Name: Indiana " & _
"Hauptstadt: Indianapolis " & _
"Beitrittsdatum: 11. Dezember 1816 " & _
"Reihenfolge: 19"
Case "IA"
Return "Name: Iowa " & _
"Hauptstadt: Des_Moines " & _
"Beitrittsdatum: 28. Dezember 1846 " & _
"Reihenfolge: 29"
Case "KS"
Return "Name: Kansas " & _
"Hauptstadt: Topeka " & _
"Beitrittsdatum: 29. Januar 1861 " & _
"Reihenfolge: 34"
Case "KY"
Return "Name: Kentucky " & _
"Hauptstadt: Frankfort " & _
"Beitrittsdatum: 1. Juni 1792 " & _
"Reihenfolge: 15"
Case "LA"
Return "Name: Louisiana " & _
"Hauptstadt: Baton_Rouge " & _
"Beitrittsdatum: 30. April 1812 " & _
"Reihenfolge: 18"
Case "ME"
Return "Name: Maine " & _
"Hauptstadt: Augusta " & _
"Beitrittsdatum: 15. März 1820 " & _
"Reihenfolge: 23"
Case "MD"
Return "Name: Maryland " & _
"Hauptstadt: Annapolis " & _
"Beitrittsdatum: 28. April 1788 " & _
"Reihenfolge: 7"
Case "MA"
Return "Name: Massachusetts " & _
"Hauptstadt: Boston " & _
"Beitrittsdatum: 6. Februar 1788 " & _
"Reihenfolge: 6"
Case "MI"
Return "Name: Michigan " & _
"Hauptstadt: Lansing " & _
"Beitrittsdatum: 26. Januar 1837 " & _
"Reihenfolge: 26"
Case "MN"
Return "Name: Minnesota " & _
"Hauptstadt: St._Paul " & _
"Beitrittsdatum: 11. Mai 1858 " & _
"Reihenfolge: 32"
Case "MS"
Return "Name: Mississippi " & _
"Hauptstadt: Jackson " & _
"Beitrittsdatum: 10. Dezember 1817 " & _
"Reihenfolge: 20"
Case "MO"
Return "Name: Missouri " & _
"Hauptstadt: Jefferson_City " & _
"Beitrittsdatum: 10. August 1821 " & _
"Reihenfolge: 24"
Case "MT"
Return "Name: Montana " & _
"Hauptstadt: Helena " & _
"Beitrittsdatum: 8. November 1889 " & _
"Reihenfolge: 41"
Case "NE"
Return "Name: Nebraska " & _
"Hauptstadt: Lincoln " & _
"Beitrittsdatum: 1. März 1867 " & _
"Reihenfolge: 37"
Case "NV"
Return "Name: Nevada " & _
"Hauptstadt: Carson_City " & _
"Beitrittsdatum: 31. Oktober 1864 " & _
"Reihenfolge: 36"
Case "NH"
Return "Name: New_Hampshire " & _
"Hauptstadt: Concord " & _
"Beitrittsdatum: 21. Juni 1788 " & _
"Reihenfolge: 9"
Case "NJ"
Return "Name: New_Jersey " & _
"Hauptstadt: Trenton " & _
"Beitrittsdatum: 18. Dezember 1787 " & _
"Reihenfolge: 3"
Case "NM"
Return "Name: New_Mexico " & _
"Hauptstadt: Santa_Fe " & _
"Beitrittsdatum: 6. Januar 1912 " & _
"Reihenfolge: 47"
Case "NY"
Return "Name: New_York " & _
"Hauptstadt: Albany " & _
"Beitrittsdatum: 26. Juli 1788 " & _
"Reihenfolge: 11"
Case "NC"
Return "Name: North_Carolina " & _
"Hauptstadt: Raleigh " & _
"Beitrittsdatum: 21. November 1789 " & _
"Reihenfolge: 12"
Case "ND"
Return "Name: North_Dakota " & _
"Hauptstadt: Bismarck " & _
"Beitrittsdatum: 2. November 1889 " & _
"Reihenfolge: 39"
Case "OH"
Return "Name: Ohio " & _
"Hauptstadt: Columbus " & _
"Beitrittsdatum: 1. März 1803 " & _
"Reihenfolge: 17"
Case "OK"
Return "Name: Oklahoma " & _
"Hauptstadt: Oklahoma_City " & _
"Beitrittsdatum: 16. November 1907 " & _
"Reihenfolge: 46"
Case "OR"
Return "Name: Oregon " & _
"Hauptstadt: Salem " & _
"Beitrittsdatum: 14. Februar 1859 " & _
"Reihenfolge: 33"
Case "PA"
Return "Name: Pennsylvania " & _
"Hauptstadt: Harrisburg " & _
"Beitrittsdatum: 12. Dezember 1787 " & _
"Reihenfolge: 2"
Case "RI"
Return "Name: Rhode_Island " & _
"Hauptstadt: Providence " & _
"Beitrittsdatum: 29. Mai 1790 " & _
"Reihenfolge: 13"
Case "SC"
Return "Name: South_Carolina " & _
"Hauptstadt: Columbia " & _
"Beitrittsdatum: 23. Mai 1788 " & _
"Reihenfolge: 8"
Case "SD"
Return "Name: South_Dakota " & _
"Hauptstadt: Pierre " & _
"Beitrittsdatum: 2. November 1889 " & _
"Reihenfolge: 40"
Case "TN"
Return "Name: Tennessee " & _
"Hauptstadt: Nashville " & _
"Beitrittsdatum: 1. Juni 1796 " & _
"Reihenfolge: 16"
Case "TX"
Return "Name: Texas " & _
"Hauptstadt: Austin " & _
"Beitrittsdatum: 28. Dezember 1846 " & _
"Reihenfolge: 29"
Case "UT"
Return "Name: Utah " & _
"Hauptstadt: Salt_Lake_City " & _
"Beitrittsdatum: 4. Januar 1896 " & _
"Reihenfolge: 45"
Case "VT"
Return "Name: Vermont " & _
"Hauptstadt: Montpelier " & _
"Beitrittsdatum: 4. März 1791 " & _
"Reihenfolge: 14"
Case "VA"
Return "Name: Virginia " & _
"Hauptstadt: Richmond " & _
"Beitrittsdatum: 25. Juni 1788 " & _
"Reihenfolge: 10"
Case "WA"
Return "Name: Washington " & _
"Hauptstadt: Olympia " & _
"Beitrittsdatum: 11. November 1889 " & _
"Reihenfolge: 42"
Case "WV"
Return "Name: West_Virginia " & _
"Hauptstadt: Charleston " & _
"Beitrittsdatum: 20. Juni 1863 " & _
"Reihenfolge: 35"
Case "WI"
Return "Name: Wisconsin " & _
"Hauptstadt: Madison " & _
"Beitrittsdatum: 29. Mai 1848 " & _
"Reihenfolge: 30"
Case "WY"
Return "Name: Wyoming " & _
"Hauptstadt: Cheyenne " & _
"Beitrittsdatum: 10. Juli 1890 " & _
"Reihenfolge: 44"
Case Else
Return "Der von Ihnen eingegebene Wert ist keine gültige" & _
"Bundesstaatabkürzung. Geben Sie eine " & _
"gültige zweistellige Abkürzung ein."
End Select
End Function
|
10. | Testen Sie nun den XML Web Service. Wählen Sie im Projektmappen-Explorer StatesInformation.asmx aus, klicken Sie mit der rechten Maustaste, und klicken Sie auf Als Startseite festlegen. Drücken Sie F5. Dadurch wird Ihre Anwendung erstellt und die .NET-Assembly und unterstützende Dateien in den \bin-Ordner unter dem virtuellen Stammverzeichnis auf Ihrem Webserver kopiert. Microsoft Internet Explorer wird mit einer Beschreibung des neuen XML Web Service angezeigt.
Abbildung 1. In Internet Explorer angezeigte Beschreibung des XML Web Service |
11. | Klicken Sie auf den Hyperlink GetStateInfo, um die Methode zu testen. Geben Sie auf der Seite eine zweistellige Abkürzung ein (z.B. VA).
Abbildung 2. Testen der "GetStateInfo"-Methode des XML Web Service |
12. | Klicken Sie auf Aufrufen. Das Ergebnis wird in Abbildung 3 dargestellt.
Abbildung 3. Das Ergebnis der "GetStateInfo"-Methode |
13. | Herzlichen Glückwunsch! Der XML Web Service funktioniert, jetzt müssen Sie eine Clientanwendung erstellen. |
Wenn Sie dieses Projekt auf einem anderen Computer als dem, auf dem IIS ausgeführt wird, erstellt haben, müssen Sie das Projekt vom Entwicklungscomputer auf den Hostwebserver des XML Web Service kopieren (verwenden Sie den in Schritt 1 des Abschnitts Einrichten des Internet Information Server erstellten Ordner) und es auf dem Server mithilfe folgender Schritte registrieren:
1. | Klicken Sie im Menü Projekt auf Projekt kopieren. Geben Sie im Dialogfeld Projekt kopieren den Ordner StatesInfoWS unter dem Stammverzeichnis des Webservers an, und klicken Sie auf OK. Alle für Discovery und die Verwendung Ihres XML Web Service erforderlichen Dateien werden in diesen Ordner kopiert. |
2. | Klicken Sie zum Registrieren auf die Schaltfläche Start, zeigen Sie auf Ausführen, und geben Sie Folgendes ein (ersetzen Sie <Pfad> durch den absoluten Pfad, in den Sie Ihre DLL kopiert haben): regsvr32 <Pfad>\StatesInfoWS.dll |
Sie legen nun ein Formular in Access 2002 an, um den XML Web Service aufzurufen und die Ergebnisse anzuzeigen.
Um diese Anwendung in Access zu erstellen, müssen Sie einen Verweis auf die Microsoft SOAP-Typbibliothek (mssoap1.dll) im Dialogfeld Verweise festlegen (Menü Extras).
1. | Starten Sie Access 2002. | ||||||||
2. | Klicken Sie im Datenbankfenster unter Objekte auf Formulare, und klicken Sie dann auf Neu, um das Dialogfeld Neues Formular anzuzeigen. | ||||||||
3. | Wählen Sie im Dialogfeld Neues Formular die Option Entwurfsansicht aus, und klicken Sie auf OK. | ||||||||
4. | Klicken Sie im Menü Ansicht auf Eigenschaften, um das Eigenschaftsblatt für dieses Formular zu öffnen. | ||||||||
5. | Ändern Sie im Eigenschaftsblatt den Text in der Eigenschaft Beschriftung zu Daten von einem XML Web Service abrufen. | ||||||||
6. | Ziehen Sie aus der Toolbox (Menü Ansicht) ein Textfeld-Steuerelement in das Formular. Ändern Sie im Eigenschaftsblatt die Eigenschaft Name zu txtAbbrevName. | ||||||||
7. | Klicken Sie auf die Bezeichnung für das Steuerelement txtAbbrevName, und ändern Sie die Eigenschaft Beschriftung zu Geben Sie die zweistellige Abkürzung für einen Staat ein, und klicken Sie auf "Informationen abrufen". | ||||||||
8. | Ziehen Sie aus der Toolbox ein Befehlsschaltfläche-Steuerelement in das Formular. Klicken Sie im Bildschirm Befehlsschaltflächen-Assistent auf Abbrechen. Ändern Sie im Eigenschaftsblatt den Namen des Steuerelements zu cmdGetInfo. | ||||||||
9. | Ändern Sie die Eigenschaft Beschriftung des Steuerelements cmdGetInfo zu Informationen abrufen. Klicken Sie im Eigenschaftsblatt auf die Registerkarte Ereignis, klicken Sie auf das Ereignis Beim Klicken, und klicken Sie dann auf die Schaltfläche zum Generieren (mit den Ellipsen . . .). | ||||||||
10. | Zunächst fügen Sie in Visual-Basic-Editor einen Webverweis auf einen URL hinzu, der eine Beschreibung der in Ihrem XML Web Service verfügbaren Methode enthält. Klicken Sie im Menü Extras auf Web Service References. | ||||||||
11. | Aktivieren Sie im Dialogfeld Web Service References das Optionsfeld Web Service URL. Geben Sie im Feld URL den URL zu Ihrer XML Web Service-Beschreibungsdatei ein, und klicken Sie auf Search. Für den XML Web Service in diesem Beispiel wäre dies | ||||||||
12. | Wählen Sie im Feld Suchergebnisse den Eintrag StatesInformation aus. Klicken Sie auf "+", um den Knoten zu erweitern. Sie können die Methode testen, indem Sie GetStateInfo auswählen und auf Test klicken.
Abbildung 4. Das Dialogfeld "Web Service References" | ||||||||
13. | Klicken Sie auf Add. Die Klasse clsws_StatesInformation wird im Klassenmodule-Ordner hinzugefügt. Diese Klasse stellt einen Proxy dar, der Schnittstellen mit dem XML Web Service bereitstellt, und ist eine lokale Darstellung des XML Web Service. | ||||||||
14. | Doppelklicken Sie auf die Klasse clsws_StatesInformation. Wenn Sie den Code ansehen, werden Sie feststellen, dass er eine Reihe von Ereignisprozeduren, z.B. Class_Initialize, Class_Terminate enthält, die automatisch vom Web Service References-Tool erstellt wurden. Sie werden auch die Funktion wsm_GetStateInfo bemerken, die verwendet wird, um die Methode GetStateInfo der Klasse StatesInformation des von Ihnen erstellten XML Web Service aufzurufen. | ||||||||
15. | Doppelklicken Sie auf das Formularmodul. Fügen Sie folgenden Code der Ereignisprozedur cmdGetInfo_Click hinzu:
' Zweck: Die Prozedur wird verwendet, um den
' Beispiel-XML Web Service StatesInformation
' durch Aufrufen der Funktion wsm_getStateInfo
' der Proxyklasse clsws_StatesInformation
' zu testen. Diese Methode ruft dann den
' XML Web Service auf, sendet eine zweistellige
' Staat-Abkürzung und zeigt die zurückgegebenen
' Informationen an.
'
' Gibt zurück: Den vollständigen Namen des Staats, die Hauptstadt des Staats,
' das Beitrittsdatum des Staats zur
' Union sowie die Beitrittsreihenfolge.
'
Dim clsStatesWS As clsws_StatesInformation
Dim strUserInfo As String
Dim strReturn As String
Dim strName As String
Dim strCapital As String
Dim strDate As String
Dim strOrder As String
Dim intStart As Integer
Dim intEnd As Integer
Dim intLength As Integer
On Error GoTo cmdGetInfo_Click_Err
' Verweis auf die Klasse clsws_StatesInformation erstellen.
Set clsStatesWS = New clsws_StatesInformation
Me!txtAbbrevName.SetFocus
strUserInfo = Me!txtAbbrevName.Text
' Die Methode wsm_GetStateInfo aufrufen.
strReturn = Trim(clsStatesWS.wsm_GetStateInfo(strUserInfo))
' Überprüfen, ob die Bundesstaatinformationen zurückgegeben wurden.
If Left(strReturn, 4) <> "Name" Then
MsgBox strReturn, , "Kein gültiger Eintrag"
GoTo cmdGetInfo_Click_End
End If
' Zurückgegebene Zeichenfolge analysieren.
' Feld Name abrufen.
' Suchen des ersten :.
intStart = InStr(1, strReturn, ":") + 2
' Erstes Leerzeichen nach dem Namen suchen.
intEnd = (InStr(intStart, strReturn, " "))
' Die Zahl der aufzunehmenden Zeichen.
intLength = intEnd - intStart
strName = Mid(strReturn, intStart, intLength)
' Überprüfen, ob sich ein Unterstrich zwischen
' den Wörtern befindet, und vor dem Anzeigen entfernen.
If InStr(1, strName, "_") <> 0 Then
strName = Replace(strName, "_", " ")
End If
Me!txtName.SetFocus
Me!txtName.Text = strName
' Feld Hauptstadt abrufen.
' Suchen des zweiten: durch Beginn am Ende des
' Namensfeldes.
intStart = InStr(intEnd, strReturn, ":") + 2
' Leerzeichen nach dem Datum suchen.
intEnd = (InStr(intStart, strReturn, " "))
' Die Zahl der aufzunehmenden Zeichen.
intLength = intEnd - intStart
strCapital = Mid(strReturn, intStart, intLength)
' Überprüfen, ob sich ein Unterstrich zwischen
' den Wörtern befindet, und vor dem Anzeigen entfernen.
If InStr(1, strCapital, "_") <> 0 Then
strCapital = Replace(strCapital, "_", " ")
End If
Me!txtCapital.SetFocus
Me!txtCapital.Text = strCapital
' Datumsfeld abrufen.
intStart = InStr(intEnd, strReturn, ":") + 2
' Komma nach dem Tag suchen und 6 für das
' Jahr hinzufügen.
intEnd = (InStr(intStart, strReturn, ",") + 6)
' Die Zahl der aufzunehmenden Zeichen.
intLength = intEnd - intStart
strDate = Mid(strReturn, intStart, intLength)
Me!txtDate.SetFocus
Me!txtDate.Text = strDate
' Schließlich die Reihenfolge abrufen, in der der Staat
' der Union beigetreten ist.
strOrder = Trim(Right(strReturn, 2))
Me!txtOrder.SetFocus
Me!txtOrder.Text = strOrder
Me!txtAbbrevName.SetFocus
cmdGetInfo_Click_End:
Exit Sub
cmdGetInfo_Click_Err:
MsgBox Err.Number & ":" & Err.Description
GoTo cmdGetInfo_Click_End
| ||||||||
16. | Schließen Sie den Visual Basic-Editor. | ||||||||
17. | Fügen Sie aus der Toolbox vier weitere Textfeld-Steuerelemente dem Formular hinzu, und positionieren Sie sie unter der Schaltfläche Informationen abrufen. | ||||||||
18. | Doppelklicken Sie auf das erste Textfeld-Steuerelement, um das Eigenschaftsblatt aufzurufen. Ändern Sie den Namen des Steuerelements zu txtName. | ||||||||
19. | Klicken Sie auf die Bezeichnung des Steuerelements, und ändern Sie die Eigenschaft Beschriftung zu Name:. | ||||||||
20. | Wiederholen Sie die Schritte 18 und 19 für die drei verbleibenden Steuerelemente, und ändern Sie die folgenden Eigenschaften:
| ||||||||
21. | Ziehen Sie ein Befehlsschaltfläche-Steuerelement in das Formular, und positionieren Sie es unter dem Steuerelement txtOrder. Wählen Sie im Bildschirm Befehlsschaltflächen-Assistent in der Liste Kategorien die Option Formularoperationen aus, und wählen Sie anschließend Formular schließen in der Liste Aktionen aus. Klicken Sie auf Weiter. | ||||||||
22. | Wählen Sie im nächsten Bildschirm Text aus, und ändern Sie den Text zu Schließen. Klicken Sie auf Weiter. | ||||||||
23. | Ändern Sie den Namen des Steuerelements zu cmdClose, und klicken Sie auf Fertig stellen. |
Öffnen Sie nun das Formular, und testen Sie den XML Web Service.
1. | Schließen Sie das Eigenschaftsblatt, falls es angezeigt wird. |
2. | Klicken Sie im Menü Ansicht auf Formularansicht. |
3. | Geben Sie einen zweistelligen Bundesstaatnamen in das Feld ein (z.B. VA), und klicken Sie auf Informationen abrufen. |
Die Ergebnisse des XML Web Service werden in den Feldern des Formulars, wie in Abbildung 5 dargestellt, angezeigt.

Abbildung 5. Access-Formular mit den Ergebnissen des XML Web Service
In diesem Artikel haben wir das Erstellen und die Weitergabe sowie den Zugriff auf einen XML Web Service demonstriert, der den zweistelligen Namen eines US-Bundesstaats akzeptiert und den vollständigen Namen des Staats, dessen Hauptstadt, das Beitrittsdatum des Staats zur Union sowie die Beitrittsreihenfolge zurückgibt.
Zuerst haben Sie ein virtuelles Stammverzeichnis auf dem Webserver erstellt. Anschließend haben Sie ein ASP.NET Web Service-Projekt in Visual Studio .NET erstellt und den Code hinzugefügt, um die Funktionen des XML Web Service zu erstellen. Dann haben Sie ein Access 2002-Formular als Clientanwendung erstellt und den XML Web Service getestet. Anhand der in diesem Artikel erläuterten Schritte können Sie sehen, wie einfach es ist, eigene XML Web Services mit Visual Studio .NET und Office XP zu erstellen, weiterzugeben und zu testen.