![\"Aufruf](\"..\/fileadmin\/_temp_\/2017_02\/pic_82_001.png\")
<\/p>\nMit Webservices lässt sich der Abruf von Daten bestimmter Anbieter aus dem Internet stark vereinfachen. Während Sie etwa zum Herunterladen eines Versandetiketts einige Minuten investieren müssen, um die Adressen und weitere Sendungsdaten aus einer Kundendatenbank in ein Onlineformular zu übertragen, könnten Sie das auch per Mausklick erledigen. Voraussetzung sind einige Zeilen Code und die Registrierung beim entsprechenden Webservice. In diesem Fall schauen wir uns das am Beispiel von Versandetiketten des Paketdienstleisters DHL an.<\/b><\/p>\n
Im Artikel Webservice testen am Beispiel von DHL <\/b>haben wir uns bereits angesehen, wie Sie die für einen Webservice benötigte WSDL-Datei ermitteln und damit über ein Tool wie SoapUI die XML-Vorlage für einen Request ermitteln, füllen und testen. Dort haben wir außerdem ein Entwickler-Konto angelegt, mit dem wir auf den Webservice von DHL zugreifen können. Schließlich haben wir einen funktionierenden Aufruf an die Sandbox-Version des Webservice, also eine zu Testzwecken bestimmte Umgebung, abgesetzt und mit dem zurückgelieferten Link ein PDF-Dokument mit dem Versand-etikett erhalten (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Aufruf des Dienstes Intraship<\/span><\/b><\/p>\n Nun wollen wir uns die Techniken ansehen, die dafür nötig sind, einen Request an einen Webservice abzusenden und die Antwort auszuwerten. Hier interessiert uns im vorliegenden Beispiel natürlich vor allem, wie wir den Link zum PDF-Dokument mit dem Versandetikett verarbeiten und das PDF-Dokument auf der Festplatte speichern oder ausdrucken.<\/p>\n Wir wollen zunächst den XML-Request, den wir im Artikel Webservice testen am Beispiel von DHL <\/b>ermittelt haben, an den Webservice schicken und den Request entgegennehmen. Dabei müssen wir natürlich auch noch die Authentifizierung berücksichtigen. Um die Funktion zum Ermitteln des Response-Dokuments aufzurufen, verwenden wir ein Fenster in einer WPF-Anwendung, das wir mit einer entsprechenden Schaltfläche ausstatten.<\/p>\n Diese gibt dann einfach den Code in einem Meldungsfenster aus (siehe Listing 1).<\/p>\n Listing 1: Aufruf der Funktion zum Senden eines Requests an den Webservice<\/span><\/b><\/p>\n Um die verschiedenen nachfolgend verwendeten Klassen zu nutzen, die sich mit dem Umgang mit dem Webservice, mit XML-Dokumenten und mit dem Lesen und Schreiben von Dokumenten beschäftigen, benötigen wir noch drei Namespaces, die wir mit dem using<\/b>-Schlüsselwort einbinden:<\/p>\n Die Funktion GetResponse<\/b>, die den Ablauf steuert, sieht wie folgt aus:<\/p>\n Hier ermitteln wir mit der Funktion CreateRequest <\/b>ein neues Objekt des Typs HttpWebRequest <\/b>und speichern es in der Variablen request<\/b>. Dabei werden Informationen wie die Header für den Aufruf, die Authentifikation und weitere Informationen in einem Objekt zusammengestellt – mehr dazu weiter unten. Danach füllen wir ein Objekt des Typs XmlDocument <\/b>namens requestXML<\/b>, und zwar ebenfalls mithilfe einer Funktion. Diese heißt GetRequestXML <\/b>und stellt einfach nur das XML-Dokument zusammen, das als Inhalt des Requests verwendet werden soll. Wir haben also nun ein Objekt des Typs HttpWebRequest<\/b>, welches die Daten für die Steuerung des Requests enthält, und ein XML-Dokument mit dem zu übergebenenen Request.<\/p>\n Nun müssen wir beide noch verheiraten. Dies geschieht im ersten using<\/b>-Konstrukt der Funktion GetResponse<\/b>. Das in Klammern hinter der using<\/b>-Anweisung erzeugte Objekt wird nach dem Durchlaufen des using<\/b>-Abschnitts wieder gelöscht. In diesem Fall handelt es sich um ein Stream<\/b>-Objekt. Diesem weisen wir das mit der Funktion GetRequestStream <\/b>ermittelte Stream<\/b>-Objekt unseres HttpWebRequest <\/b>namens request <\/b>zu. Wir haben also mit stream <\/b>ein Stream<\/b>-Objekt referenziert, das wir nun füllen können und so den übergebenen Inhalt als Request-Inhalt an das HttpWebRequest<\/b>-Objekt übergeben. Dies erledigen wir mit der einzigen Anweisung des using<\/b>-Konstrukts, mit der wir das in requestXML <\/b>gespeicherte XML-Objekt in den Stream und somit in das Objekt request <\/b>speichern.<\/p>\n Das zweite using<\/b>-Konstrukt ruft dann bereits die Methode GetResponse <\/b>von request <\/b>auf und speichert das Ergebnis in der Variablen response <\/b>mit dem Datentyp WebResponse<\/b>. response <\/b>liefert mit GetResponseStream <\/b>wiederum einen Stream, den wir diesmal allerdings nicht in einem Stream<\/b>-Objekt speichern, sondern einem StreamReader <\/b>als Konstruktor-Parameter übergeben. Wir erstellen also ein neues StreamReader<\/b>-Objekt und weisen diesem den Stream zu, den wir als Antwort des Webservice erhalten haben. Diesen in rd <\/b>gespeicherten Streamreader kapseln wir wiederum in einem using<\/b>-Konstrukt, da wir ihn nur für die folgenden beiden Anweisungen benötigen. Die erste liest mit ReadToEnd <\/b>den kompletten Inhalt des in rd <\/b>gespeicherten Streams und fügt ihn der Variablen result <\/b>hinzu. Die Variable result<\/b>, die zu diesem Zeitpunkt das XML-Dokument mit der Antwort des Webservices enthält, wird dann schließlich als Funktionswert zurückgegeben. Die aufrufende Methode gibt den Inhalt dann schließlich wie in Bild 2 als Meldung aus.<\/p>\n Bild 2: Ergebnis des Requests<\/span><\/b><\/p>\n Die Funktion CreateRequest <\/b>stellt den Request zusammen und gibt diesen als HttpWebRequest<\/b>-Objekt an die aufrufende Instanz zurück. Dabei legt diese zunächst ein Uri<\/b>-Objekt an und hinterlegt die Uri, die als Endpunkt für den Webservice dient (hier der Request für die Sandbox: https:\/\/cig.dhl.de\/services\/sandbox\/soap<\/b>). Danach erstellt sie das HttpWeb-Request<\/b>-Objekt auf Basis der Methode Create <\/b>der Klasse WebRequest<\/b>. Dieser übergibt sie das Uri<\/b>-Objekt mit dem Endpunkt als Parameter. Das Ergebnis wird schließlich in den Typ HttpWebRequest <\/b>umgewandelt. Danach stellt die Funktion die Zeichenkette für die Authentifizierung zusammen. Der Benutzername und das Kennwort werden zunächst in die Variablen username <\/b>und password <\/b>geschrieben (später fragen Sie die Daten entweder ab oder speichern direkt die kodierte Form), durch einen Doppelpunkt voneinander getrennt in einer neuen Zeichenkette aufgenommen und in einen Base64-String umgewandelt. Das Ergebnis landet in der Variablen auth<\/b>. Danach fügt die Add<\/b>-Methode der Headers<\/b>-Auflistung des in request <\/b>gespeicherten WebHttpRequest<\/b>-Objekts einen neuen Header mit dem Namen Authorization <\/b>und dem aus der Zeichenkette Basic<\/b>, einem Leerzeichen und der kodierten Version aus Benutzername und Kennwort als Wert hinzu. Danach legt sie noch die Eigenschaften ContentType <\/b>(text\/xml;charset=”utf-8″<\/b>), Accept <\/b>(text\/xml<\/b>) und Method <\/b>(POST<\/b>) von request <\/b>fest. Danach gibt die Methode den Inhalt der Objektvariablen request<\/b> an die aufrufende Methode zurück:<\/p>\n Damit kommen wir zur letzten Funktionsmethode, die wir für den ersten Aufruf benötigen. Diese heißt GetRequestXML <\/b>und erstellt zunächst ein neues Objekt des Typs XmlDocument<\/b>. Die Variable für dieses Objekt heißt requestXML<\/b>.<\/p>\n Es soll nun mit dem als Zeichenkette vorhandenen XML-Dokument gefüllt werden, welches wir im Artikel Webservice testen am Beispiel von DHL <\/b>zusammengestellt und ausprobiert haben. Diese Zeichenkette laden wir mit der Methode LoadXml <\/b>in das Objekt requestXML <\/b>und geben dieses als Rückgabewert an die aufrufende Methode zurück:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Anfrage zusammenstellen und abschicken<\/h2>\n
private void btnEinfacherAufruf_Click(object sender, RoutedEventArgs e) {\r\n MessageBox.Show(GetResponse());\r\n}<\/pre>\nusing System.Net;\r\nusing System.Xml;\r\nusing System.IO;<\/pre>\n
public string GetResponse() {\r\n HttpWebRequest request = CreateRequest();\r\n XmlDocument requestXML = GetRequestXML();\r\n using (Stream stream = request.GetRequestStream()) {\r\n requestXML.Save(stream);\r\n }\r\n using (WebResponse response = request.GetResponse()) {\r\n using (StreamReader rd = new StreamReader(response.GetResponseStream())) {\r\n var result = rd.ReadToEnd();\r\n return result;\r\n }\r\n }\r\n}<\/pre>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2017_02\/pic_82_002.png\")
<\/p>\nRequest zusammenstellen<\/h2>\n
public HttpWebRequest CreateRequest() {\r\n Uri uri = new Uri(\"https:\/\/cig.dhl.de\/services\/sandbox\/soap\");\r\n HttpWebRequest request = (HttpWebRequest)WebRequest.Create(@uri);\r\n String username = \"andreminhorst\";\r\n String password = \"*********\";\r\n String auth = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(username + \":\" + password));\r\n request.Headers.Add(\"Authorization\", \"Basic \" + auth);\r\n request.ContentType = \"text\/xml;charset=\\\"utf-8\\\"\";\r\n request.Accept = \"text\/xml\";\r\n request.Method = \"POST\";\r\n return request;\r\n}<\/pre>\nXML-Dokument zusammenstellen<\/h2>\n
public XmlDocument GetRequestXML() {\r\n XmlDocument requestXML = new XmlDocument();\r\n requestXML.LoadXml(@\"<soapenv:Envelope ...>\r\n <soapenv:Header>\r\n <cis:Authentification>\r\n <cis:user>2222222222_01<\/cis:user>\r\n <cis:signature>pass<\/cis:signature>\r\n <\/cis:Authentification>\r\n <\/soapenv:Header>\r\n ---\r\n <\/soapenv:Envelope>\");\r\n return requestXML;\r\n}<\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t