{"id":55000327,"date":"2022-08-01T00:00:00","date_gmt":"2023-03-02T17:04:16","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=327"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Umfangreiche_Texte_in_Code_integrieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Umfangreiche_Texte_in_Code_integrieren\/","title":{"rendered":"Umfangreiche Texte in Code integrieren"},"content":{"rendered":"

Es gibt Aufgaben, um die schlägt man sich nicht. Eine davon ist es, längere Texte hart im VBA-Code zu verdrahten, sodass diese später weiterverarbeitet werden können. Ein Beispiel ist das Zusammenstellen eines XML-Dokuments, von dem man eine Vorlage hat, und das man mit eigenen Werten füllen möchte, um es dann beispielsweise als Anfrage an einen Webservice zu schicken. Oder man möchte den Inhalt einer Mail per VBA an Outlook schicken und versenden, nachdem man den Mailtext noch um individuelle Inhalte wie Anrede oder Name des Empfängers ergänzt hat. Sprich: Uns liegt ein mehrzeiliger Text vor, den wir irgendwie in eine Variable packen wollen – und zwar ausschließlich per VBA-Code. Wie das gelingt, zeigt der vorliegende Artikel.<\/b><\/p>\n

Mein aktuelles Beispiel, das mich zum Entwickeln der in diesem Artikel vorgestellten Lösung veranlasst hat, ist das Zusammenstellen eines XML-Dokuments. Wer schon einmal ein XML-Dokument mit der Anfrage an einen Webservice geschickt hat, kennt das vielleicht – in der Dokumentation des Webservice-Betreibers finden wir ein umfassendes XML-Dokument, das mit Beispieldaten gefüllt ist und das nur noch an unsere eigenen Zwecke angepasst werden soll. Eine Zeile darin lautet dann beispielsweise:<\/p>\n

<password>pass<\/password><\/pre>\n
Wir wollen diese samt den restlichen Zeilen des XML-Dokuments mit unseren realen Daten anpassen und das resultierende Dokument in einer Variablen speichern, um es dann an den Webservice zu schicken. Nur für diese eine Zeile würden wir dann eine Prozedur wie die folgende programmieren:<\/p>\n
Public Sub <\/span>XMLZusammenstellen()\r\n     Dim <\/span>strText As String<\/span>\r\n     strText = \"<password>pass<\/password>\" & vbCrLf<\/span>\r\n     Debug.Print<\/span> strText\r\nEnd Sub<\/span><\/pre>\n
Im nächsten Schritt würden wir dann das hier fest im Code untergebrachte Kennwort pass <\/b>durch einen Parameter ersetzen. Diese Version sieht wie folgt aus:<\/p>\n
Public Sub <\/span>XMLZusammenstellen(strPassword As String<\/span>)\r\n     Dim <\/span>strText As String<\/span>\r\n     strText = \"<password>\" & strPassword _\r\n         & \"<\/password>\" & vbCrLf<\/span>\r\n     Debug.Print<\/span> strText\r\nEnd Sub<\/span><\/pre>\n
Dann rufen wir die Prozedur mit einem Parameterwert wie folgt auf:<\/p>\n
XMLZusammenstellen \"MeinKennwort\"<\/pre>\n
Das liefert dann:<\/p>\n
<password>MeinKennwort<\/password><\/pre>\n
Für eine einzige Zeile ist der Aufwand zum Parametrisieren überschaubar, für ein paar weitere Zeilen vielleicht auch noch. Aber das XML-Dokument, das zu füllen war, sah in den VBA-Code kopiert zunächst wie in Bild 1 aus. Das heißt, wir müssen jede Zeile mit Ausnahme der ersten wie folgt ergänzen, also vorn um die Zuweisung des bisher in der Variablen gespeicherten Textes plus der neuen Zeile an die Variable:<\/p>\n
\"Ein<\/p>\n
Bild 1: Ein langes XML-Dokument soll in den VBA-Code eingearbeitet werden.<\/span><\/b><\/p>\n
strXML = strXML & \"   <soapenv:Header>\" & vbCrLf<\/span><\/pre>\n
Wenn wir das für einige zig Zeilen erledigen müssen, wird es Zeit, über eine Automatisierung nachzudenken. Darüber hinaus müssen wir wie bei der in XML-Dokumenten üblichen ersten Zeile, die noch die Definition von Namespaces enthält, noch einfache Anführungszeichen durch doppelte Anführungszeichen ersetzen wie bei diesem Beispiel (die eigentlichen Namespace-URLs haben wir aus Gründen der Übersicht gekürzt):<\/p>\n
<soapenv:Envelope xmlns:soapenv=\"...\" xmlns:cis=\"...\" xmlns:ns=\"...\"><\/pre>\n
Daraus wird dann die folgende Zeile – auch hier mit gekürzten Namespace-URLs (in einer Zeile):<\/p>\n
strXML = strXML & \"<soapenv:Envelope xmlns:soapenv=\"\"...\"\" xmlns:cis=\"\"...\"\" xmlns:ns=\"\"...\"\">\" & vbCrLf<\/span><\/pre>\n
Code per Code anpassen<\/h2>\n
Die Anpassungen sind, so nervig sie auch sein mögen, nicht besonders komplex. Also können wir dies vermutlich recht einfach automatisieren, wenn wir die richtigen Befehle herausfinden. Dazu benötigen wir als Erstes eine Bibliothek, welche uns den Zugriff auf das Objektmodell des VBA-Editors ermöglicht und so auch den Zugriff auf den Inhalt von Codefenstern. Diesen Verweis fügen wir über den Verweise<\/b>-Dialog hinzu, den wir vom VBA-Editor aus mit Extras|Verweise <\/b>öffnen. Die gewünschte Bibliothek heißt Microsoft Visual Basic for Applications Extensibility 5.3 <\/b>(siehe Bild 2).<\/p>\n
\"Hinzufügen<\/p>\n
Bild 2: Hinzufügen eines Verweises auf die VBE-Bibliothek<\/span><\/b><\/p>\n
Markieren und ersetzen<\/h2>\n
Der Plan lautet nun, dass wir die Zeilen in der Prozedur, die wir vorn um strXML = strXML & ” <\/b>und hinten um ” & vbCrLf <\/b>ersetzen wollen, zunächst markieren und dass wir dann eine Prozedur aufrufen, welche die Arbeit für uns erledigt. Das Markieren erledigen wir von Hand, denn nur wir wissen, welche Zeilen bearbeitet werden sollen.<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\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
\n\n\t\t\n\t\t