{"id":55000479,"date":"2026-04-01T00:00:00","date_gmt":"2026-05-16T19:27:49","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=479"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Textdateien_und_Stream_mit_dem_FileSystemObject","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Textdateien_und_Stream_mit_dem_FileSystemObject\/","title":{"rendered":"Textdateien und Stream mit dem FileSystemObject"},"content":{"rendered":"

\"\"Im Artikel Dateimanagement mit dem FileSystemObject<\/b> (www.vbentwickler.de\/478<\/b>) haben wir die Klasse FileSystemObject<\/b> kennengelernt und damit Laufwerke, Verzeichnisse und Dateien verwaltet. Dabei haben wir drei Methoden und Funktionen erwähnt, die wir in einem separaten Artikel behandeln wollten: CreateTextFile<\/b>, OpenTextFile<\/b> und OpenAsTextStream<\/b>. Diese drei Elemente sind das Tor zur Klasse TextStream<\/b>, mit der wir Textdateien erstellen, beschreiben und auslesen können. In diesem Artikel schauen wir uns zuerst an, wie wir TextStream<\/b>-Objekte erzeugen, und gehen dann alle Eigenschaften und Methoden der Klasse durch. Abschließend bauen wir ein praxisnahes Beispiel, in dem wir eine CSV-Datei erzeugen und wieder einlesen.<\/b><\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels findest Du in der Beispieldatenbank zum Artikel. Alle Prozeduren befinden sich im Modul mdlTextStream<\/b>. Um die Funktionen des FileSystemObject<\/b> nutzen zu können, benötigst Du einen Verweis auf die Bibliothek Microsoft Scripting Runtime<\/b>. Diesen richtest Du über den Menüpunkt Extras|Verweise<\/b> im VBA-Editor ein.<\/p>\n

Drei Wege zum TextStream<\/h2>\n

Die Klasse TextStream<\/b> lässt sich nicht direkt instanziieren. Wir können also kein Objekt mit New TextStream<\/b> erzeugen. Stattdessen liefern uns drei Funktionen beziehungsweise Methoden ein solches Objekt zurück:<\/p>\n

    \n
  • CreateTextFile<\/b>: Erstellt eine neue Textdatei und gibt ein TextStream<\/b>-Objekt zum Beschreiben zurück.<\/li>\n
  • OpenTextFile<\/b>: Öffnet eine vorhandene Textdatei und gibt ein TextStream<\/b>-Objekt zum Lesen, Schreiben oder Anhängen zurück.<\/li>\n
  • OpenAsTextStream<\/b>: Methode der File<\/b>-Klasse, die ein TextStream<\/b>-Objekt auf Basis eines bereits referenzierten File<\/b>-Objekts öffnet.<\/li>\n<\/ul>\n

    Alle drei Varianten liefern am Ende ein Objekt vom Typ TextStream<\/b>, das über dieselben Eigenschaften und Methoden verfügt. Der Unterschied liegt nur darin, wie wir an dieses Objekt gelangen.<\/p>\n

    Textdatei erstellen mit CreateTextFile<\/h2>\n

    Die Funktion CreateTextFile<\/b> ist eine Methode des FileSystemObject<\/b>. Sie erwartet als ersten Parameter den Pfad zu der zu erstellenden Datei. Optional können wir mit dem zweiten Parameter (Overwrite<\/b>) angeben, ob eine bereits vorhandene Datei überschrieben werden soll. Der Standardwert ist True<\/b>. Ein dritter optionaler Parameter (Unicode<\/b>) legt fest, ob die Datei im Unicode-Format erstellt werden soll. Der Standardwert ist False<\/b>, was eine ANSI-Datei erzeugt.<\/p>\n

    Die folgende Prozedur erstellt eine neue Textdatei im aktuellen Datenbankverzeichnis und schreibt drei Zeilen hinein:<\/p>\n

    Public Sub <\/span>TextdateiErstellen()\r\n    Dim <\/span>objFSO As <\/span>Scripting.FileSystemObject\r\n    Dim <\/span>objTextstream As <\/span>Scripting.TextStream\r\n    Dim <\/span>strPfad As String<\/span>\r\n    strPfad = CurrentProject.Path & \"\\Beispiel.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = objFSO.CreateTextFile(strPfad, True<\/span>)\r\n    objTextstream.WriteLine \"Erste Zeile\"\r\n    objTextstream.WriteLine \"Zweite Zeile\"\r\n    objTextstream.WriteLine \"Dritte Zeile\"\r\n    objTextstream.Close\r\n    Set<\/span> objTextstream = Nothing\r\n    Set<\/span> objFSO = Nothing\r\nEnd Sub<\/span><\/pre>\n
    Wir erzeugen ein FileSystemObject<\/b> und rufen dessen CreateTextFile<\/b>-Methode auf. Das Ergebnis ist ein TextStream<\/b>-Objekt, das bereits zum Schreiben geöffnet ist. Mit WriteLine<\/b> schreiben wir drei Zeilen in die Datei und schließen den Stream anschließend mit Close<\/b>.<\/p>\n
    Übrigens: CreateTextFile<\/b> gibt es nicht nur am FileSystemObject<\/b>, sondern auch an der Folder<\/b>-Klasse. Dort übergeben wir lediglich den Dateinamen ohne Verzeichnisangabe, weil das Verzeichnis bereits durch das Folder<\/b>-Objekt festgelegt ist.<\/p>\n
    Textdatei öffnen mit OpenTextFile<\/h2>\n
    Um eine vorhandene Textdatei zu öffnen, verwenden wir die Funktion OpenTextFile<\/b> des FileSystemObject<\/b>. Diese erwartet als ersten Parameter den Pfad zur Datei.<\/p>\n
    Der zweite Parameter (IOMode<\/b>) gibt den Zugriffsmodus an. Hier stehen drei Konstanten zur Verfügung:<\/p>\n
      \n
    • ForReading<\/b> (1<\/b>): Öffnet die Datei nur zum Lesen.<\/li>\n
    • ForWriting<\/b> (2<\/b>): Öffnet die Datei zum Schreiben. Dabei wird der vorhandene Inhalt überschrieben.<\/li>\n
    • ForAppending<\/b> (8<\/b>): Öffnet die Datei zum Anhängen. Neuer Inhalt wird am Ende der Datei angefügt.<\/li>\n<\/ul>\n
      Optional kann ein dritter Parameter (Create<\/b>) angegeben werden, der festlegt, ob die Datei erstellt werden soll, wenn sie noch nicht existiert. Der Standardwert ist False<\/b>. Ein vierter Parameter (Format<\/b>) steuert die Zeichenkodierung: TristateFalse<\/b> (0<\/b>) für ANSI, TristateTrue<\/b> (-1<\/b>) für Unicode und TristateUseDefault<\/b> (-2<\/b>) für die Systemvorgabe.<\/p>\n
      Das folgende Beispiel öffnet die zuvor erstellte Datei zum Lesen und gibt den gesamten Inhalt im Direktbereich aus:<\/p>\n
      Public Sub <\/span>TextdateiLesen()\r\n    Dim <\/span>objFSO As <\/span>Scripting.FileSystemObject\r\n    Dim <\/span>objTextstream As <\/span>Scripting.TextStream\r\n    Dim <\/span>strPfad As String<\/span>\r\n    strPfad = CurrentProject.Path & \"\\Beispiel.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = objFSO.OpenTextFile(strPfad, _\r\n        ForReading)\r\n    Debug.Print<\/span> objTextstream.ReadAll\r\n    objTextstream.Close\r\n    Set<\/span> objTextstream = Nothing\r\n    Set<\/span> objFSO = Nothing\r\nEnd Sub<\/span><\/pre>\n
      Hier nutzen wir die Methode ReadAll<\/b>, um den gesamten Inhalt der Datei auf einmal einzulesen. Die Details zu ReadAll<\/b> und den übrigen Methoden der TextStream<\/b>-Klasse folgen weiter unten.<\/p>\n
      TextStream über ein File-Objekt öffnen mit OpenAsTextStream<\/h2>\n
      Der dritte Weg führt über die File<\/b>-Klasse. Wenn wir bereits ein File<\/b>-Objekt referenziert haben, können wir dessen Methode OpenAsTextStream<\/b> aufrufen. Die Parameter sind identisch mit denen von OpenTextFile<\/b>, allerdings ohne den Dateipfad, da dieser bereits durch das File<\/b>-Objekt feststeht.<\/p>\n
      Das folgende Beispiel zeigt, wie wir zunächst ein File<\/b>-Objekt holen und darauf einen TextStream<\/b> öffnen:<\/p>\n
      Public Sub <\/span>TextdateiPerFileObjekt()\r\n     Dim <\/span>objFSO As <\/span>Scripting.FileSystemObject\r\n     Dim <\/span>objFile As <\/span>Scripting.File\r\n     Dim <\/span>objTextstream As <\/span>Scripting.TextStream\r\n     Dim <\/span>strPfad As String<\/span>\r\n     strPfad = CurrentProject.Path _\r\n          & \"\\Beispiel.txt\"\r\n     Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n     Set<\/span> objFile = objFSO.GetFile(strPfad)\r\n     Set<\/span> objTextstream = objFile.OpenAsTextStream( _\r\n          ForReading)\r\n     Debug.Print<\/span> objTextstream.ReadAll\r\n     objTextstream.Close\r\n     Set<\/span> objTextstream = Nothing\r\n     Set<\/span> objFile = Nothing\r\n     Set<\/span> objFSO = Nothing\r\nEnd Sub<\/span><\/pre>\n
      Wir holen zunächst mit GetFile<\/b> ein File<\/b>-Objekt und rufen dann dessen OpenAsTextStream<\/b>-Methode auf. Das Ergebnis ist wiederum ein TextStream<\/b>-Objekt, das wir wie gewohnt verwenden können.<\/p>\n
      Dieser Weg bietet sich vor allem an, wenn wir ohnehin bereits mit File<\/b>-Objekten arbeiten, zum Beispiel beim Durchlaufen der Files<\/b>-Auflistung eines Verzeichnisses.<\/p>\n
      Die Eigenschaften der TextStream-Klasse<\/h2>\n
      Die TextStream<\/b>-Klasse bietet vier Eigenschaften, mit denen wir Informationen über die aktuelle Position innerhalb des Streams abfragen können. Alle vier sind schreibgeschützt.<\/p>\n
        \n
      • AtEndOfLine<\/b> gibt True<\/b> zurück, wenn sich die Leseposition am Ende einer Zeile befindet, also direkt vor dem Zeilenumbruch. Diese Eigenschaft steht nur bei Streams zur Verfügung, die zum Lesen geöffnet wurden. Versuchen wir, sie bei einem zum Schreiben geöffneten Stream abzufragen, erhalten wir einen Laufzeitfehler.<\/li>\n
      • AtEndOfStream<\/b> gibt True<\/b> zurück, wenn die Leseposition das Ende der Datei erreicht hat. Auch diese Eigenschaft ist nur bei lesend geöffneten Streams verfügbar. Sie entspricht in etwa der EOF<\/b>-Funktion, die wir bei den klassischen VBA-Dateioperationen mit Open<\/b> und Close<\/b> verwenden.<\/li>\n
      • Column<\/b> liefert die aktuelle Spaltenposition innerhalb der Zeile. Die Zählung beginnt bei 1. Nach dem Öffnen einer Datei zum Lesen steht Column<\/b> auf 1. Nach dem Lesen des ersten Zeichens steht der Wert auf 2 und so weiter.<\/li>\n
      • Line<\/b> gibt die aktuelle Zeilennummer zurück. Auch hier beginnt die Zählung bei 1. Jedes Mal, wenn ein Zeilenumbruch überschritten wird, erhöht sich der Wert um eins.<\/li>\n<\/ul>\n
        Mit Column<\/b> und Line<\/b> zusammen können wir jederzeit feststellen, an welcher Stelle in der Datei wir uns beim Lesen befinden. Das kann zum Beispiel bei der Fehleranalyse hilfreich sein, wenn beim Einlesen einer Datei ein unerwarteter Wert auftritt und wir die genaue Position im Fehlerprotokoll festhalten möchten.<\/p>\n
        Methoden zum Lesen: Read, ReadLine und ReadAll<\/h2>\n
        Die TextStream<\/b>-Klasse bietet drei Methoden zum Lesen von Inhalten. Alle drei setzen voraus, dass der Stream zum Lesen geöffnet wurde (Modus ForReading<\/b>).<\/p>\n
        Read<\/b> erwartet als Parameter die Anzahl der zu lesenden Zeichen und gibt diese als Zeichenkette zurück. Nach dem Aufruf wird die Leseposition um die entsprechende Anzahl Zeichen weitergerückt. Das folgende Beispiel liest die ersten zehn Zeichen einer Datei:<\/p>\n
        Public Sub <\/span>ErsteZeichenLesen()\r\n    ...\r\n    Dim <\/span>strPfad As String<\/span>\r\n    Dim <\/span>strErgebnis As String<\/span>\r\n    strPfad = CurrentProject.Path & \"\\Beispiel.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = _\r\n        objFSO.OpenTextFile(strPfad, ForReading)\r\n    strErgebnis = objTextstream.Read(10)\r\n    Debug.Print<\/span> strErgebnis\r\n    ...\r\nEnd Sub<\/span><\/pre>\n
        ReadLine<\/b> liest eine komplette Zeile bis zum nächsten Zeilenumbruch und gibt diese ohne den Zeilenumbruch zurück. Die Leseposition wird in die nächste Zeile verschoben. In Kombination mit AtEndOfStream<\/b> können wir damit alle Zeilen einer Datei durchlaufen:<\/p>\n
        Public Sub <\/span>AlleZeilenLesen()\r\n    ...\r\n    strPfad = CurrentProject.Path & \"\\Beispiel.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = _\r\n        objFSO.OpenTextFile(strPfad, ForReading)\r\n    Do While<\/span> Not<\/span> objTextstream.AtEndOfStream\r\n        Debug.Print<\/span> objTextstream.ReadLine\r\n    Loop<\/span>\r\n    ...\r\nEnd Sub<\/span><\/pre>\n
        Dies ist das Gegenstück zu der aus den klassischen VBA-Dateioperationen bekannten Kombination aus Line Input #<\/b> und EOF<\/b>.<\/p>\n
        ReadAll<\/b> liest den gesamten verbleibenden Inhalt der Datei in eine einzige Zeichenkette. Das ist praktisch, wenn wir den vollständigen Dateiinhalt auf einmal verarbeiten möchten. Bei sehr großen Dateien sollte man diese Methode allerdings mit Bedacht einsetzen, da der gesamte Inhalt im Arbeitsspeicher gehalten wird.<\/p>\n
        Methoden zum Schreiben: Write, WriteLine und WriteBlankLines<\/h2>\n
        Für das Schreiben stehen ebenfalls drei Methoden bereit. Diese setzen voraus, dass der Stream zum Schreiben (ForWriting<\/b>) oder zum Anhängen (ForAppending<\/b>) geöffnet wurde.<\/p>\n
        Write<\/b> schreibt eine Zeichenkette in den Stream, ohne einen Zeilenumbruch anzuhängen. Mehrere aufeinanderfolgende Aufrufe von Write<\/b> erzeugen damit zusammenhängenden Text in derselben Zeile:<\/p>\n
        Public Sub <\/span>TextOhneUmbruch()\r\n    ...\r\n    strPfad = CurrentProject.Path & \"\\WriteTest.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = _\r\n        objFSO.CreateTextFile(strPfad, True<\/span>)\r\n    objTextstream.Write \"Vorname\"\r\n    objTextstream.Write \";\"\r\n    objTextstream.Write \"Nachname\"\r\n    ...\r\nEnd Sub<\/span><\/pre>\n
        Das Ergebnis in der Datei wäre eine einzelne Zeile mit dem Inhalt Vorname;Nachname<\/b>.<\/p>\n
        WriteLine<\/b> funktioniert wie Write<\/b>, hängt aber automatisch einen Zeilenumbruch an. Jeder Aufruf von WriteLine<\/b> erzeugt also eine eigene Zeile in der Datei. Rufen wir WriteLine<\/b> ohne Parameter auf, wird lediglich eine Leerzeile geschrieben.<\/p>\n
        WriteBlankLines<\/b> erwartet als Parameter die Anzahl der einzufügenden Leerzeilen. Der folgende Aufruf fügt drei leere Zeilen in die Datei ein:<\/p>\n
        Public Sub <\/span>LeerzeilenEinfuegen()\r\n    ...\r\n    strPfad = CurrentProject.Path & \"\\Leerzeilen.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = objFSO.CreateTextFile( _\r\n        strPfad, True<\/span>)\r\n    objTextstream.WriteLine \"Abschnitt 1\"\r\n    objTextstream.WriteBlankLines 3\r\n    objTextstream.WriteLine \"Abschnitt 2\"\r\n    ...\r\nEnd Sub<\/span><\/pre>\n
        Diese Methode ist nützlich, wenn wir in einer Ausgabedatei Abschnitte visuell voneinander trennen möchten.<\/p>\n
        Navigieren im Stream: Skip und SkipLine<\/h2>\n
        Neben den Lese- und Schreibmethoden bietet die TextStream<\/b>-Klasse zwei Methoden, mit denen wir Inhalte beim Lesen überspringen können, ohne diese in eine Variable einzulesen.<\/p>\n
        Skip<\/b> erwartet als Parameter die Anzahl der zu überspringenden Zeichen. Die Leseposition wird um die angegebene Anzahl Zeichen vorgerückt:<\/p>\n
        Public Sub <\/span>ZeichenUeberspringen()\r\n    ...\r\n    strPfad = CurrentProject.Path & \"\\Beispiel.txt\"\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = _\r\n        objFSO.OpenTextFile(strPfad, ForReading)\r\n    objTextstream.Skip 5\r\n    Debug.Print<\/span> objTextstream.ReadLine\r\n    ...\r\nEnd Sub<\/span><\/pre>\n
        SkipLine<\/b> überspringt die aktuelle Zeile vollständig, einschließlich des Zeilenumbruchs. Die Leseposition steht danach am Anfang der nächsten Zeile.<\/p>\n
        Beide Methoden funktionieren nur bei Streams, die zum Lesen geöffnet wurden. Ein typischer Anwendungsfall für SkipLine<\/b> ist das Überspringen einer Kopfzeile beim Einlesen von CSV-Dateien.<\/p>\n
        Statt die erste Zeile mit ReadLine<\/b> in eine Variable zu lesen, die wir anschließend gar nicht benötigen, überspringen wir sie einfach.<\/p>\n
        Stream schließen mit Close<\/h2>\n
        Die Close<\/b>-Methode schließt den TextStream<\/b> und gibt die zugrunde liegende Dateiressource frei. Nach dem Aufruf von Close<\/b> kann das TextStream<\/b>-Objekt nicht mehr verwendet werden. Es empfiehlt sich, nach dem Schließen auch die Objektvariable auf Nothing<\/b> zu setzen:<\/p>\n
        ts.Close\r\nSet<\/span> ts = Nothing<\/pre>\n
        Vergisst man das Schließen, wird der Stream spätestens beim Aufräumen der Objektvariablen durch VBA geschlossen. Es ist aber guter Stil, Ressourcen explizit freizugeben, sobald sie nicht mehr benötigt werden.<\/p>\n
        Vergleich: TextStream versus Open\/Close<\/h2>\n
        Im Artikel VBA und Textdateien: Alles über Open, Close und Co.<\/b> (www.vbentwickler.de\/454<\/b>) haben wir die klassischen VBA-Anweisungen Open<\/b>, Close<\/b>, Print #<\/b> und Line Input #<\/b> kennengelernt. Nun stellt sich die Frage: Wann greift man zu den klassischen Anweisungen und wann zum TextStream<\/b>?<\/p>\n
        Die klassischen Anweisungen benötigen keinen Verweis auf eine externe Bibliothek und funktionieren direkt in jedem VBA-Projekt. Außerdem bieten sie mit Write #<\/b> und Input #<\/b> eine Möglichkeit, strukturierte Daten typsicher zu schreiben und wieder einzulesen.<\/p>\n
        Das TextStream<\/b>-Objekt punktet dagegen mit einer saubereren, objektorientierten Syntax. Statt mit Dateinummern zu hantieren, arbeiten wir mit einem Objekt und dessen Methoden.<\/p>\n
        Außerdem können wir mit OpenTextFile<\/b> direkt Unicode-Dateien lesen und schreiben, was mit den klassischen Anweisungen nicht möglich ist. Wenn wir ohnehin bereits das FileSystemObject<\/b> für Dateioperationen verwenden, liegt es nahe, auch die Textdateioperationen darüber abzuwickeln.<\/p>\n
        Praxisbeispiel: CSV-Export und -Import<\/h2>\n
        Zum Abschluss verknüpfen wir die vorgestellten Methoden in einem praxisnahen Szenario. Wir exportieren den Inhalt einer Access-Tabelle in eine CSV-Datei und lesen diese anschließend wieder zeilenweise ein.<\/p>\n
        Die Tabelle tblArtikel<\/b> enthält drei Felder: ArtikelID<\/b> (Autowert), Bezeichnung<\/b> (Text) und Preis<\/b> (Währung) – siehe Bild 1.<\/p>\n
        \"Die<\/p>\n
        Bild 1: Die Beispieltabelle tblArtikel<\/span><\/b><\/p>\n
        Die Prozedur CSVExport<\/b> öffnet ein Recordset auf die Tabelle und schreibt zuerst eine Kopfzeile mit den Feldnamen. Dann durchläuft sie alle Datenätze und schreibt die Feldwerte durch Semikolon getrennt in jeweils eine Zeile (siehe Listing 1).<\/p>\n
        Public Sub <\/span>CSVExport()\r\n    Dim <\/span>db As <\/span>DAO.Database\r\n    Dim <\/span>rst As <\/span>DAO.Recordset\r\n    Dim <\/span>objFSO As <\/span>Scripting.FileSystemObject\r\n    Dim <\/span>objTextstream As <\/span>Scripting.TextStream\r\n    Dim <\/span>strPfad As String<\/span>\r\n    strPfad = CurrentProject.Path & \"\\Artikel.csv\"\r\n    Set<\/span> db = CurrentDb\r\n    Set<\/span> rst = db.OpenRecordset(\"tblArtikel\", _\r\n        dbOpenSnapshot)\r\n    Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> objTextstream = objFSO.CreateTextFile(strPfad, True<\/span>)\r\n    objTextstream.WriteLine \"ArtikelID;Bezeichnung;Preis\"\r\n    Do While<\/span> Not<\/span> rst.EOF\r\n        objTextstream.WriteLine rst!ArtikelID & \";\" & rst!Bezeichnung & \";\" & rst!Preis\r\n        rst.MoveNext<\/span>\r\n    Loop<\/span>\r\n    objTextstream.Close\r\n    rst.Close\r\n    Set<\/span> objTextstream = Nothing\r\n    Set<\/span> rst = Nothing\r\n    Set<\/span> objFSO = Nothing\r\n    Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n
        Listing 1: Prozedur zum Exportieren von Tabellendaten in eine .csv-Datei<\/span><\/b><\/p>\n
        Die Prozedur verwendet CreateTextFile<\/b>, um die CSV-Datei neu anzulegen. Mit WriteLine<\/b> schreiben wir zuerst die Kopfzeile und dann je Datensatz eine Zeile mit den durch Semikolon getrennten Feldwerten. Am Ende schließen wir sowohl den Stream als auch das Recordset.<\/p>\n
        Das Ergebnis sehen wir in Bild 2.<\/p>\n
        \"Die<\/p>\n
        Bild 2: Die als .csv-Datei exportierten Artikeldaten<\/span><\/b><\/p>\n
        Hier könnte es noch ein Problem geben, nämlich wenn die zu speichernden Werte selbst Semikola enthalten. Diese würden als neues Feld interpretiert werden. Das können wir allerdings verhindern, indem wir die zu schreibenden Werte in Anführungszeichen einfassen. Hier ist die korrigierte Zeile:<\/p>\n
        objTextstream.WriteLine \"\"\"\" & rst!ArtikelID _\r\n    & \"\"\";\"\"\" & rst!Bezeichnung & \"\"\";\"\"\" & rst!Preis & \"\"\"\"<\/pre>\n
        CSV-Datei wieder importieren<\/h2>\n
        Für den Import der CSV-Datei nutzen wir OpenTextFile<\/b> mit dem Modus ForReading<\/b>. Die Prozedur CSVImport<\/b> überspringt die Kopfzeile mit SkipLine<\/b> und liest dann alle weiteren Zeilen mit ReadLine<\/b> ein. Jede Zeile wird an den Semikolons aufgeteilt und die einzelnen Werte werden im Direktbereich ausgegeben (siehe Listing 2).<\/p>\n
        Public Sub <\/span>CSVImport()\r\n     Dim <\/span>objFSO As <\/span>Scripting.FileSystemObject\r\n     Dim <\/span>objTextstream As <\/span>Scripting.TextStream\r\n     Dim <\/span>strPfad As String<\/span>\r\n     Dim <\/span>strZeile As String<\/span>\r\n     Dim <\/span>arrFelder() As String<\/span>\r\n     strPfad = CurrentProject.Path & \"\\Artikel.csv\"\r\n     Set<\/span> objFSO = New<\/span> Scripting.FileSystemObject\r\n     Set<\/span> objTextstream = objFSO.OpenTextFile(strPfad, ForReading)\r\n     objTextstream.SkipLine\r\n     Do While<\/span> Not<\/span> objTextstream.AtEndOfStream\r\n          strZeile = objTextstream.ReadLine\r\n          arrFelder = Split<\/span>(strZeile, \";\")\r\n          Debug.Print<\/span> \"ID: \" & arrFelder(0) & \", Bezeichnung: \" & arrFelder(1) & \", Preis: \" & arrFelder(2)\r\n     Loop<\/span>\r\n     objTextstream.Close\r\n     Set<\/span> objTextstream = Nothing\r\n     Set<\/span> objFSO = Nothing\r\nEnd Sub<\/span><\/pre>\n
        Listing 2: Prozedur zum Einlesen einer CSV-Datei<\/span><\/b><\/p>\n
        Hier sehen wir SkipLine<\/b> in Aktion: Wir überspringen die Kopfzeile, weil wir deren Inhalt nicht benötigen. Danach durchlaufen wir mit Do While Not ts.AtEndOfStream<\/b> alle verbleibenden Zeilen. Jede Zeile wird mit der VBA-Funktion Split<\/b> am Semikolon aufgeteilt und die Einzelwerte werden ausgegeben.<\/p>\n
        Natürlich könnten wir statt der Ausgabe im Direktbereich die eingelesenen Daten auch in eine Tabelle schreiben, in ein Array sammeln oder anderweitig weiterverarbeiten.<\/p>\n
        Text an eine vorhandene Datei anhängen<\/h2>\n
        Ein häufiger Anwendungsfall ist das Protokollieren von Vorgängen in einer Logdatei.<\/p>\n
        Dazu öffnen wir die Datei im Modus ForAppending<\/b>, damit der vorhandene Inhalt erhalten bleibt und die neuen Einträge am Ende angefügt werden.<\/p>\n
        Die folgende Prozedur schreibt einen Eintrag mit Zeitstempel in eine Logdatei:<\/p>\n
        Public Sub <\/span>LogEintrag(strMeldung As String<\/span>)\r\n    Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\n    Dim <\/span>ts As <\/span>Scripting.TextStream\r\n    Dim <\/span>strPfad As String<\/span>\r\n    strPfad = CurrentProject.Path & \"\\Protokoll.log\"\r\n    Set<\/span> fso = New<\/span> Scripting.FileSystemObject\r\n    Set<\/span> ts = fso.OpenTextFile(strPfad, _\r\n    ForAppending, True<\/span>)\r\n    ts.WriteLine Format(Now, \"yyyy-mm-dd hh:nn:ss\") _\r\n        & \" - \" & strMeldung\r\n    ts.Close\r\n    Set<\/span> ts = Nothing\r\n    Set<\/span> fso = Nothing\r\nEnd Sub<\/span><\/pre>\n
        Beachte den dritten Parameter True<\/b> bei OpenTextFile<\/b>: Damit wird die Datei automatisch erstellt, falls sie noch nicht existiert.<\/p>\n
        Beim ersten Aufruf wird die Logdatei also angelegt, bei allen weiteren Aufrufen werden die Einträge angehängt.<\/p>\n
        Einen Aufruf dieser Prozedur könnten wir so gestalten:<\/p>\n
        LogEintrag \"Import abgeschlossen\"<\/pre>\n
        Damit landet in der Logdatei eine Zeile wie die folgende:<\/p>\n
        2025-06-15 14:30:22 - Import abgeschlossen<\/pre>\n
        Zusammenfassung und Ausblick<\/h2>\n
        Mit der TextStream<\/b>-Klasse der Bibliothek Microsoft Scripting Runtime<\/b> können wir Textdateien komfortabel erstellen, beschreiben und auslesen. Die drei Wege zum TextStream<\/b> – CreateTextFile<\/b>, OpenTextFile<\/b> und OpenAsTextStream<\/b> – bieten für jede Situation den passenden Einstieg.<\/p>\n
        Die Methoden zum Lesen (Read<\/b>, ReadLine<\/b>, ReadAll<\/b>), zum Schreiben (Write<\/b>, WriteLine<\/b>, WriteBlankLines<\/b>) und zum Navigieren (Skip<\/b>, SkipLine<\/b>) decken alle typischen Anforderungen ab.<\/p>\n
        In Kombination mit den Eigenschaften AtEndOfStream<\/b>, AtEndOfLine<\/b>, Line<\/b> und Column<\/b> haben wir jederzeit volle Kontrolle über die aktuelle Position im Stream.<\/p>\n
        Gegenüber den klassischen VBA-Anweisungen Open<\/b>, Close<\/b>, Print #<\/b> und Line Input #<\/b> bietet der TextStream<\/b> eine objektorientierte Alternative, die besonders dann naheliegt, wenn wir ohnehin mit dem FileSystemObject<\/b> arbeiten.<\/p>\n
        Für Szenarien, in denen wir auch Unicode-Dateien verarbeiten müssen, ist der TextStream<\/b> sogar die einzige Option innerhalb der Scripting-Welt.<\/p>\n
        Downloads zu diesem Beitrag<\/h2>\n
        Enthaltene Beispieldateien:<\/p>\n
        TextdateienUndStreamMitFileSytemObject.accdb<\/p>\n
        Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
        Im Artikel Dateimanagement mit dem FileSystemObject (www.vbentwickler.de\/478) haben wir die Klasse FileSystemObject kennengelernt und damit Laufwerke, Verzeichnisse und Dateien verwaltet. Dabei haben wir drei Methoden und Funktionen erwähnt, die wir in einem separaten Artikel behandeln wollten: CreateTextFile, OpenTextFile und OpenAsTextStream. Diese drei Elemente sind das Tor zur Klasse TextStream, mit der wir Textdateien erstellen, beschreiben und auslesen können. In diesem Artikel schauen wir uns zuerst an, wie wir TextStream-Objekte erzeugen, und gehen dann alle Eigenschaften und Methoden der Klasse durch. Abschließend bauen wir ein praxisnahes Beispiel, in dem wir eine CSV-Datei erzeugen und wieder einlesen.<\/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":[66022026,662026,44000023,44000025,44000028],"tags":[],"yst_prominent_words":[],"class_list":["post-55000479","post","type-post","status-publish","format-standard","hentry","category-66022026","category-662026","category-PowerApps","category-VBAProgrammierung","category-Word_programmieren"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000479","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=55000479"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000479\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000479"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000479"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000479"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000479"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}