{"id":55000794,"date":"2011-10-01T00:00:00","date_gmt":"2020-05-22T21:57:43","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=794"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Dateisystem_im_Griff_mit_dem_FileSystemObject","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Dateisystem_im_Griff_mit_dem_FileSystemObject\/","title":{"rendered":"Dateisystem im Griff mit dem FileSystemObject"},"content":{"rendered":"

\"\"<\/p>\n

Für viele Fälle reichen die in VBA integrierten Befehle wie Dir, MkDir, Kill oder Copy aus. Manchmal stoßen Sie damit aber an die Grenzen der VBA-Bibliothek. In diesem Fall hilft möglicherweise das FileSystemObject weiter. Es bietet umfangreiche Möglichkeiten, auf Laufwerke, Verzeichnisse und Dateien zuzugreifen. Dieser Beitrag zeigt, wie Sie das FileSystemObject verfügbar machen und welche interessanten Aktionen Sie damit durchführen können.<\/b><\/p>\n

Das FileSystemObject <\/b>ist Bestandteil der Bibliothek Microsoft Scripting Runtime, die Sie zur einfacheren Programmierung per IntelliSense per Verweis einbinden (s. Bild 1). Den Verweise<\/b>-Dialog öffnen Sie über den Menübefehl Extras|Verweise <\/b>des VBA-Editors.<\/p>\n

\"pic001.png\"<\/p>\n

Bild 1: Verweis auf die Microsoft Scripting Runtime<\/span><\/b><\/p>\n

Objekte<\/b><\/p>\n

Das Objekt FileSystemObject <\/b>ist das Hauptobjekt für den Zugriff auf Laufwerke, Verzeichnisse und Dateien. Wenn Sie auf eines dieser Objekte zugreifen möchten, benötigen Sie meist eine der Methoden des FileSystemObjects<\/b>. Um das FileSystemObject <\/b>zu nutzen, deklarieren und instanzieren Sie es zuvor:<\/p>\n

Dim objFSO As Scripting.FileSystemObject\r\nSet objFSO = New Scripting.FileSystemObject<\/pre>\n
Danach greifen Sie per IntelliSense bequem auf seine Eigenschaften und Methoden zu.<\/p>\n
Existenz von Laufwerken, Verzeichnissen und Dateien prüfen<\/b><\/p>\n
In vielen Fällen werden Sie vor einer Aktion mit dem jeweiligen Objekt prüfen, ob dieses überhaupt existiert. <\/p>\n
Beim Laufwerk liefert die Funktion DriveExists <\/b>die notwendige Information. Das folgende Beispiel zeigt für einen modernen Rechner, dass es zwar ein Laufwerk mit dem Buchstaben c <\/b>gibt, aber keines mit dem Buchstaben a<\/b>:<\/p>\n
Dim objFSO As Scripting.FileSystemObject\r\nSet objFSO = New Scripting.FileSystemObject\r\nDebug.Print objFSO.DriveExists("a")\r\nDebug.Print objFSO.DriveExists("c")<\/pre>\n
Bei Verzeichnissen ist die Funktion FolderExists<\/b> für die Prüfung der Existenz verantwortlich. Die folgenden Zeilen belegen, dass das Verzeichnis, in dem sich die aktuelle Datenbank befindet, tatsächlich vorhanden ist:<\/p>\n
Debug.Print objFSO.FolderExists(CurrentProject.Path)<\/pre>\n
ähnlich sieht es bei den Dateien aus – hier muss die Funktion FileExists <\/b>Ihren Dienst verrichten. Die folgende Zeile liefert hoffentlich den Wert True <\/b>zurück:<\/p>\n
Debug.Print objFSO.FileExists(CurrentDb.Name)<\/pre>\n
Laufwerke<\/b><\/p>\n
Auf die Laufwerke können Sie direkt mithilfe der Auflistung Drives <\/b>des FileSystemObject<\/b>-Objekts zugreifen. Die Anzahl der Laufwerke ermitteln Sie mit der Eigenschaft Drives.Count<\/b>.<\/p>\n
Den Zugriff auf die einzelnen Laufwerk-Objekte über die Item<\/b>-Eigenschaft erhalten Sie nur durch Angabe des Laufwerkbuchstabens:<\/p>\n
With objFSO\r\n    Debug.Print "Laufwerke: ", .Drives.Count\r\n    Debug.Print .Drives.Item("c").VolumeName\r\nEnd With<\/pre>\n
Wenn Sie alle Laufwerke samt Laufwerksbuchstabe und weiteren Informationen ermitteln möchten, greifen Sie per For Each<\/b>-Schleife darauf zu.<\/p>\n
Beispiele für den Zugriff auf die Elemente der Drives<\/b>-Auflistung haben wir im Formular frmLaufwerke <\/b>und dessen Klassenmodul untergebracht.<\/p>\n
Als erstes soll das Kombinationsfeld mit dem Laufwerksbuchstaben in der gebundenen, unsichtbaren Spalte und dem Pfad als sichtbarem Eintrag gefüllt werden.<\/p>\n
Dies erledigt die folgende Prozedur, die zunächst in einer For Each<\/b>-Schleife alle Laufwerke des aktuellen Systems durchläuft. Dabei trägt Sie die für die Anzeige im Kombinationsfeld nötigen Daten zusammen. Das Ergebnis sieht etwa so aus:<\/p>\n
C;C:;D;D:;E;E:;F;F:;G;G:;<\/pre>\n
Es wird also für jedes Laufwerk zunächst der einzelne Buchstabe und dann der Pfad ausgegeben. Da das Kombinationsfeld den Wert Wertliste <\/b>für die Eigenschaft Herkunftsart <\/b>sowie die Werte 2 <\/b>und 0cm <\/b>für die Eigenschaften Spaltenanzahl<\/b> und Spaltenbreiten<\/b> enthält, zeigt es genau die Pfade an (s. Bild 2).<\/p>\n
\"pic002.png\"<\/p>\n
Bild 2: Formular zur Anzeige von Laufwerksdaten<\/span><\/b><\/p>\n
Der erste Eintrag wird gleich beim Laden des Formulars ausgewählt und die Prozedur DatenLesen <\/b>ausgeführt, die das Formular mit weiteren Laufwerkseigenschaften füllt (s. Listing 1<\/a><\/span>).<\/p>\n
Listing 1: Einlesen von Informationen über das aktuell ausgewählte Laufwerk<\/p>\n
Private Sub Form_Load()\r\n    Dim objDrive As Scripting.Drive\r\n    Dim strDrives As String\r\n    Set objFSO = New Scripting.FileSystemObject\r\n    For Each objDrive In objFSO.Drives\r\n        With objDrive\r\n            strDrives = strDrives & objDrive.DriveLetter & ";" & objDrive.Path & ";"\r\n        End With\r\n    Next objDrive\r\n    Me!cboLaufwerke.RowSource = strDrives\r\n    Me!cboLaufwerke = Me!cboLaufwerke.ItemData(0)\r\n    DatenLesen\r\nEnd Sub<\/pre>\n
Die Prozedur DatenLesen <\/b>wird nicht nur beim Laden, sondern auch nach dem Auswählen eines anderen Eintrags im Kombinationsfeld cboLaufwerke <\/b>aufgerufen. Sie füllt die Textfelder des Formulars mit weiteren Informationen, die allesamt das jeweilige Drive<\/b>-Objekt bereitstellt (s. Listing 2<\/a><\/span>).<\/p>\n
Listing 2: Einlesen von Informationen über das aktuell ausgewählte Laufwerk<\/p>\n
Private Sub DatenLesen()\r\n    Dim objDrive As Scripting.Drive\r\n    Set objDrive = objFSO.Drives(Me!cboLaufwerke)\r\n    With objDrive\r\n        Me!txtDriveletter = .DriveLetter\r\n        Me!txtDriveType = .DriveType\r\n        Me!txtPath = .Path\r\n        Me!txtShareName = .ShareName\r\n        If .IsReady Then\r\n            Me!txtFileSystem = .FileSystem\r\n            Me!txtFreeSpace = .FreeSpace\r\n            Me!txtRootFolder = .RootFolder\r\n            Me!txtSerialNumber = .SerialNumber\r\n            Me!txtTotalSize = .TotalSize\r\n            Me!txtVolumename = .VolumeName\r\n        Else\r\n            MsgBox "Laufwerk ''" & Me!cboLaufwerke.Column(1) & "'' nicht bereit."\r\n            Me!txtFileSystem = Null\r\n            Me!txtFreeSpace = Null\r\n            Me!txtRootFolder = Null\r\n            Me!txtSerialNumber = Null\r\n            Me!txtTotalSize = Null\r\n            Me!txtVolumename = Null\r\n        End If\r\n    End With\r\nEnd Sub<\/pre>\n
Sollte das jeweilige Laufwerk nicht bereit sein, was beispielsweise bei CD- oder DVD-Laufwerken geschieht, die gerade keinen Datenträger enthalten, erscheint eine Meldung und es werden entsprechend weniger Informationen im Formular angezeigt. Diesen Zustand fragen Sie übrigens mit der Eigenschaft IsReady <\/b>ab.<\/p>\n
Verzeichnisse lesen<\/b><\/p>\n
Prinzipiell ist c:\\ <\/b>auch ein Verzeichnis, zumindest wenn man der Nomenklatur des Objektmodells unterhalt des FileSystemObject<\/b>-Objekts glaubt. Die Eigenschaft RootFolder <\/b>liefert nämlich genau diese Information. Allerdings tut sie das nur, weil RootFolder <\/b>ein eigenes Objekt mit der Eigenschaft Name <\/b>als Standardeigenschaft ist. Mit der Eigenschaft RootFolder <\/b>können Sie also auch ein Objekt des Typs Folder <\/b>referenzieren – und zwar zum Beispiel c:\\<\/b>.<\/p>\n
Unterhalb eines Laufwerks gibt es in der Regel einen oder mehrere Verzeichnisse. Auf diese greifen Sie über die Folders<\/b>-Auflistung des Drive<\/b>-Objekts zu.<\/p>\n
Wenn Sie zuvor das RootFolder<\/b>-Objekt eines Verzeichnisses ermitteln, in diesem Fall c:<\/b>, greifen Sie wie folgt auf die unterhalb von c:\\ <\/b>liegenden Verzeichnisse zu und geben diese im Direktfenster aus (s. Listing 3<\/a><\/span>).<\/p>\n
Listing 3: Verzeichnisse eines Laufwerks ausgeben<\/p>\n
Public Sub Verzeichnisse()\r\n    Dim objFSO As Scripting.FileSystemObject\r\n    Dim objDrive As Scripting.Drive\r\n    Dim objRootFolder As Scripting.Folder\r\n    Dim objFolder As Scripting.Folder\r\n    Set objFSO = New Scripting.FileSystemObject\r\n    Set objDrive = objFSO.Drives("c")\r\n    Set objRootFolder = objDrive.RootFolder\r\n    For Each objFolder In objRootFolder.SubFolders\r\n         Debug.Print objFolder.path\r\n    Next objFolder\r\nEnd Sub<\/pre>\n
<\/p>\n
Wenn Sie der For Each<\/b>-Schleife dieser Prozedur noch die Anweisung <\/p>\n
VerzeichnisseRek objFolder<\/pre>\n
hinzufügen und die folgende Prozedur erstellen, geben beide Prozeduren rekursiv alle Verzeichnisse des Laufwerks aus (s. Listing 4<\/a><\/span>).<\/p>\n
Listing 4: Verzeichnisse eines Laufwerks rekursiv ausgeben<\/p>\n
Public Sub VerzeichnisseRek(objParentFolder As Scripting.Folder)\r\n    Dim objFolder As Scripting.Folder\r\n    For Each objFolder In objParentFolder.SubFolders\r\n         Debug.Print objFolder.path\r\n        VerzeichnisseRek objFolder\r\n    Next objFolder\r\nEnd Sub<\/pre>\n
Sollten Sie dies mit Laufwerk c: <\/b>ausprobieren, merken Sie sich schonmal die Tastenkombination Strg + Rollen <\/b>zum Abbrechen des Vorgangs vor – dieser kann nämlich eine Weile dauern.<\/p>\n
Normalerweise tritt auch schnell ein Fehler auf, und zwar beim Versuch, Elemente spezieller Verzeichnisse wie etwa Systemverzeichnisse einzulesen.<\/p>\n
Ob ein Verzeichnis ein Systemverzeichnis ist, finden Sie mit der Eigenschaft Attributes<\/b> heraus. Dieses enthält einen Zahlenwert, der sich aus den Zahlenwerten verschiedener Konstanten zusammensetzt. In diesem Fall lautete der Wert der Eigenschaft Attributes 22<\/b>.<\/p>\n
Dieser Wert enthält die Werte 16 <\/b>(Directory<\/b>), 4 <\/b>(System<\/b>) und 2 <\/b>(Hidden<\/b>). System <\/b>und Hidden <\/b>– das ist kein Verzeichnis, dessen Inhalt wohl nur von System-Instanzen gelesen werden sollte.<\/p>\n
Solche Informationen erhalten Sie übrigens im Objektkatalog des VBA-Editors (s. Bild 3).<\/p>\n
\"pic003.png\"<\/p>\n
Bild 3: Konstanten des FileSystemObject-Objekts im Objektkatalog des VBA-Editors<\/span><\/b><\/p>\n
Dateien lesen<\/b><\/p>\n
Jedes Folder<\/b>-Objekt hat eine Files<\/b>-Auflistung, mit der Sie auf die im jeweiligen Verzeichnis gespeicherten Dateien zugreifen können.<\/p>\n
Für das Rootverzeichnis c:\\ <\/b>gelingt dies beispielsweise mit der Prozedur aus Listing 5<\/a><\/span>.<\/p>\n
Listing 5: Auflisten aller Dateien eines Verzeichnisses<\/p>\n
Public Sub Dateien()\r\n    Dim objFSO As Scripting.FileSystemObject\r\n    Dim objFolder As Scripting.Folder\r\n    Dim objFile As Scripting.File\r\n    Set objFSO = New Scripting.FileSystemObject\r\n    Set objFolder = objFSO.Drives("c").RootFolder\r\n    For Each objFile In objFolder.Files\r\n         Debug.Print objFile.Name\r\n    Next objFile\r\nEnd Sub<\/pre>\n
Dateiinformationen anzeigen<\/b><\/p>\n
Wenn Sie eine Datei referenziert haben, greifen Sie leicht auf die Informationen dieser Datei zu. Das Formular frmAktuelleDatenbankdatei <\/b>(s. Bild 4<\/a><\/span>) zeigt beispielsweise die Daten zur aktuell geöffneten Datenbankdatei an. Dazu ist der Aufruf der Prozedur aus Listing 6  beim Laden des Formulars nötig.<\/p>\n
Listing 6: Einlesen von Informationen zur aktuellen Access-Datei<\/p>\n
Private Sub Form_Load()\r\n    Dim objFSO As Scripting.FileSystemObject\r\n    Dim objFile As Scripting.File\r\n    Set objFSO = New Scripting.FileSystemObject\r\n    Set objFile = objFSO.GetFile(CurrentDb.Name)\r\n    With objFile\r\n        Me!txtAttributes = .Attributes\r\n        Me!txtDateCreated = .DateCreated\r\n        Me!txtDateLastAccessed = .DateLastAccessed\r\n        Me!txtDateLastModified = .DateLastModified\r\n        Me!txtDrive = .Drive\r\n        Me!txtName = .Name\r\n        Me!txtParentFolder = .ParentFolder\r\n        Me!txtPath = .Path\r\n        Me!txtShortName = .ShortName\r\n        Me!txtShortPath = .ShortPath\r\n        Me!txtSize = .Size\r\n        Me!txtType = .Type\r\n    End With\r\nEnd Sub<\/pre>\n
\"pic004.png\"<\/p>\n
Bild 4: Dieses Formular liefert einige Informationen über eine Datei.<\/span><\/b><\/p>\n
Weitere Informationen über Dateien erhalten<\/b><\/p>\n
In vielen Fällen ist die Kenntnis des reinen Dateinamens und der Dateiendung interessant. Diese erfahren Sie mit dem FileSystemObject <\/b>über die Funktionen GetBaseName <\/b>und GetExtensionName<\/b>, in folgendem Beispiel etwa für die aktuelle Datenbankdatei:<\/p>\n
Dim objFSO As Scripting.FileSystemObject\r\nSet objFSO = New Scripting.FileSystemObject\r\nDebug.Print objFSO.GetBaseName(CurrentDb.Name)\r\nDebug.Print objFSO.GetExtensionName(CurrentDb.Name)<\/pre>\n
Operationen mit Dateien und Verzeichnissen<\/b><\/p>\n
Verzeichnisse können Sie mit den Methoden Copy<\/b>, Delete <\/b>und Move <\/b>des Folder<\/b>-Objekts kopieren, löschen und verschieben. Gleiches gilt für das File<\/b>-Objekt. Vom Folder<\/b>-Objekt aus kann man außerdem ein Textstream<\/b>-Objekt erzeugen, ein File<\/b>-Objekt als Textstream<\/b>-Objekt öffnen – zum Textstream<\/b>-Objekt später mehr. Neue Verzeichnisse erstellen Sie mit der Add<\/b>-Methode des Folders<\/b>-Objekts. Wie dies alles funktioniert, zeigen die folgenden Abschnitte.<\/p>\n
Verzeichnisse und Dateien referenzieren<\/b><\/p>\n
Verschiedene der nachfolgend vorgestellten Techniken verwenden eine Objektvariable, die entweder auf ein Verzeichnis oder auf eine Datei im Dateisystem verweisen und die verschiedene Methoden etwa zum Erstellen, Kopieren, Verschieben oder Löschen von Verzeichnissen und Dateien bereitstellen.<\/p>\n
Wenn Sie ein vorhandenes Verzeichnis referenzieren möchten, gelingt das etwa mit der Funktion GetFolder<\/b>. Folgende Beispielroutine gibt den Pfad zur aktuellen Datenbank aus:<\/p>\n
Dim objFSO As Scripting.FileSystemObject\r\nDim objFolder As Scripting.Folder\r\nSet objFSO = New Scripting.FileSystemObject\r\nSet objFolder = objFSO.GetFolder(CurrentProject.Path)\r\nDebug.Print objFolder.Path<\/pre>\n
Um eine Datei zu referenzieren, geben Sie deren Namen als Parameter der Funktion GetFile <\/b>an:<\/p>\n
Dim objFSO As Scripting.FileSystemObject\r\nDim objFile As Scripting.File\r\nSet objFSO = New Scripting.FileSystemObject\r\nSet objFile = objFSO.GetFile(CurrentProject.Path & "\\Text.txt")\r\nDebug.Print objFile.Path<\/pre>\n
Verzeichnisse erstellen<\/b><\/p>\n
Zum Erstellen von Verzeichnissen bietet das FileSystemObject<\/b>-Objekt zwei Möglichkeiten. Die eine ist eine Methode dieses Objekts selbst: CreateFolder<\/b>. Die zweite ist die Add<\/b>-Methode der Auflistung SubFolders <\/b>eines Folder<\/b>-Objekts.<\/p>\n
Beide Objekte erlauben nur das Anlegen jeweils eines Verzeichnisses, Sie können als nicht in einem Schritt mehrere Verzeichnisse gleichzeitig anlegen.<\/p>\n
Wenn Sie etwa ein Verzeichnis c:\\test <\/b>haben, können Sie nicht direkt c:\\test\\test1\\test2 <\/b>anlegen, sondern müssen erst c:\\test\\test1 <\/b>erstellen.<\/p>\n
Das ist ein guter Anlass, eine kleine Hilfsfunktion rund um die Methode CreateFolder <\/b>zu erstellen. Diese heißt VerzeichnisErstellen<\/b> und ist in Listing 7<\/a><\/span> zu finden. Dieser Prozedur können Sie gleich einen Verzeichnisnamen übergeben, der eigentlich das Anlegen zweier oder mehrerer Verzeichnisse erfordern würde. Die Prozedur ergänzt zunächst den angegebenen Pfad um ein Backslash-Zeichen (\\<\/b>), wenn dieser nicht bereits mit diesem Zeichen endet. Dann wird eine Do…Loop Until<\/b>-Schleife solange durchlaufen, bis alle Unterverzeichnisse angelegt wurden.<\/p>\n
Listing 7: Erstellen eines Verzeichnisses<\/p>\n
Public Sub VerzeichnisErstellen(strVerzeichnis As String)\r\n    Dim objFSO As Scripting.FileSystemObject\r\n    Dim intPosition As Integer\r\n    Set objFSO = New Scripting.FileSystemObject\r\n    If Not Right(strVerzeichnis, 1) = "\\" Then\r\n         strVerzeichnis = strVerzeichnis & "\\"\r\n    End If\r\n    Do\r\n     On Error Resume Next\r\n        objFSO.CreateFolder Mid(strVerzeichnis, 1, intPosition - 1)\r\n        On Error GoTo 0\r\n        intPosition = InStr(intPosition + 1, strVerzeichnis, "\\")\r\n     Loop Until intPosition = 0\r\nEnd Sub<\/pre>\n
Die Prozedur könnte hier von vorne aus für jedes Unterverzeichnis prüfen, ob dieses bereits vorhanden ist, aber wir machen es uns ein wenig einfacher: Die Prozedur soll einfach jedes Unterverzeichnis anlegen.<\/p>\n
Ist eines schon vorhanden, wird der dadurch ausgelöste Fehler 58<\/b> (Datei existiert bereits<\/b>) einfach ignoriert und das nächste Unterverzeichnis angelegt.<\/p>\n
Verzeichnisse kopieren<\/b><\/p>\n
Mit der CopyFolder<\/b>-Methode des FileSystemObject<\/b>-Objekts kopieren Sie den Inhalt von Verzeichnissen. Die Anweisung erwartet drei Parameter:<\/p>\n