{"id":55000478,"date":"2025-08-01T00:00:00","date_gmt":"2025-10-12T10:40:42","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=478"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Dateimanagement_mit_dem_FileSystemObject","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Dateimanagement_mit_dem_FileSystemObject\/","title":{"rendered":"Dateimanagement mit dem FileSystemObject"},"content":{"rendered":"

VBA bietet bereits einige Befehle, mit denen wir Dateioperationen ausführen können. Wir können mit MkDir neue Verzeichnisse erstellen, mit Dir prüfen, ob Dateien oder Verzeichnisse vorhanden sind oder mit Kill Dateien löschen. Diese Befehle sind aber recht kompliziert in der Handhabung. Daher schauen wir uns in diesem Artikel einmal die Klasse “FileSystemObject” an, mit der wir deutlich komfortabler mit Dateien und Verzeichnissen arbeiten können. Damit lässt sich alles erledigen, was mit dem Anlegen, Kopieren, Verschieben und Löschen zusammenhängt – und vieles mehr.<\/b><\/p>\n

Definition<\/h2>\n

Im Rahmen dieses Artikels werden wir folgende Bezeichnungen verwenden:<\/p>\n

Verzeichnis<\/b>: Laufwerksbuchstabe plus Unterverzeichnisse, zum Beispiel c:\\Temp<\/b><\/p>\n

Dateiname<\/b>: Nur der Dateiname ohne Verzeichnisse, also beispielsweise Test.txt<\/b><\/p>\n

Pfad<\/b>: Verzeichnis plus Dateiname, hier also c:\\Temp\\Test.txt<\/b><\/p>\n

Die Klasse FileSystemObject<\/h2>\n

Die Klasse FileSystemObject <\/b>ist Teil der Bibliothek Microsoft Scripting Runtime<\/b>, die wir als Erstes referenzieren müssen.<\/p>\n

Dazu öffnen wir im VBA-Editor den Verweise<\/b>-Dialog und fügen den entsprechenden Eintrag hinzu (siehe Bild 1).<\/p>\n

\"Verweis<\/p>\n

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

Danach können wir den Objektkatalog öffnen und finden alle Elemente der Klasse FileSystemObject <\/b>vor (siehe Bild 2).<\/p>\n

\"Die<\/p>\n

Bild 2: Die Elemente der Klasse FileSystemObject in der Übersicht im Objektkatalog<\/span><\/b><\/p>\n

Hier steigen wir nun ein und schauen uns die verschiedenen Elemente erst einmal in der Übersicht an – später gehen wir detailliert auf jedes einzelne ein:<\/p>\n

    \n
  • BuildPath<\/b>: Stellt aus Verzeichnis und Dateinamen einen Pfad zusammen und ergänzt gegebenenfalls das fehlende Backslash-Zeichen zwischen den beiden Elementen.<\/li>\n
  • CopyFile<\/b>: Kopiert eine Datei.<\/li>\n
  • CopyFolder<\/b>: Kopiert ein Verzeichnis.<\/li>\n
  • CreateFolder<\/b>: Erstellt ein Verzeichnis.<\/li>\n
  • CreateTextFile<\/b>: Erstellt eine Textdatei.<\/li>\n
  • DeleteFile<\/b>: Löscht eine Datei.<\/li>\n
  • DeleteFolder<\/b>: Löscht ein Verzeichnis.<\/li>\n
  • DriveExists<\/b>: Prüft, ob ein Laufwerk vorhanden ist.<\/li>\n
  • Drives<\/b>: Liefert eine Auflistung von Drive<\/b>-Objekten, die Informationen zu den einzelnen Laufwerken liefern.<\/li>\n
  • FileExists<\/b>: Prüft, ob eine Datei vorhanden ist.<\/li>\n
  • FolderExists<\/b>: Prüft, ob ein Verzeichnis vorhanden ist.<\/li>\n
  • GetAbsolutePathname<\/b>: Holt einen absoluten Pfadnamen.<\/li>\n
  • GetBaseName<\/b>: Holt den Basisdateinamen ohne Dateiendung.<\/li>\n
  • GetDrive<\/b>: Ermittelt ein Drive<\/b>-Objekte auf Basis eines Laufwerksbuchstabens, des Laufwerksverzeichnisses oder des Rootverzeichnisses.<\/li>\n
  • GetDriveName<\/b>: Ermittelt das Verzeichnis eines Laufwerkes auf Basis eines Verzeichnisses, das auch Unterordner enthalten kann.<\/li>\n
  • GetExtensionName<\/b>: Holt die Dateinamenerweiterung.<\/li>\n
  • GetFile<\/b>: Holt ein File<\/b>-Objekt.<\/li>\n
  • GetFileName<\/b>: Ermittelt einen Dateinamen.<\/li>\n
  • GetFileVersion<\/b>: Ermittelt die Version einer Datei.<\/li>\n
  • GetFolder<\/b>: Holt ein Folder<\/b>-Objekt.<\/li>\n
  • GetParentFolderName<\/b>: Ermittelt das übergeordnete Verzeichnis.<\/li>\n
  • GetSpecialFolder<\/b>: Ermittelt ein Folder<\/b>-Objekt zu einem Spezialverzeichnis.<\/li>\n
  • GetStandardStream<\/b>: Liefert ein Stream-Objekt auf Basis einer Datei.<\/li>\n
  • GetTempName<\/b>: Liefert einen zufälligen temporären Dateinamen.<\/li>\n
  • MoveFile<\/b>: Verschiebt eine Datei.<\/li>\n
  • MoveFolder<\/b>: Verschiebt ein Verzeichnis.<\/li>\n
  • OpenTextFile<\/b>: Öffnet eine Textdatei.<\/li>\n<\/ul>\n

    Die Klasse FileSystemObject nutzen<\/h2>\n

    Um die Elemente der Klasse FileSystemObjekt <\/b>zu nutzen, müssen wir zunächst ein Objekt auf Basis dieser Klasse erstellen.<\/p>\n

    Das erledigen wir bei Early Binding, also mit vorhandenem Verweis auf die Bibliothek Microsoft Scripting Runtime<\/b>, wie folgt:<\/p>\n

    Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\nSet<\/span> fso = New<\/span> Scripting.FileSystemObject<\/pre>\n
    Wenn wir Late Binding nutzen, also ohne Verweis arbeiten wollen, nutzen wir:<\/p>\n
    Dim <\/span>fso As Object<\/span>\r\nSet<\/span> fso = CreateObject(\"Scripting.FileSystemObject\")<\/pre>\n
    Der Vorteil von Early Binding liegt darin, dass wir während der Entwicklung die Funktionen von IntelliSense nutzen können.<\/p>\n
    Wir nutzen hier eine Objektvariable mit der Bezeichnung fso<\/b>. Man könnte auch beispielsweise objFileSystemObject <\/b>nutzen, damit man direkt weiß, welche Klasse damit referenziert wird.<\/p>\n
    Wir verwenden hier aus Platzgründen die kürzere Variante (eine Alternative ist objFSO<\/b>).<\/p>\n
    Laufwerksinformationen ermitteln mit Drive<\/h2>\n
    Die Drives<\/b>-Auflistung liefert uns Informationen über die verschiedenen Laufwerke. Wir können folgende Informationen erhalten:<\/p>\n
      \n
    • AvailableSpace<\/b>: Liefert den freien Speicherplatz in Bytes.<\/li>\n
    • DriveLetter<\/b>: Liefert nur den Laufwerksbuchstaben, also beispielsweise c<\/b>.<\/li>\n
    • DriveType<\/b>: Liefert den Typ des Laufwerks als Zahlenwert mit den möglichen Werten 0 (Unknown Type<\/b>), 1 <\/b>(Removable<\/b>), 2 <\/b>(Fixed<\/b>), 3 <\/b>(Remote<\/b>), 4 <\/b>(CDRom<\/b>) oder 5 <\/b>(RamDisk<\/b>).<\/li>\n
    • FileSystem<\/b>: Liefert beispielsweise den Wert FAT32 <\/b>oder NTFS<\/b>.<\/li>\n
    • FreeSpace<\/b>: Liefert den freien Speicherplatz für den aktuellen Benutzer. Dieser kann identisch sein mit dem Wert von AvailableSpace<\/b>.<\/li>\n
    • IsReady<\/b>: Gibt an, ob das Laufwerk verfügbar ist.<\/li>\n
    • Path<\/b>: Gibt den Laufwerkbuchstaben gefolgt von einem Doppelpunkt an, zum Beispiel c:<\/b>.<\/li>\n
    • RootFolder<\/b>: Gibt den Laufwerkbuchstaben gefolgt von einem Doppelpunkt und einem Backslash an, zum Beispiel c:\\<\/b>.<\/li>\n
    • SerialNumber<\/b>: Gibt die Seriennummer des Laufwerks an.<\/li>\n
    • ShareName<\/b>: Liefert den Namen der Windows-Freigabe, wenn das Laufwerk ein Netzlaufwerk ist. Anderenfalls liefert es eine leere Zeichenkette.<\/li>\n
    • TotalSize<\/b>: Gibt den gesamten Speicherplatz des Laufwerks in Bytes zurück.<\/li>\n
    • VolumeName<\/b>: Beschriftung des Laufwerks, wie er im Windows Explorer angezeigt wird.<\/li>\n<\/ul>\n
      Mit der Prozedur aus Listing 1 geben wir alle Informationen aller Laufwerke aus, indem wir diese in einer For Each<\/b>-Schleife über die Drives<\/b>-Auflistung durchlaufen. Dabei weisen wir die einzelnen Elemente einer Objektvariablen namens objDrive <\/b>mit dem Typ FileSystemObject.Drive <\/b>zu.<\/p>\n
      Public Sub <\/span>LaufwerksbuchstabenErmitteln()\r\n     Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\n     Dim <\/span>objDrive As <\/span>Scripting.Drive\r\n     Set<\/span> fso = New<\/span> Scripting.FileSystemObject\r\n     \r\n     For Each objDrive In fso.Drives\r\n         Debug.Print<\/span> \"AvailbableSpace: \" & objDrive.AvailableSpace\r\n         Debug.Print<\/span> \"DriveLetter:\" & objDrive.DriveLetter\r\n         Debug.Print<\/span> \"DriveType:\" & objDrive.DriveType\r\n         Debug.Print<\/span> \"FileSystem:\" & objDrive.FileSystem\r\n         Debug.Print<\/span> \"FreeSpace:\" & objDrive.FreeSpace\r\n         Debug.Print<\/span> \"IsReady:\" & objDrive.IsReady\r\n         Debug.Print<\/span> \"Path:\" & objDrive.Path\r\n         Debug.Print<\/span> \"RootFolder:\" & objDrive.RootFolder\r\n         Debug.Print<\/span> \"SerialNumber:\" & objDrive.SerialNumber\r\n         Debug.Print<\/span> \"ShareName:\" & objDrive.ShareName\r\n         Debug.Print<\/span> \"TotalSize:\" & objDrive.TotalSize\r\n         Debug.Print<\/span> \"VolumeName:\" & objDrive.VolumeName\r\n     Next<\/span> objDrive\r\nEnd Sub<\/span><\/pre>\n
      Listing 1: Prozedur zur Ausgabe von Laufwerksinformationen im Direktbereich<\/span><\/b><\/p>\n
      Für das Laufwerk C:\\<\/b> erhalten wir beispielsweise folgende Ausgabe im Direktbereich:<\/p>\n
      AvailbableSpace: 207972556800\r\nDriveLetter:C\r\nDriveType:2\r\nFileSystem:NTFS\r\nFreeSpace:207972556800\r\nIsReady:Wahr\r\nPath:C:\r\nRootFolder:C:\\\r\nSerialNumber:-966946150\r\nShareName:\r\nTotalSize:1999516987392\r\nVolumeName:Hauptlaufwerk<\/pre>\n
      Laufwerk referenzieren mit GetDrive<\/h2>\n
      Mit der Funktion GetDrive<\/b> können wir ein Drive<\/b>-Objekt zu einem Ausdruck wie c<\/b>, c: <\/b>oder c:\\ <\/b>ermitteln.<\/p>\n
      Im folgenden Beispiel deklarieren wir eine Drive<\/b>-Variable namens objDrive <\/b>und weisen ihr das Ergebnis der GetDrive<\/b>-Funktion für c:\\ <\/b>zu.<\/p>\n
      Danach geben wir den verfügbaren Speicherplatz dieses Laufwerks aus:<\/p>\n
      Public Sub <\/span>LaufwerkReferenzieren()\r\n     Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\n     Dim <\/span>objDrive As <\/span>Scripting.Drive\r\n     Set<\/span> fso = New<\/span> Scripting.FileSystemObject\r\n     Set<\/span> objDrive = fso.GetDrive(\"c:\\\")\r\n     Debug.Print<\/span> objDrive.AvailableSpace\r\nEnd Sub<\/span><\/pre>\n
      Die Standardeigenschaft der Drive<\/b>-Klasse ist die Eigenschaft Path<\/b>. <\/p>\n
      Wir können c: <\/b>also auch einfach so ausgeben lassen:<\/p>\n
      Debug.Print<\/span> objDrive<\/pre>\n
      Name eines Laufwerks ermitteln mit GetDriveName<\/h2>\n
      Mit der Funktion GetDriveName <\/b>können wir den Namen eines Laufwerks für einen beliebigen Pfad ermitteln.<\/p>\n
      Wenn wir also etwas das Laufwerk benötigen, auf dem sich die aktuelle Datenbankdatei befindet, nutzen wir die folgenden Anweisungen (siehe Funktion LaufwerkNameErmitteln<\/b>), der wir CurrentProject.Path <\/b>als Parameter übergeben:<\/p>\n
      Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\nDim <\/span>objDrive As <\/span>Scripting.Drive\r\nSet<\/span> fso = New<\/span> Scripting.FileSystemObject\r\nDebug.Print<\/span> fso.GetDriveName(CurrentProject.Path)<\/pre>\n
      Mit DriveExists prüfen, ob ein Laufwerk existiert<\/h2>\n
      Die Funktion DriveExists <\/b>prüft, ob ein Laufwerk existiert. Dazu können wir den Laufwerksbuchstaben (c<\/b>), das Verzeichnis (c:<\/b>) oder das Rootverzeichnis (c:\\<\/b>) übergeben. Für das Laufwerk d: <\/b>liefert die folgende Prozedur beispielsweise den Wert False<\/b>, wenn kein entsprechendes Laufwerk vorhanden ist:<\/p>\n
      Dim <\/span>fso As <\/span>Scripting.FileSystemObject\r\nDim <\/span>objDrive As <\/span>Scripting.Drive\r\nSet<\/span> fso = New<\/span> Scripting.FileSystemObject\r\nDebug.Print<\/span> fso.DriveExists(\"d:\\\")<\/pre>\n
      Mit Verzeichnissen arbeiten<\/h2>\n
      Nachdem wir die Funktionen für die Laufwerke erledigt haben, kommen wir zu den Funktionen für den Umgang mit Verzeichnissen. Hier können wir Verzeichnisse erstellen, prüfen, ob ein Verzeichnis existiert, Verzeichnisse löschen, kopieren oder verschieben, Eigenschaften von Verzeichnissen auslesen und übergeordnete Verzeichnisse oder Spezialverzeichnisse ermitteln.<\/p>\n
      Verzeichnisse erstellen mit CreateFolder<\/h2>\n
      Mit der Methode CreateFolder <\/b>können wir ein Verzeichnis erstellen. Dazu geben wir einfach den kompletten Pfad zum Verzeichnis an, zum Beispiel c:\\Temp\\Ordner 1<\/b>:<\/p>\n
      fso.CreateFolder \"c:\\Temp\\Ordner 1\"<\/pre>\n
      Wenn wir versuchen, einen Ordner zu erstellen, der bereits vorhanden ist, erhalten wir Fehler 58<\/b>, Datei existiert bereits<\/b>. Um dies zu verhindern, können wir mit FolderExists <\/b>vorab prüfen, ob das Verzeichnis bereits vorhanden ist (siehe weiter unten).<\/p>\n
      Wir können mit CreateFolder <\/b>immer nur ein Verzeichnis gleichzeitig erstellen. Um c:\\Temp\\Ordner 1\\Ordner 2 <\/b>zu erstellen, benötigen wir zwei Anweisungen:<\/p>\n
      fso.CreateFolder \"c:\\Temp\\Ordner 1\"\r\nfso.CreateFolder \"c:\\Temp\\Ordner 1\\Ordner 2\"<\/pre>\n
      Wir können auch das Ergebnis von CreateFolder <\/b>mit einer Folder<\/b>-Variablen referenzieren, um dann die Operationen der Folder<\/b>-Klasse auszuführen – mehr dazu weiter unten (dort finden wir eine weitere Methode zum Anlegen von Verzeichnissen):<\/p>\n
      Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nSet<\/span> objFolder = fso.CreateFolder(\"c:\\Temp\\Ordner 1\")<\/pre>\n
      Mit FolderExists prüfen, ob ein Verzeichnis existiert<\/h2>\n
      Mit der Funktion FolderExists <\/b>können wir prüfen, ob ein Verzeichnis bereits existiert. Dieser Funktion übergeben wir den vollständigen Pfad bis zu dem zu untersuchenden Verzeichnis:<\/p>\n
      Debug.Print<\/span> fso.FolderExists(\"c:\\Temp\\Ordner 1\")<\/pre>\n
      Vor den verschiedenen Operationen auf Basis eines Verzeichnisses sollten wir in einer If…Then<\/b>-Bedingung prüfen, ob das Verzeichnis überhaupt vorhanden ist:<\/p>\n
      If <\/span>fso.FolderExists(\"c:\\Temp\\Ordner 1\") Then<\/span>\r\n     ''... Operationen mit diesem Verzeichnis\r\nEnd If<\/span><\/pre>\n
      Verzeichnisse löschen mit DeleteFolder<\/h2>\n
      Mit der Methode DeleteFolder <\/b>können wir Verzeichnisse löschen.<\/p>\n
      fso.DeleteFolder \"c:\\Temp\\Ordner 1\"<\/pre>\n
      Wenn sich im Verzeichnis beispielsweise eine aktuell geöffneten Access-Datenbank befindet, liefert DeleteFolder <\/b>Fehler 70<\/b>, Zugriff verweigert<\/b>. Das Gleiche ist der Fall, wenn der Ordner schreibgeschützt ist.<\/p>\n
      Wenn wir ein solches Verzeichnis dennoch löschen wollen, können wir DeleteFolder <\/b>für den zweiten Parameter Force <\/b>den Wert True <\/b>übergeben:<\/p>\n
      fso.DeleteFolder \"c:\\Temp\\Ordner 1\", True<\/span><\/pre>\n
      Dies löscht jedoch nur schreibgeschützte Elemente, eine geöffnete Access-Datenbank oder andere durch das System schreibgeschützten Elemente lassen sich auch auf diese Weise nicht löschen.<\/p>\n
      Verzeichnisse kopieren mit CopyFolder<\/h2>\n
      Die Methode CopyFolder <\/b>kopiert das mit dem ersten Parameter angegebene Verzeichnis in das Verzeichnis aus dem zweiten Parameter. Dabei werden auch alle enthaltenen Unterverzeichnisse und Dateien kopiert.<\/p>\n
      Wenn wir also den Inhalt von Ordner 1 <\/b>in einen neuen Ordner 2 <\/b>kopieren wollen, der gleichzeitig angelegt wird, verwenden wir diesen Aufruf:<\/p>\n
      fso.CopyFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\"<\/pre>\n
      Wenn wir das Verzeichnis Ordner 1 <\/b>in Ordner 2 <\/b>kopieren wollen, sodass Ordner 2 <\/b>unterhalb von Ordner 1 <\/b>angelegt wird, nutzen wir:<\/p>\n
      fso.CopyFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\\\"<\/pre>\n
      Mit dem dritten Parameter OverwriteFiles <\/b>können wir noch angeben, dass eventuell vorhandene Dateien und Verzeichnisse gleichen Namens überschrieben werden sollen.<\/p>\n
      Verzeichnisse verschieben mit MoveFolder<\/h2>\n
      Auf die gleiche Weise arbeitet MoveFolder<\/b>, nur dass das ursprüngliche Verzeichnis bei diesem Vorgang gelöscht wird:<\/p>\n
      fso.MoveFolder \"c:\\Temp\\Ordner 1\", \"c:\\temp\\Ordner 2\\\"<\/pre>\n
      Folder-Objekt holen mit GetFolder<\/h2>\n
      Die FileSystemObject<\/b>-Klasse bietet nicht nur eine Drive<\/b>-Klasse mit weiteren Eigenschaften eines Laufwerks, sondern auch entsprechende Klassen für Verzeichnisse (Folder<\/b>) und Dateien (File<\/b>).<\/p>\n
      Das Folder<\/b>-Objekt liefert weitere Methoden und Eigenschaften für Verzeichnisse.<\/p>\n
      Um ein solches zu erhalten, nutzen wir zum Beispiel die GetFolder<\/b>-Funktion. Das Ergebnis weisen wir einer Variablen des Typs Folder <\/b>zu, die wir zuvor deklarieren:<\/p>\n
      Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nSet<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nDebug.Print<\/span> objFolder<\/pre>\n
      Danach können wir die Methoden und Eigenschaften von objFolder <\/b>nutzen – mehr dazu weiter unten. Hier geben wir nur die Standardeigenschaft aus, nämlich den Pfad zu diesem Verzeichnis:<\/p>\n
      c:\\Temp\\Ordner 1<\/pre>\n
      Übergeordnetes Verzeichnis ermitteln mit GetParentFolderName<\/h2>\n
      Mit der Funktion GetParentFolderName <\/b>der FileSystemObject<\/b>-Klasse ermitteln wir das übergeordnete Verzeichnis eines Verzeichnisses:<\/p>\n
      Debug.Print<\/span> fso.GetParentFolderName(\"c:\\Temp\\Ordner 1\")<\/pre>\n
      Dies liefert:<\/p>\n
      c:\\Temp<\/pre>\n
      Spezialverzeichnisse ermitteln mit GetSpecialFolder<\/h2>\n
      Mit der Funktion GetSpecialFolder <\/b>können wir verschiedene Standardverzeichnisse ermitteln. Dazu übergeben wir einen der folgenden Werte:<\/p>\n
        \n
      • SystemFolder<\/b> (1<\/b>): Liefert standardmäßig C:\\Windows\\System32<\/b>.<\/li>\n
      • TemporaryFolder<\/b> (2<\/b>): Liefert standardmäßig C:\\Users\\User\\AppData\\Local\\Temp<\/b>.<\/li>\n
      • WindowsFolder<\/b> (0<\/b>): Liefert standardmäßig C:\\Windows<\/b>.<\/li>\n<\/ul>\n
        Die Funktion rufen wir wie folgt auf:<\/p>\n
        Debug.Print<\/span> fso.GetSpecialFolder(SystemFolder)\r\nDebug.Print<\/span> fso.GetSpecialFolder(TemporaryFolder)\r\nDebug.Print<\/span> fso.GetSpecialFolder(WindowsFolder)<\/pre>\n
        Das Ergebnis lautet:<\/p>\n
        C:\\Windows\\System32\r\nC:\\Users\\User\\AppData\\Local\\Temp\r\nC:\\Windows<\/pre>\n
        Hier ist zu beachten, dass GetSpecialFolder <\/b>jeweils ein Folder<\/b>-Objekt liefert und die Debug.Print<\/b>-Anweisungen wieder den Wert der Standardeigenschaft liefern.<\/p>\n
        Wie können das Ergebnis also auch einer Folder<\/b>-Objektvariablen zuweisen und damit weitere Operationen ausführen (siehe weiter unten).<\/p>\n
        Operationen der Folder-Klasse<\/h2>\n
        Wenn wir beispielsweise mit GetFolder <\/b>oder GetSpecialFolder <\/b>einen Verweis auf ein Folder<\/b>-Objekt geholt haben, können wir dessen Methoden und Eigenschaften nutzen, die wir in den folgenden Abschnitten vorstellen. Diese liefert die folgenden Elemente:<\/p>\n
          \n
        • Attributes<\/b>: Liefert einen Zahlenwert, der verschiedene Attribute kombiniert.<\/li>\n
        • Copy<\/b>: Kopiert das Verzeichnis in das angegebene Verzeichnis.<\/li>\n
        • CreateTextFile<\/b>: Erstellt eine Textdatei im Verzeichnis.<\/li>\n
        • DateCreated<\/b>: Liefert das Erstellungsdatum des Verzeichnisses.<\/li>\n
        • DateLastAccessed<\/b>: Liefert das Datum des letzten lesenden Zugriffs.<\/li>\n
        • DateLastModified<\/b>: Liefert das Datum des letzten schreibenden Zugriffs.<\/li>\n
        • Delete<\/b>: Löscht das Verzeichnis.<\/li>\n
        • Drive<\/b>: Ermittelt einen Verweis auf das Drive<\/b>-Objekt des Verzeichnisses.<\/li>\n
        • Files<\/b>: Liefert die Files<\/b>-Auflistung des Verzeichnisses.<\/li>\n
        • IsRootFolder<\/b>: Gibt an, ob es sich bei dem Verzeichnis um das Rootverzeichnis handelt, also beispielsweise c:\\<\/b>.<\/li>\n
        • Move<\/b>: Verschiebt das Verzeichnis in das angegebene Verzeichnis.<\/li>\n
        • Name<\/b>: Liefert den Namen des Verzeichnisses.<\/li>\n
        • ParentFolder<\/b>: Liefert ein Folder<\/b>-Objekt für das übergeordnete Verzeichnis.<\/li>\n
        • Path<\/b>: Liefert den Pfad zu dem Verzeichnis.<\/li>\n
        • ShortName<\/b>: Liefert den kurzen Namen des Verzeichnisses.<\/li>\n
        • ShortPath<\/b>: Liefert den kurzen Pfad des Pfades zum Verzeichnis.<\/li>\n
        • Size<\/b>: Liefert die Größe des Verzeichnisses inklusive der enthaltenen Dateien.<\/li>\n
        • SubFolders<\/b>: Liefert eine Auflistung der Unterordner des Verzeichnisses.<\/li>\n
        • Type<\/b>: Gibt den Typ des Verzeichnisses aus.<\/li>\n<\/ul>\n
          In den folgenden Abschnitten setzen wir voraus, dass wir objFolder <\/b>zuvor mit einem Verweis auf ein Verzeichnis gefüllt haben.<\/p>\n
          Attribute eines Verzeichnisses mit Attributes ermitteln<\/h2>\n
          Für ein herkömmliches Verzeichnis liefert das Attributes<\/b>-Attribut den Wert 16<\/b>. Die Werte können wir im Objektkatalog unter FileAttribute <\/b>einsehen.<\/p>\n
          Die Werte lauten Alias <\/b>(1.024<\/b>), Archive <\/b>(32<\/b>), Compressed <\/b>(2.048<\/b>), Directory <\/b>(16<\/b>), Hidden <\/b>(2<\/b>), Normal <\/b>(0<\/b>), ReadOnly <\/b>(1<\/b>), System <\/b>(4<\/b>) und Column <\/b>(8<\/b>). Sie gelten gleichermaßen für das File<\/b>– und das Folder<\/b>-Objekt.<\/p>\n
          Ob ein Verzeichnis eines der genannten Attribute aufweist, können wir prüfen, indem wir wie folgt vorgehen – hier am Beispiel des Attributs Directory<\/b>:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nSet<\/span> objFolder = fso.GetFolder(\"c:\\Temp\")\r\nDebug.Print<\/span> objFolder.Attributes\r\nIf <\/span>(objFolder.Attributes And Directory) = Directory Then<\/span>\r\n     Debug.Print<\/span> \"Verzeichnis hat das Attribut ''Directory''\"\r\nEnd If<\/span><\/pre>\n
          Ermitteln, wann ein Verzeichnis erstellt, gelesen oder bearbeitet wurde<\/h2>\n
          Mit den drei Eigenschaften DateCreated<\/b>, DateLastAccessed <\/b>und DateLastModified <\/b>finden wir heraus, wann ein Verzeichnis erstellt, zuletzt gelesen und zuletzt bearbeitet wurde:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\")\r\nDebug.Print<\/span> objFolder.DateCreated\r\nDebug.Print<\/span> objFolder.DateLastAccessed\r\nDebug.Print<\/span> objFolder.DateLastModified<\/pre>\n
          Die Ausgabe lautet beispielsweise:<\/p>\n
          22.07.2025 22:09:37 \r\n08.10.2025 22:21:56 \r\n08.10.2025 22:21:56 <\/pre>\n
          Weitere Verzeichniseigenschaften<\/h2>\n
          Das Folder<\/b>-Objekt liefert noch einige weitere Eigenschaften, die wir hier zusammenfassen und für ein Verzeichnis mit einem längeren Namen als acht Zeichen ausgeben:<\/p>\n
          Set<\/span> objFolder = _\r\n     fso.CreateFolder(\"c:\\temp\\LangerVerzeichnisname\")\r\nDebug.Print<\/span> objFolder.IsRootFolder\r\nDebug.Print<\/span> objFolder.Name\r\nDebug.Print<\/span> objFolder.Path\r\nDebug.Print<\/span> objFolder.ShortName\r\nDebug.Print<\/span> objFolder.ShortPath\r\nDebug.Print<\/span> objFolder.Size<\/pre>\n
          Die Ergebnisse lauten:<\/p>\n
          Falsch                        ''IsRootFolder\r\nLangerVerzeichnisname         ''Name\r\nC:\\Temp\\LangerVerzeichnisname ''Path\r\nLANGER~1                      ''ShortName\r\nC:\\temp\\LANGER~1              ''ShortPath\r\n  0                            ''Size<\/pre>\n
          Verzeichnis kopieren mit Copy<\/h2>\n
          Um das Verzeichnis aus objFolder <\/b>in ein anderes Verzeichnis zu kopieren, rufen wir Folgendes auf:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 2\\\"<\/pre>\n
          Damit landet Ordner 1 <\/b>als Unterverzeichnis in Ordner 2<\/b>.<\/p>\n
          Wenn wir nicht das Verzeichnis selbst, sondern nur seinen Inhalt in Ordner 2 <\/b>kopieren wollen, lassen wir das letzte Backslash-Zeichen im Zielverzeichnis weg:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 2\"<\/pre>\n
          Wir können das Verzeichnis Ordner 1 <\/b>auch in einen neuen Ordner 3 <\/b>kopieren.<\/p>\n
          Dies erzeugt ein neues Verzeichnis namens Ordner 3<\/b>, das den Inhalt von Ordner 1 <\/b>enthält:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Copy \"c:\\Temp\\Ordner 3\"<\/pre>\n
          Verzeichnis verschieben mit Move<\/h2>\n
          Auf ähnliche Weise können wir mit Move <\/b>einen Ordner oder seinen Inhalt in den Zielordner verschieben. Die Syntax für die drei oben genannten Fälle ist gleich, der zu verschiebende Ordner wird dann nach dem Kopieren entfernt. Aber wir können nur zwei der drei Fälle nutzen:<\/p>\n
          Ordner 1 <\/b>in Ordner 2 <\/b>verschieben:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 2\\\"<\/pre>\n
          Inhalt von Ordner 1 <\/b>in Ordner 2 <\/b>verschieben funktioniert nicht, sondern liefert Fehler 58<\/b>, Datei existiert bereits<\/b>:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 2\"<\/pre>\n
          Ordner 1 <\/b>in Ordner 3 <\/b>verschieben bewirkt letztlich ein Umbenennen von Ordner 1 <\/b>in Ordner 3<\/b>:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Move \"c:\\Temp\\Ordner 3\"<\/pre>\n
          Verzeichnis löschen mit Delete<\/h2>\n
          Zum Löschen des mit objFolder<\/b> markierten Verzeichnisses brauchen wir einfach nur die Delete<\/b>-Methode dieses Objekts aufzurufen:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.Delete<\/pre>\n
          Ermitteln des Drive-Objekts mit Drive<\/h2>\n
          Mit der Drive<\/b>-Eigenschaft der Folder<\/b>-Klasse können wir das Drive<\/b>-Objekt zu dem Ordner ermitteln. Wenn man also zum Beispiel einen neuen Ordner im gleichen Laufwerk anlegen möchte, wäre dies ein guter Startpunkt:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nSet<\/span> objDrive = objFolder.Drive\r\nDebug.Print<\/span> objDrive.Path<\/pre>\n
          Files-Auflistung mit Files<\/h2>\n
          Mit der Files<\/b>-Eigenschaft holen wir eine Files<\/b>-Auflistung der Dateien eines Verzeichnisses. Hier geben wir die Anzahl der enthaltenen Dateien aus – weiter unten zeigen wir weitere Optionen der Files<\/b>-Auflistung:<\/p>\n
          Dim <\/span>objFiles As <\/span>Scripting.Files\r\n---\r\nSet<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nSet<\/span> objFiles = objFolder.Files\r\nDebug.Print<\/span> objFiles.Count<\/pre>\n
          Folders-Auflistung mit SubFolders<\/h2>\n
          Auf ähnliche Weise können wir die Auflistung der Unterordner eines Verzeichnisses holen. Dazu nutzen wir die SubFolders<\/b>-Eigenschaft.<\/p>\n
          Das Ergebnis speichern wir in einem Folders<\/b>-Objekt und geben anschließend die Anzahl der Unterordner aus:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nDim <\/span>objFolders As <\/span>Scripting.Folders\r\nSet<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nSet<\/span> objFolders = objFolder.SubFolders\r\nDebug.Print<\/span> objFolders.Count<\/pre>\n
          Übergeordnetes Verzeichnis mit ParentFolder<\/h2>\n
          Mit der Eigenschaft ParentFolder <\/b>holen wir ein Folder<\/b>-Objekt für das übergeordneten Verzeichnis. Hier speichern wir es in einem Folder<\/b>-Objekt namens objParentFolder <\/b>und geben das Verzeichnis mit Path<\/b> aus:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nDim <\/span>objParentFolder As <\/span>Scripting.Folder\r\nSet<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\\Ordner 2\")\r\nSet<\/span> objParentFolder = objFolder.ParentFolder\r\nDebug.Print<\/span> objParentFolder.Path<\/pre>\n
          Erstellen einer Textdatei mit CreateTextFile<\/h2>\n
          Mit CreateTextFile <\/b>können wir im Verzeichnis aus objFolder <\/b>eine neue, leere Textdatei erstellen:<\/p>\n
          Set<\/span> objFolder = fso.GetFolder(\"c:\\Temp\\Ordner 1\")\r\nobjFolder.CreateTextFile \"Test.txt\"<\/pre>\n
          Mehr zur Verwendung von Textdateien findest Du weiter unten.<\/p>\n
          Verzeichnisse durchlaufen über die Folders-Auflistung<\/h2>\n
          Die Folders<\/b>-Auflistung, die wir mit der SubFolders<\/b>-Eigenschaft holen können, können wir durchlaufen und damit alle Unterordner ausgeben lassen.<\/p>\n
          Dazu nutzen wir eine For Each<\/b>-Schleife:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nDim <\/span>objFolders As <\/span>Scripting.Folders\r\nSet<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\nSet<\/span> objFolders = objFolder.SubFolders\r\nFor Each objFolder In objFolders\r\n     Debug.Print<\/span> objFolder\r\nNext<\/span> objFolder<\/pre>\n
          Verzeichnis zur Folders-Auflistung hinzufügen<\/h2>\n
          Wenn wir einmal eine Folders<\/b>-Auflistung referenziert haben, können wir mit der Add<\/b>-Methode ein neues Unterverzeichnis zum referenzierten Verzeichnis hinzufügen:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nDim <\/span>objFolders As <\/span>Scripting.Folders\r\nSet<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\nSet<\/span> objFolders = objFolder.SubFolders\r\nobjFolders.Add \"Folder 4\"<\/pre>\n
          Mit Dateien arbeiten<\/h2>\n
          Nun folgen die Funktionen der FileSystemObject<\/b>-Klasse für das Arbeiten mit Dateien.<\/p>\n
          Hier können wir prüfen, ob eine Datei existiert, Dateien löschen, kopieren oder verschieben, Dateinamen und -version ermitteln oder mit GetFile <\/b>auf File<\/b>-Objekte zugreifen.<\/p>\n
          Außerdem können wir alle Dateien eines Verzeichnisses mit der Files<\/b>-Auflistung eines Folder<\/b>-Objekts durchlaufen und verarbeiten oder analysieren.<\/p>\n
          Mit FileExists prüfen, ob eine Datei existiert<\/h2>\n
          Mit der Funktion FileExists <\/b>können wir prüfen, ob eine Datei vorhanden ist:<\/p>\n
          Debug.Print<\/span> fso.FileExists(CurrentDb.Name)<\/pre>\n
          Hier prüfen wir, ob die aktuelle Datenbankdatei vorhanden ist, was natürlich das Ergebnis True <\/b>zurückliefert.<\/p>\n
          Datei löschen mit DeleteFile<\/h2>\n
          Mit der DeleteFile<\/b>-Methode können wir die Datei mit dem angegebenen Pfad löschen:<\/p>\n
          fso.DeleteFile CurrentProject.Path & \"\\test.txt\"<\/pre>\n
          Datei kopieren mit CopyFile<\/h2>\n
          Mit der Methode CopyFile <\/b>kopiert eine Datei in die angegebene Datei:<\/p>\n
          fso.CopyFile \"c:\\Temp\\test.txt\", \"c:\\Temp\\test2.txt\"<\/pre>\n
          Datei verschieben mit MoveFile<\/h2>\n
          Mit der MoveFile<\/b>-Methode können wir eine Datei verschieben.<\/p>\n
          Bei Angabe des gleichen Quell- wie Zielpfades wird die Datei prinzipiell umbenannt:<\/p>\n
          fso.MoveFile \"c:\\Temp\\test.txt\", \"c:\\Temp\\test3.txt\"<\/pre>\n
          Wir können diese auch in ein anderes Verzeichnis verschieben:<\/p>\n
          fso.MoveFile \"c:\\Temp\\test.txt\", _\r\n     \"c:\\Temp\\Ordner 1\\test3.txt\"<\/pre>\n
          Dateiname ermitteln mit GetFileName<\/h2>\n
          Der GetFileName<\/b>-Funktion können wir den vollständigen Pfad zu einer Datei übergeben und erhalten lediglich den Dateinamen ohne Laufwerks- und Verzeichnisangabe als Ergebnis:<\/p>\n
          Debug.Print<\/span> fso.GetFileName(CurrentDb.Name)<\/pre>\n
          File-Objekt holen mit GetFile<\/h2>\n
          Auf ähnliche Art holen wir uns ein File<\/b>-Objekt auf Basis der für die GetFile<\/b>-Funktion angegebenen Datei.<\/p>\n
          Hier geben wir den Wert der Eigenschaft Name <\/b>des File<\/b>-Objekts im Direktbereich aus:<\/p>\n
          Dim <\/span>objFile As <\/span>Scripting.File\r\nSet<\/span> objFile = fso.GetFile(CurrentDb.Name)\r\nDebug.Print<\/span> objFile.Name<\/pre>\n
          Dateiversion ermitteln mit GetFileVersion<\/h2>\n
          Mit GetFileVersion <\/b>holen wir die Dateiversion. Für die aktuelle Datenbank liefert die Funktion eine leere Zeichenkette:<\/p>\n
          Debug.Print<\/span> fso.GetFileVersion(CurrentDb.Name)<\/pre>\n
          Tatsächlich liefert GetFileVersion <\/b>nur eine Version für Dateien wie .exe<\/b>, .dll <\/b>und ähnliche Dateien.<\/p>\n
          So können wir beispielsweise wie folgt die Version der MSAccess.exe <\/b>ermitteln:<\/p>\n
          Debug.Print<\/span> fso.GetFileVersion(SysCmd(acSysCmdAccessDir) _\r\n     & \"\\MSAccess.exe\")<\/pre>\n
          Dateien eines Verzeichnisses durchlaufen mit der Files-Auflistung<\/h2>\n
          Genau wir mit der Folders<\/b>-Auflistung für Verzeichnisse können wir mit der Files<\/b>-Auflistung alle Dateien eines Verzeichnisses durchlaufen – hier beispielsweise für alle Dateien des aktuellen Datenbankverzeichnisses:<\/p>\n
          Dim <\/span>objFolder As <\/span>Scripting.Folder\r\nDim <\/span>objFiles As <\/span>Scripting.Files\r\nDim <\/span>objFile As <\/span>Scripting.File\r\nSet<\/span> fso = New<\/span> Scripting.FileSystemObject\r\nSet<\/span> objFolder = fso.GetFolder(CurrentProject.Path)\r\nSet<\/span> objFiles = objFolder.Files\r\nFor Each objFile In objFiles\r\n     Debug.Print<\/span> objFile.Name\r\nNext<\/span> objFile<\/pre>\n
          Operationen der File-Klasse<\/h2>\n
          Genau wie die Folder<\/b>-Klasse liefert auch die File<\/b>-Klasse einige Methoden und Eigenschaften. Die folgenden Eigenschaften und Methoden funktionieren genauso wie bei der oben beschriebenen Folder<\/b>-Klasse:<\/p>\n
          Attributes<\/b>, Copy<\/b>, DateCreated<\/b>, DateLastAccessed<\/b>, DateLastModified<\/b>, Delete<\/b>, Drive<\/b>, Move<\/b>, Name<\/b>, ParentFolder<\/b>, Path<\/b>, ShortName<\/b>, ShortPath<\/b>, Size<\/b>, Type<\/b>.<\/p>\n
          Lediglich die OpenAsTextStream<\/b>-Methode ist neu. Mit dieser können wir ein TextStream<\/b>-Objekt auf Basis einer Datei öffnen. Mehr dazu gleich im Anschluss.<\/p>\n
          Mit Textdateien arbeiten<\/h2>\n
          Schließlich folgen drei Funktionen, mit denen wir speziell mit Textdateien arbeiten können.<\/p>\n
          Diese können wir nutzen, um Textdateien zu erstellen, diese auszulesen und sie zum Beschreiben zu öffnen.<\/p>\n
          Diese Methoden und Funktionen beschreiben wir in einem weiteren Artikel namens Textdateien und Stream mit FileSytemObject <\/b>(www.vbentwickler.de\/479<\/b>).<\/p>\n