Neben diesen Anweisungen erläutern wir in diesem Artikel auch noch diese Elemente, die Teil der Klasse FileSystem <\/b>sind:<\/p>\n Wenn wir bestehende Datei öffnen oder eine neue Datei erstellen wollen, benötigen wir die Open<\/b>-Anweisung.<\/p>\n Die Open<\/b>-Anweisung ist nicht wie herkömmliche VBA-Anweisungen aufgebaut, die einfach aufgerufen werden und gegebenenfalls noch einen oder mehrere Parameter entgegennehmen.<\/p>\n Die Open<\/b>-Anweisung besteht vielmehr aus mehreren Teilen, die nacheinander notiert werden müssen. Hier ist die grundlegende Syntax:<\/p>\n Wir finden hier verschiedene Bestandteile, die wir wie Pflichtparameter oder optionale Parameter angeben können:<\/p>\n Für einfache lesende oder schreibende Zugriff benötigen wir nicht unbedingt alle dieser Parameter.<\/p>\n Eine geöffnete oder neu erstellte Datei kann je nach Modus lesend und\/oder schreibend verwendet werden.<\/p>\n Danach sollte sie jedoch auch wieder geschlossen werden. Das erledigt die Anweisung Close<\/b>.<\/p>\n Diese Anweisung erwartet keinen, einen oder mehrere Parameter. Ohne Parameter schließt die Close<\/b>-Anweisung alle aktuell geöffneten Dateien wieder.<\/p>\n Dateien werden mit der Open<\/b>-Anweisung unter Angabe einer Dateinummer geöffnet. Diese können wir auch angeben, wenn wir diese Datei gezielt wieder schließen möchten.<\/p>\n Wenn wir mehrere Dateien geöffnet haben, können wir diese entweder durch mehrfaches Aufrufen der Close<\/b>-Methode unter Angabe der jeweiligen Dateinummer wieder schließen. Wir können die Dateinummern aber auch als kommaseparierte Liste übergeben.<\/p>\n Hier ein Beispiel, das eine einfache Datei zum Schreiben anlegt oder öffnet:<\/p>\n Wenn wir sicher sind, dass in der aktuellen Session nur eine Datei geöffnet wird, können wir auch einen festen Zahlenwert nutzen:<\/p>\n Wenn wir zwei Dateien gleichzeitig benötigen, können wir zwei Mal die FreeFile<\/b>-Methode nutzen und die Dateien nacheinander öffnen und wieder schließen:<\/p>\n Wichtig ist, dass wir den zweiten Aufruf von FreeFile <\/b>erst starten, wenn die erste Datei bereits geöffnet ist. Ansonsten würde FreeFile <\/b>wieder den gleichen Wert wie beim ersten Aufruf liefern, da dieser noch nicht verwendet wurde.<\/p>\n Wir können die beiden letzten Anweisungen auch zusammenfassen:<\/p>\n Die vorherigen Beispiele legen immer leere Textdateien an. Da wir diese nicht mit Inhalt füllen, haben diese immer eine Größe von 0 Bytes.<\/p>\n Die Alternative zum Schließen aller geöffneten Dateien mit der Close<\/b>-Anweisung ist die Reset<\/b>-Anweisung.<\/p>\n Die folgende Prozedur erstellt eine Textdatei und füllt diese mit fünf Zeilen Text.<\/p>\n Dabei schreiben wir zuerst den Pfad zu der zu erstellenden Datei in die Variable strDateipfad<\/b>. Wir ermitteln mit der Funktion FreeFile <\/b>die nächste freie Dateinummer und schreiben diese in die Variable intDateinummer<\/b>. Diese verwenden wir in der Open<\/b>-Anweisung, der wir als Erstes mit strDateipfad <\/b>den Namen der zu erstellenden Datei übergeben.<\/p>\n Danach folgt der Teil For Output<\/b>, der angibt, das wir in die Datei schreiben wollen. Schließlich leitet das Schlüsselwort As <\/b>die Angabe der Dateinummer ein. Die Angabe des Raute-Zeichens (#) ist hier übrigens nicht verpflichtend – im Gegensatz zu den späteren Vorkommen in Zusammenhang mit den Print<\/b>– und Close<\/b>-Anweisungen. Der Übersichtlichkeit halber wollen wir das Raute-Zeichen jedoch konsequent überall benutzen, wo die Dateinummer zum Einsatz kommt.<\/p>\n Danach durchlaufen wir eine For…Next<\/b>-Schleife fünf Mal und schreiben eine Zeile wie die folgende in die Stringvariable strZeile<\/b>:<\/p>\n Danach schreiben wir den Inhalt dieser Variablen mit der Print<\/b>-Methode in die Datei. Dabei geben wir als ersten Parameter die Dateinummer und als zweiten Parameter den zu schreibenden Inhalt an.<\/p>\n Nachdem die Schleifendurchläufe abgeschlossen sind, schließen wir mit der Close<\/b>-Anweisung die Datei:<\/p>\n Das Ergebnis sieht im Texteditor wie in Bild 1 aus.<\/p>\n Bild 1: Die frisch erstellte Textdatei<\/span><\/b><\/p>\n Nun schauen wir uns die verschiedenen Methoden zum Lesen des Inhalts einer Textdatei an. Dazu gehören die folgenden:<\/p>\n Zunächst wollen wir die im vorherigen Beispiel erstellte Textdatei wieder in eine Textvariable einlesen.<\/p>\n Dazu verwenden wir die folgende Prozedur. Diese weist der Variablen strDateipfad <\/b>den Pfad zu der einzulesenden Datei zu. Dann prüft sie mit der Dir<\/b>-Funktion, ob diese Datei überhaupt vorhanden ist. Anderenfalls würde der Versuch, darauf zuzugreifen, anschließend einen Fehler auslösen.<\/p>\n Danach schreibt sie die mit FreeFile <\/b>ermittelte nächste freie Dateinummer in die Variable intDateinummer<\/b>. Diese nutzt sie dann als Dateinummer beim Öffnen der Datei aus strDateipfad <\/b>mit der Open<\/b>-Methode. Diese verwendet außerdem das Schlüsselwort For Input<\/b>, damit die Datei zum Lesen geöffnet wird. Danach liest die Prozedur den kompletten Inhalt der Datei mit einer einzigen Anweisung in die Variable strInhalt <\/b>ein.<\/p>\n Diese Anweisung heißt Input<\/b> und sie erhält als ersten Parameter die Anzahl der einzulesenden Zeichen und als zweiten die Dateinummer der betroffenen Datei. Die Anzahl der einzulesenden Zeichen ermitteln wir mit der Funktion LOF<\/b>, die als Parameter wiederum die Dateinummer erwartet.<\/p>\n Nach dem Schließen der Datei mit der Close<\/b>-Anweisung geben wir schließlich noch den eingelesenen Inhalt im Direktbereich des VBA-Editors aus:<\/p>\n Die Anzahl der enthaltenen Zeichen können wir uns mit der LOF<\/b>-Funktion auch im Direktbereich ausgeben lassen. Dazu fügen wir die folgende Zeile zwischen Open <\/b>und Close <\/b>ein:<\/p>\n Interessanterweise führt die Angabe des Raute-Zeichens beim Parameter der LOF<\/b>-Funktion zu einem Fehler.<\/p>\n Hinweis: Es gibt zwei verschiedene Input<\/b>-Anweisungen. Diese hier erwartet als ersten Parameter die Anzahl der einzulesenden Zeichen und als zweiten die Dateinummer. Die andere beschreiben wir weiter unten.<\/p>\n Es ist allerdings nicht immer gewünscht, gleich die vollständige Textdatei einzulesen. Gegebenenfalls möchte man nur soweit einlesen, bis man eine bestimmte Zeile gefunden hat. Deshalb zeigt das folgende Beispiel, wie wir eine Textdatei zeilenweise einlesen.<\/p>\n Dabei weisen wir der Variablen strDateipfad <\/b>wieder den Pfad zu der einzulesenden Datei zu. Dann prüfen wir mit der Dir<\/b>-Funktion, ob diese Datei überhaupt vorhanden ist. Ist das nicht der Fall, geben wir eine entsprechende Meldung aus und brechen das Einlesen ab.<\/p>\n Anderenfalls fahren wir fort und weisen intDateinummer <\/b>die nächste freie Dateinummer zu. Damit rufen wir die Open<\/b>-Anweisung unter Angabe des Dateipfades und der Zugriffsart For Input<\/b>, also zum Lesen, und der Dateinummer aus intDateinummer <\/b>auf.<\/p>\n Nun durchlaufen wir alle Zeilen der Textdatei. Das Einlesen erledigen wir mit der Anweisung Line Input<\/b>, der wir als ersten Parameter die Dateinummer und als zweiten die Variable übergeben, die wir mit der aktuellen Zeile füllen wollen. Außerdem wird die jeweils eingelesene Zeile im Direktbereich des VBA-Editors ausgegeben.<\/p>\n Die Einleseposition wird nach dem Einlesen einer Zeile automatisch in die nächste Zeile verschoben, wodurch wir im nächsten Schleifendurchlauf mit der gleichen Anweisung die folgende Zeile einlesen können.<\/p>\n Die Do While<\/b>-Schleife läuft solange, bis die Funktion EOF <\/b>mit der Dateinummer als Parameter den Wert True <\/b>zurückliefert. Das bedeutet, dass die Einleseposition sich hinter dem letzten lesbaren Zeichen befindet.<\/p>\n Nach dem Ausgeben aller Zeilen schließt die Prozedur die Datei mit der Close<\/b>-Anweisung wieder:<\/p>\n Es gibt eine weitere Methode, um Dateien mit Daten zu füllen. Dabei handelt es sich um die Write #<\/b>-Anweisung. Diese wird in der Regel gemeinsam mit der Read #<\/b>-Methode verwendet – Write # <\/b>schreibt in die Datei, Read # <\/b>liest aus der Datei.<\/p>\n Warum werden diese als Paar genutzt? Weil Write # <\/b>in einem speziellen Format schreibt, das am einfachsten mit Read # <\/b>wieder eingelesen werden kann.<\/p>\n Im folgenden Beispiel nutzen wir die Write #<\/b>-Anweisung, um Daten strukturiert in eine Datei zu schreiben. Dazu nutzen wir eine Access-Tabelle als Datenquelle. Diese enthält die drei Felder PersonID<\/b>, Person <\/b>und Alter <\/b>mit einigen wenigen Datensätzen (siehe Bild 2). <\/p>\n Bild 2: Daten zum Schreiben in eine Datei<\/span><\/b><\/p>\n Die folgende Prozedur trägt den Namen der zu erstellenden Datei in die Variable strDateipfad <\/b>ein. Dann öffnet sie ein Recordset auf Basis der oben vorgestellten Tabelle und öffnet die Datei aus strDateipfad <\/b>mit einer mit FreeFile <\/b>ermittelten Dateinummer zum Schreiben (For Output<\/b>).<\/p>\n Danach durchläuft sie in einer Do While<\/b>-Schleife das Recordset und ruft für jeden Datensatz einmal die Write #<\/b>-Anweisung auf. Diese verwendet als ersten Parameter die Dateinummer und in den folgenden Parametern die Inhalte der Felder PersonID<\/b>, Person <\/b>und Alter<\/b>.<\/p>\n Wichtig ist, dass wir die Inhalte der numerischen Felder nochmal in den entsprechenden Datentyp konvertieren müssen, also PersonID <\/b>mit der CLng<\/b>-Funktion und Alter <\/b>mit der CInt<\/b>-Funktion. Wenn wir dies nicht tun, werden alle Inhalte als String interpretiert und in Anführungszeichen eingeschlossen. Dadurch können sie nicht mehr korrekt eingelesen werden.<\/p>\n Nachdem alle Datensätze geschrieben wurden, schließt sie die Textdatei und die übrigen Elemente:<\/p>\n Das Ergebnis sehen wir in Bild 3. Jeder Datensatz ist in einer eigenen Zeile gelandet und jeder Feldinhalt wird in Anführungszeichen eingefasst und durch ein Komma vom nächsten Eintrag getrennt.<\/p>\n Bild 3: Ergebnis der Write-Anweisung<\/span><\/b><\/p>\n Nun wollen wir eine solche Datei auch wieder einlesen. Dazu verwenden wir die Input #<\/b>-Anweisung.<\/p>\n Die Prozedur aus Listing 1 benötigt einige weitere Variablen, da wir die Inhalte der einzelnen Felder zwischenspeichern müssen, bevor wir diese in die Tabelle schreiben. Sie trägt wieder den Dateinamen in die Variable strDateipfad <\/b>ein. Bevor sie die Datei zum Lesen öffnet, prüft sie zuerst mit der Dir<\/b>-Funktion, ob die Datei überhaupt vorhanden ist. Falls nicht, wird die Prozedur nach Ausgabe einer entsprechenden Meldung beendet.<\/p>\n Listing 1: Prozedur zum Einlesen von Daten einer Textdatei in eine Access-Tabelle<\/span><\/b><\/p>\n Anderenfalls öffnen wir wieder das Recordset, diesmal um Datensätze hinzuzufügen. Außerdem öffnen wir die Datei aus strDateipfad<\/b> für den lesenden Zugriff (For Input<\/b>).<\/p>\n Danach durchlaufen wir in einer Do While<\/b>-Schleife alle Zeilen der Textdatei, bis wir das Dateiende erreicht haben. Die dazu notwendige Abbruchbedingung lautet EOF (intDateinummer)<\/b>.<\/p>\n Innerhalb der Schleife lesen wir mit der Read #<\/b>-Methode jeweils eine Zeile ein. Der erste Parameter ist die Dateinummer, die folgenden sind die Variablen, in die wir die Daten aus dem jeweiligen Element füllen wollen.<\/p>\n Danach fügen wir den eingelesenen Datensatz in die Tabelle tblPersonen <\/b>ein. Um den neuen Datensatz anzulegen, rufen wir zunächst die AddNew<\/b>-Methode auf. Dann fügen wir die Inhalt der Variablen den entsprechenden Feldern zu.<\/p>\n Dabei lassen wir das Feld PersonID <\/b>aus, weil es sich hierbei um ein Autowert<\/b>-Feld handelt, das automatisch gefüllt wird.<\/p>\n Nach dem Füllen der Felder speichern wir den Datensatz mit der Update<\/b>-Methode.<\/p>\n Schließlich schließen wir die Textdatei und das Recordset und leeren die Objektvariablen.<\/p>\n Gegebenenfalls möchten wir einer Datei, die bereits die Daten aus der Tabelle einer Datenbank enthält, die Daten aus einer anderen Tabelle hinzufügen. Dann können wir eine ähnliche Prozedur wie zuvor verwenden. Wir müssen lediglich die Open<\/b>-Anweisung so ändern, dass diese die Datei statt mit For Output <\/b>mit For Append <\/b>öffnet:<\/p>\n VBA bietet einige Möglichkeiten für das Erstellen, Füllen, Ändern und Auslesen von Textdateien. Mit diesen kann man zwar nicht alle Aufgaben bewältigen, aber für einfache Zwecke lohnt sich ein Blick auf diese Sammlung. Wir meinen damit Anweisungen wie Open, Close, Print, Input und einige weitere, die spannenderweise im Objektkatalog noch nicht einmal erwähnt werden. Wir werden uns in diesem Artikel eingehend mit diesen Anweisungen beschäftigen und in verschiedenen Beispielen zeigen, wie sich damit immer wiederkehrende Aufgaben wie das Schreiben oder Lesen von Textdateien leicht bewältigen lässt.<\/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":[662024,66062024,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000454","post","type-post","status-publish","format-standard","hentry","category-662024","category-66062024","category-VBAProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000454","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000454"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000454\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000454"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000454"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000454"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000454"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
Öffnen oder Erstellen einer Datei mit Open<\/h2>\n
Open pathname For mode [ Access access ] [ lock ] As <\/span>[ # ] filenumber [ Len<\/span> = reclength ]<\/pre>\n\n
Schließen einer Datei mit Close<\/h2>\n
Dim <\/span>intFile As Integer<\/span>\r\nintFile = FreeFile\r\nOpen CurrentProject.Path & \"\\Test.txt\" For Output As <\/span>#intFile\r\nClose #intFile<\/pre>\nOpen CurrentProject.Path & \"\\Test.txt\" For Output As <\/span>#1\r\nClose #1<\/pre>\nDim <\/span>intFile1 As Integer<\/span>\r\nDim <\/span>intFile2 As Integer<\/span>\r\nintFile1 = FreeFile\r\nOpen CurrentProject.Path & \"\\Test1.txt\" For Output As <\/span>#intFile1\r\nintFile2 = FreeFile\r\nOpen CurrentProject.Path & \"\\Test2.txt\" For Output As <\/span>#intFile2\r\nClose #intFile1\r\nClose #intFile2<\/pre>\nClose #intFile1, #intFile2<\/pre>\n
Alle Dateien mit Reset schließen<\/h2>\n
Einfache Textdateien schreiben<\/h2>\n
Dies ist der Inhalt der Zeile 1<\/pre>\n
Public Sub <\/span>TextdateiSchreiben()\r\n Dim <\/span>strDateipfad As String<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n Dim <\/span>strPraefix As String<\/span>\r\n Dim <\/span>strTextinhalt As String<\/span>\r\n Dim <\/span>intZeile As Integer<\/span>\r\n strDateipfad = CurrentProject.Path & \"\\Textdatei.txt\"\r\n intDateinummer = FreeFile\r\n Open strDateipfad For Output As <\/span>#intDateinummer\r\n For intZeile = 1 To 5\r\n strTextinhalt = \"Dies ist der Inhalt der Zeile \" _\r\n & intZeile\r\n Print #intDateinummer, strTextinhalt\r\n Next<\/span> intZeile\r\n Close #intDateinummer\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_06\/pic_454_001.png\")
<\/p>\nEinfache Textdateien einlesen<\/h2>\n
\n
Einlesen einer vollständigen Textdatei<\/h2>\n
Public Sub <\/span>TextdateiKomplettEinlesen()\r\n Dim <\/span>strDateipfad As String<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n Dim <\/span>strInhalt As String<\/span>\r\n strDateipfad = CurrentProject.Path & \"\\Textdatei.txt\"\r\n If <\/span>Dir(strDateipfad) = \"\" Then<\/span>\r\n MsgBox<\/span> \"Die Datei existiert nicht: \" _\r\n & strDateipfad, vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n intDateinummer = FreeFile\r\n Open strDateipfad For Input As <\/span>#intDateinummer\r\n strInhalt = Input(LOF(intDateinummer), intDateinummer)\r\n Close #intDateinummer\r\n Debug.Print<\/span> strInhalt\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> LOF(intDateinummer)<\/pre>\nZeilenweises Einlesen einer Textdatei<\/h2>\n
Public Sub <\/span>TextdateiZeilenweiseEinlesen()\r\n Dim <\/span>strDateipfad As String<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n Dim <\/span>strZeile As String<\/span>\r\n strDateipfad = CurrentProject.Path & \"\\Textdatei.txt\"\r\n If <\/span>Dir(strDateipfad) = \"\" Then<\/span>\r\n MsgBox<\/span> \"Die Datei existiert nicht: \" _\r\n & strDateipfad, vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n intDateinummer = FreeFile\r\n Open strDateipfad For Input As <\/span>intDateinummer\r\n Do While<\/span> Not<\/span> EOF(intDateinummer)\r\n Line Input #intDateinummer, strZeile\r\n Debug.Print<\/span> strZeile\r\n Loop<\/span>\r\n \r\n Close #intDateinummer\r\nEnd Sub<\/span><\/pre>\nDateien lesen und schreiben mit Write # und Read #<\/h2>\n
Datei mit Write # schreiben<\/h2>\n
![\"Daten](\"..\/fileadmin\/_temp_\/2024_06\/pic_454_002.png\")
<\/p>\nPublic Sub <\/span>SchreibePersonenInDatei()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strDateipfad As String<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n strDateipfad = CurrentProject.Path & \"\\Personen.txt\"\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"tblPersonen\")\r\n intDateinummer = FreeFile\r\n Open strDateipfad For Output As <\/span>#intDateinummer\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Write #intDateinummer, CLng(rst!PersonID), _\r\n rst!Person, CInt(rst!Alter)\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Close #intDateinummer\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2024_06\/pic_454_003.png\")
<\/p>\nDatei mit Read # lesen<\/h2>\n
Public Sub <\/span>LesePersonenAusDatei()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strDateipfad As String<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n Dim <\/span>lngPersonID As Long<\/span>\r\n Dim <\/span>strPerson As String<\/span>\r\n Dim <\/span>intAlter As Integer<\/span>\r\n strDateipfad = CurrentProject.Path & \"\\Personen.txt\"\r\n If <\/span>Dir(strDateipfad) = \"\" Then<\/span>\r\n MsgBox<\/span> \"Die Datei existiert nicht: \" & strDateipfad, vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"tblPersonen\")\r\n intDateinummer = FreeFile\r\n Open strDateipfad For Input As <\/span>#intDateinummer\r\n Do While<\/span> Not<\/span> EOF(intDateinummer)\r\n Read #intDateinummer, lngPersonID, strPerson, intAlter\r\n rst.AddNew<\/span>\r\n rst!Person = strPerson\r\n rst!Alter = intAlter\r\n rst.Update\r\n Loop<\/span>\r\n Close #intDateinummer\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nDaten mit Write # an eine Datei anfügen<\/h2>\n
Open strDateipfad For Append As <\/span>#intDateinummer<\/pre>\n","protected":false},"excerpt":{"rendered":"