Textdateien und Stream mit dem FileSystemObject

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.

Beispieldatenbank

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

Drei Wege zum TextStream

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

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

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

Textdatei erstellen mit CreateTextFile

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

Die folgende Prozedur erstellt eine neue Textdatei im aktuellen Datenbankverzeichnis und schreibt drei Zeilen hinein:

Public Sub TextdateiErstellen()
    Dim objFSO As Scripting.FileSystemObject
    Dim objTextstream As Scripting.TextStream
    Dim strPfad As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.CreateTextFile(strPfad, True)
    objTextstream.WriteLine "Erste Zeile"
    objTextstream.WriteLine "Zweite Zeile"
    objTextstream.WriteLine "Dritte Zeile"
    objTextstream.Close
    Set objTextstream = Nothing
    Set objFSO = Nothing
End Sub

Wir erzeugen ein FileSystemObject und rufen dessen CreateTextFile-Methode auf. Das Ergebnis ist ein TextStream-Objekt, das bereits zum Schreiben geöffnet ist. Mit WriteLine schreiben wir drei Zeilen in die Datei und schließen den Stream anschließend mit Close.

Übrigens: CreateTextFile gibt es nicht nur am FileSystemObject, sondern auch an der Folder-Klasse. Dort übergeben wir lediglich den Dateinamen ohne Verzeichnisangabe, weil das Verzeichnis bereits durch das Folder-Objekt festgelegt ist.

Textdatei öffnen mit OpenTextFile

Um eine vorhandene Textdatei zu öffnen, verwenden wir die Funktion OpenTextFile des FileSystemObject. Diese erwartet als ersten Parameter den Pfad zur Datei.

Der zweite Parameter (IOMode) gibt den Zugriffsmodus an. Hier stehen drei Konstanten zur Verfügung:

• ForReading (1): Öffnet die Datei nur zum Lesen.
• ForWriting (2): Öffnet die Datei zum Schreiben. Dabei wird der vorhandene Inhalt überschrieben.
• ForAppending (8): Öffnet die Datei zum Anhängen. Neuer Inhalt wird am Ende der Datei angefügt.

Optional kann ein dritter Parameter (Create) angegeben werden, der festlegt, ob die Datei erstellt werden soll, wenn sie noch nicht existiert. Der Standardwert ist False. Ein vierter Parameter (Format) steuert die Zeichenkodierung: TristateFalse (0) für ANSI, TristateTrue (-1) für Unicode und TristateUseDefault (-2) für die Systemvorgabe.

Das folgende Beispiel öffnet die zuvor erstellte Datei zum Lesen und gibt den gesamten Inhalt im Direktbereich aus:

Public Sub TextdateiLesen()
    Dim objFSO As Scripting.FileSystemObject
    Dim objTextstream As Scripting.TextStream
    Dim strPfad As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.OpenTextFile(strPfad, _
        ForReading)
    Debug.Print objTextstream.ReadAll
    objTextstream.Close
    Set objTextstream = Nothing
    Set objFSO = Nothing
End Sub

Hier nutzen wir die Methode ReadAll, um den gesamten Inhalt der Datei auf einmal einzulesen. Die Details zu ReadAll und den übrigen Methoden der TextStream-Klasse folgen weiter unten.

TextStream über ein File-Objekt öffnen mit OpenAsTextStream

Der dritte Weg führt über die File-Klasse. Wenn wir bereits ein File-Objekt referenziert haben, können wir dessen Methode OpenAsTextStream aufrufen. Die Parameter sind identisch mit denen von OpenTextFile, allerdings ohne den Dateipfad, da dieser bereits durch das File-Objekt feststeht.

Das folgende Beispiel zeigt, wie wir zunächst ein File-Objekt holen und darauf einen TextStream öffnen:

Public Sub TextdateiPerFileObjekt()
     Dim objFSO As Scripting.FileSystemObject
     Dim objFile As Scripting.File
     Dim objTextstream As Scripting.TextStream
     Dim strPfad As String
     strPfad = CurrentProject.Path _
          & "\Beispiel.txt"
     Set objFSO = New Scripting.FileSystemObject
     Set objFile = objFSO.GetFile(strPfad)
     Set objTextstream = objFile.OpenAsTextStream( _
          ForReading)
     Debug.Print objTextstream.ReadAll
     objTextstream.Close
     Set objTextstream = Nothing
     Set objFile = Nothing
     Set objFSO = Nothing
End Sub

Wir holen zunächst mit GetFile ein File-Objekt und rufen dann dessen OpenAsTextStream-Methode auf. Das Ergebnis ist wiederum ein TextStream-Objekt, das wir wie gewohnt verwenden können.

Dieser Weg bietet sich vor allem an, wenn wir ohnehin bereits mit File-Objekten arbeiten, zum Beispiel beim Durchlaufen der Files-Auflistung eines Verzeichnisses.

Die Eigenschaften der TextStream-Klasse

Die TextStream-Klasse bietet vier Eigenschaften, mit denen wir Informationen über die aktuelle Position innerhalb des Streams abfragen können. Alle vier sind schreibgeschützt.

• AtEndOfLine gibt True 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.
• AtEndOfStream gibt True 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-Funktion, die wir bei den klassischen VBA-Dateioperationen mit Open und Close verwenden.
• Column liefert die aktuelle Spaltenposition innerhalb der Zeile. Die Zählung beginnt bei 1. Nach dem Öffnen einer Datei zum Lesen steht Column auf 1. Nach dem Lesen des ersten Zeichens steht der Wert auf 2 und so weiter.
• Line 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.

Mit Column und Line 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.

Methoden zum Lesen: Read, ReadLine und ReadAll

Die TextStream-Klasse bietet drei Methoden zum Lesen von Inhalten. Alle drei setzen voraus, dass der Stream zum Lesen geöffnet wurde (Modus ForReading).

Read 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:

Public Sub ErsteZeichenLesen()
    ...
    Dim strPfad As String
    Dim strErgebnis As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    strErgebnis = objTextstream.Read(10)
    Debug.Print strErgebnis
    ...
End Sub

ReadLine 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 können wir damit alle Zeilen einer Datei durchlaufen:

Public Sub AlleZeilenLesen()
    ...
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    Do While Not objTextstream.AtEndOfStream
        Debug.Print objTextstream.ReadLine
    Loop
    ...
End Sub

Dies ist das Gegenstück zu der aus den klassischen VBA-Dateioperationen bekannten Kombination aus Line Input # und EOF.

ReadAll 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.

Methoden zum Schreiben: Write, WriteLine und WriteBlankLines

Für das Schreiben stehen ebenfalls drei Methoden bereit. Diese setzen voraus, dass der Stream zum Schreiben (ForWriting) oder zum Anhängen (ForAppending) geöffnet wurde.

Write schreibt eine Zeichenkette in den Stream, ohne einen Zeilenumbruch anzuhängen. Mehrere aufeinanderfolgende Aufrufe von Write erzeugen damit zusammenhängenden Text in derselben Zeile:

Public Sub TextOhneUmbruch()
    ...
    strPfad = CurrentProject.Path & "\WriteTest.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.CreateTextFile(strPfad, True)
    objTextstream.Write "Vorname"
    objTextstream.Write ";"
    objTextstream.Write "Nachname"
    ...
End Sub

Das Ergebnis in der Datei wäre eine einzelne Zeile mit dem Inhalt Vorname;Nachname.

WriteLine funktioniert wie Write, hängt aber automatisch einen Zeilenumbruch an. Jeder Aufruf von WriteLine erzeugt also eine eigene Zeile in der Datei. Rufen wir WriteLine ohne Parameter auf, wird lediglich eine Leerzeile geschrieben.

WriteBlankLines erwartet als Parameter die Anzahl der einzufügenden Leerzeilen. Der folgende Aufruf fügt drei leere Zeilen in die Datei ein:

Public Sub LeerzeilenEinfuegen()
    ...
    strPfad = CurrentProject.Path & "\Leerzeilen.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.CreateTextFile( _
        strPfad, True)
    objTextstream.WriteLine "Abschnitt 1"
    objTextstream.WriteBlankLines 3
    objTextstream.WriteLine "Abschnitt 2"
    ...
End Sub

Diese Methode ist nützlich, wenn wir in einer Ausgabedatei Abschnitte visuell voneinander trennen möchten.

Navigieren im Stream: Skip und SkipLine

Neben den Lese- und Schreibmethoden bietet die TextStream-Klasse zwei Methoden, mit denen wir Inhalte beim Lesen überspringen können, ohne diese in eine Variable einzulesen.

Skip erwartet als Parameter die Anzahl der zu überspringenden Zeichen. Die Leseposition wird um die angegebene Anzahl Zeichen vorgerückt:

Public Sub ZeichenUeberspringen()
    ...
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    objTextstream.Skip 5
    Debug.Print objTextstream.ReadLine
    ...
End Sub

SkipLine überspringt die aktuelle Zeile vollständig, einschließlich des Zeilenumbruchs. Die Leseposition steht danach am Anfang der nächsten Zeile.

Beide Methoden funktionieren nur bei Streams, die zum Lesen geöffnet wurden. Ein typischer Anwendungsfall für SkipLine ist das Überspringen einer Kopfzeile beim Einlesen von CSV-Dateien.

Statt die erste Zeile mit ReadLine in eine Variable zu lesen, die wir anschließend gar nicht benötigen, überspringen wir sie einfach.

Public Sub TextdateiErstellen()
    Dim objFSO As Scripting.FileSystemObject
    Dim objTextstream As Scripting.TextStream
    Dim strPfad As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.CreateTextFile(strPfad, True)
    objTextstream.WriteLine "Erste Zeile"
    objTextstream.WriteLine "Zweite Zeile"
    objTextstream.WriteLine "Dritte Zeile"
    objTextstream.Close
    Set objTextstream = Nothing
    Set objFSO = Nothing
End Sub

Public Sub TextdateiLesen()
    Dim objFSO As Scripting.FileSystemObject
    Dim objTextstream As Scripting.TextStream
    Dim strPfad As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.OpenTextFile(strPfad, _
        ForReading)
    Debug.Print objTextstream.ReadAll
    objTextstream.Close
    Set objTextstream = Nothing
    Set objFSO = Nothing
End Sub

Public Sub TextdateiPerFileObjekt()
     Dim objFSO As Scripting.FileSystemObject
     Dim objFile As Scripting.File
     Dim objTextstream As Scripting.TextStream
     Dim strPfad As String
     strPfad = CurrentProject.Path _
          & "\Beispiel.txt"
     Set objFSO = New Scripting.FileSystemObject
     Set objFile = objFSO.GetFile(strPfad)
     Set objTextstream = objFile.OpenAsTextStream( _
          ForReading)
     Debug.Print objTextstream.ReadAll
     objTextstream.Close
     Set objTextstream = Nothing
     Set objFile = Nothing
     Set objFSO = Nothing
End Sub

Public Sub ErsteZeichenLesen()
    ...
    Dim strPfad As String
    Dim strErgebnis As String
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    strErgebnis = objTextstream.Read(10)
    Debug.Print strErgebnis
    ...
End Sub

Public Sub AlleZeilenLesen()
    ...
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    Do While Not objTextstream.AtEndOfStream
        Debug.Print objTextstream.ReadLine
    Loop
    ...
End Sub

Public Sub TextOhneUmbruch()
    ...
    strPfad = CurrentProject.Path & "\WriteTest.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.CreateTextFile(strPfad, True)
    objTextstream.Write "Vorname"
    objTextstream.Write ";"
    objTextstream.Write "Nachname"
    ...
End Sub

Public Sub LeerzeilenEinfuegen()
    ...
    strPfad = CurrentProject.Path & "\Leerzeilen.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = objFSO.CreateTextFile( _
        strPfad, True)
    objTextstream.WriteLine "Abschnitt 1"
    objTextstream.WriteBlankLines 3
    objTextstream.WriteLine "Abschnitt 2"
    ...
End Sub

Public Sub ZeichenUeberspringen()
    ...
    strPfad = CurrentProject.Path & "\Beispiel.txt"
    Set objFSO = New Scripting.FileSystemObject
    Set objTextstream = _
        objFSO.OpenTextFile(strPfad, ForReading)
    objTextstream.Skip 5
    Debug.Print objTextstream.ReadLine
    ...
End Sub

Oder hast Du eine konkrete Frage zu Deiner eigenen Access-Anwendung?

Vielleicht stellt Deine Anwendung Dich vor eine Herausforderung, zu der Du bisher keine Lösung findest. Schlechte Performance, kein ausreichender Zugriffsschutz, Du bist unsicher über Dein Datenmodell oder Dein Code liefert unerklärliche Fehler?

In unserem kostenlosen Access-Audit schaut sich André Minhorst persönlich gemeinsam mit Dir Deine Lösung per Zoom an – und zeigt Dir, wo Datenmodell, VBA-Code, Ergonomie und Sicherheit Optimierungspotenzial bieten.