{"id":55000182,"date":"2019-08-01T00:00:00","date_gmt":"2020-03-27T19:38:12","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=182"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Mit_Dateien_und_Verzeichnissen_arbeiten","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Mit_Dateien_und_Verzeichnissen_arbeiten\/","title":{"rendered":"Mit Dateien und Verzeichnissen arbeiten"},"content":{"rendered":"

Wer unter Visual Studio Anwendungen mit Visual Basic programmiert, wird früher oder später an den Punkt kommen, wo er mit Dateien und Verzeichnissen arbeitet. Dabei gibt es Aufgaben wie zu ermitteln, ob eine Datei bereits vorhanden ist, eine Datei von einem Verzeichnis in ein anderes zu kopieren, alle Dateien eines Verzeichnisses zu durchlaufen oder dies gar rekursiv für untergeordnete Verzeichnisse und Dateien zu erledigen. Natürlich bietet Microsoft passende Möglichkeiten an, die kaum noch etwas mit den von VBA gewohnten Befehlen zu tun haben und auch nicht mit den Methoden des FileSystemObjects.<\/b><\/p>\n

Die Beispiele dieses Artikels haben wir mit dem Tool LINQPad <\/b>durchgespielt, das die einfache Eingabe von Visual Basic- und C#-Anweisungen und deren Ausführung erlaubt. Sie müssen hier nicht immer erst das Projekt kompilieren, um die enthaltenen Anweisungen zu debuggen, sondern können dies quasi ad hoc erledigen (Download siehe https:\/\/www.linqpad.net<\/b>).<\/p>\n

Der Namespace System.IO<\/h2>\n

Die Objekte, Methoden und Eigenschaften, die wir in diesem Artikel vorstellen, befinden sich im Namespace System.IO<\/b>. Um diesen für eine Datei in LINQPad verfügbar zu machen, betätigen Sie die Taste F4<\/b>. Dadurch wird der Dialog Query Properties <\/b>geöffnet. In diesem wechseln Sie zum zweiten Registerreiter Additional Namespace Imports<\/b>. Hier tragen Sie einfach wie in Bild 1 den folgenden Namespace ein:<\/p>\n

\"Hinzufügen<\/p>\n

Bild 1: Hinzufügen von Namespaces<\/span><\/b><\/p>\n

System.IO<\/pre>\n
Danach stehen die Elemente dieses Namespaces in dem entsprechenden Fenster von LINQPad <\/b>zur Verfügung.<\/p>\n
Laufwerke<\/h2>\n
Das oberste Element der Hierarchie der Elemente des Dateisystems sind die Laufwerke. Diese können wir über die Funktion GetDrives<\/b> auslesen und erhalten damit Objekte des Typs DriveInfo<\/b>. Diese wiederum liefern einige Eigenschaften, mit denen wir die Informationen zum jeweiligen Laufwerk auslesen können. <\/p>\n
Laufwerke ausgeben<\/h2>\n
Die Anweisungen, die wir ausprobieren wollen, fügen wir jeweils in die Sub Main<\/b>-Prozedur ein. Wir steigen gleich ein und wollen alle Laufwerke des aktuellen Rechners im Direktfenster ausgeben. Dazu deklarieren wir zunächst ein Array namens objDrives <\/b>und eine Variable namens objDrive<\/b>, beide vom Typ DriveInfo<\/b>. Es gibt kein Auflistungsobjekt, sondern eine Funktion namens GetDrives<\/b>, die alle Laufwerke zurückliefert. Das Ergebnis, das wir zum Array objDrives <\/b>hinzufügen, durchlaufen wir in einer For Each<\/b>-Schleife. Dabei referenzieren wir das aktuelle Element jeweils mit der Variablen objDrive <\/b>und geben den Wert seiner Eigenschaft Name <\/b>aus:<\/p>\n
Sub <\/span>Main\r\n     Dim <\/span>objDrives() As <\/span>DriveInfo\r\n     Dim <\/span>objDrive As <\/span>DriveInfo\r\n     objDrives = DriveInfo.GetDrives()\r\n     For Each objDrive In objDrives\r\n         Debug.print (objDrive.Name)\r\n     Next<\/span> objDrive    \r\nEnd Sub<\/span> <\/pre>\n
Das Ergebnis sieht im Fall des hier verwendeten Rechners etwa wie in Bild 2 aus.<\/p>\n
\"Ausgabe<\/p>\n
Bild 2: Ausgabe der Laufwerksnamen<\/span><\/b><\/p>\n
Eigenschaften von Laufwerken<\/h2>\n
Das DriveInfo<\/b>-Objekt bietet eine ganze Reihe von Eigenschaften. Mit den folgenden Anweisungen geben wir diese im Direktbereich aus:<\/p>\n
For Each objDrive In objDrives\r\n     Debug.print (objDrive.Name)\r\n     Debug.Print<\/span>(\"AvailableFreeSpace: \" & objDrive.AvailableFreeSpace.ToString())\r\n     Debug.Print<\/span>(\"DriveFormat:        \" & objDrive.DriveFormat.ToString())\r\n     Debug.Print<\/span>(\"DriveType:          \" & objDrive.DriveType.ToString())\r\n     Debug.Print<\/span>(\"IsReady:            \" & objDrive.IsReady.ToString())\r\n     Debug.Print<\/span>(\"RootDirectory:      \" & objDrive.RootDirectory.ToString())\r\n     Debug.Print<\/span>(\"TotalFreeSpace:     \" & objDrive.TotalFreeSpace.ToString())\r\n     Debug.Print<\/span>(\"TotalSize:          \" & objDrive.TotalSize.ToString())\r\n     Debug.Print<\/span>(\"VolumeLabel:        \" & objDrive.VolumeLabel.ToString())\r\nNext<\/span> objDrive    <\/pre>\n
Die Eigenschaft IsReady <\/b>ist beispielsweise interessant für CD\/DVD-Laufwerke. Ist keine CD oder DVD eingelegt, liefert IsReady <\/b>den Wert False<\/b>. Ein Zugriff auf Eigenschaften wie AvailableFreeSpace<\/b> oder DriveFormat <\/b>ist somit nicht möglich, Name <\/b>oder DriveType <\/b>hingegen funktionieren. Um beim Zugriff auf alle Laufwerke Ausnahmen zu verhindern, können Sie prüfen, ob das Laufwerk bereit ist und nur dann auf die Eigenschaften zugreifen, die bei nicht bereiten Laufwerken nicht zur Verfügung stehen. Dazu verwenden wir eine einfache If…Then<\/b>-Bedingung:<\/p>\n
For Each objDrive In objDrives\r\n     Debug.print(objDrive.Name)\r\n     Debug.Print<\/span>(\"DriveType:          \" & objDrive.DriveType.ToString())\r\n     Debug.Print<\/span>(\"IsReady:            \" & objDrive.IsReady.ToString())\r\n     Debug.Print<\/span>(\"RootDirectory:      \" & objDrive.RootDirectory.ToString())\r\n     If <\/span>(objDrive.IsReady) Then<\/span>\r\n         Debug.Print<\/span>(\"AvailableFreeSpace: \" & objDrive.AvailableFreeSpace.ToString())\r\n         Debug.Print<\/span>(\"DriveFormat:        \" & objDrive.DriveFormat.ToString())\r\n         Debug.Print<\/span>(\"TotalFreeSpace:     \" & objDrive.TotalFreeSpace.ToString())\r\n         Debug.Print<\/span>(\"TotalSize:          \" & objDrive.TotalSize.ToString())\r\n         Debug.Print<\/span>(\"VolumeLabel:        \" & objDrive.VolumeLabel.ToString())\r\n     End If<\/span>\r\nNext<\/span> objDrive<\/pre>\n
Praktischerweise geben Eigenschaften wie etwa DriveFormat <\/b>nicht wie unter VBA nur die Zahlenwerte von Konstanten aus, sondern über die Funktion ToString() <\/b>auch direkt entsprechende Zeichenketten. Benötigen Sie einmal den Zahlenwert, können Sie ToString() <\/b>einfach weglassen.<\/p>\n
Auf ein Verzeichnis zugreifen<\/h2>\n
Auf ein Verzeichnis greifen wir über das DirectoryInfo<\/b>-Objekt zu. Dieses erstellen wir jeweils mit der New<\/b>-Methode und übergeben der Konstruktor-Methode dabei den Namen des Verzeichnisses. Hier geben wir direkt die Eigenschaften als Kommentar hinter der jeweiligen Anweisung an:<\/p>\n
Dim <\/span>objDirectoryInfo As <\/span>DirectoryInfo\r\nobjDirectoryInfo = New<\/span> DirectoryInfo(\"c:\\Beispiele\")\r\nDebug.Print<\/span> (objDirectoryInfo.CreationTime.ToString)    ''01.01.1601 01:00:00\r\nDebug.Print<\/span> (objDirectoryInfo.CreationTimeUtc)       ''01.01.1601\r\nDebug.Print<\/span> (objDirectoryInfo.Extension)                ''\r\nDebug.Print<\/span> (objDirectoryInfo.Exists)           ''False<\/span>\r\nDebug.Print<\/span> (objDirectoryInfo.FullName)           ''c:\\Beispiele\r\nDebug.Print<\/span> (objDirectoryInfo.Name)                    ''Beispiele\r\nDebug.Print<\/span> (objDirectoryInfo.Root.FullName)                ''c:\\<\/pre>\n
Verzeichnisse eines Laufwerks lesen<\/h2>\n
Damit haben wir zwar schon einen Weg gefunden, auf ein Verzeichnis zuzugreifen, dessen Namen wir kennen. Aber wie können wir beispielsweise alle Verzeichnisse eines Laufwerks lesen und ausgeben Es sieht nicht so aus, als ob das DriveInfo<\/b>-Objekte Eigenschaften bereitstellt, die eine Auflistung aller untergeordneten Verzeichnisse liefert. Aber wir kommen dennoch zum Ziel, denn das DirectoryInfo<\/b>-Objekt bietet eine Funktion namens GetDirectories<\/b>. Und da ein Laufwerk ja prinzipiell auch ein Verzeichnis abbilden, zum Beispiel c:\\, können wir diese Funktion nutzen, um die Verzeichnisse eines Laufwerks zu ermitteln. Insgesamt sieht das etwa wie folgt aus:<\/p>\n
Dim <\/span>objDrive As <\/span>DriveInfo\r\nDim <\/span>objDirectoryDrive As <\/span>DirectoryInfo\r\nDim <\/span>objDirectory As <\/span>DirectoryInfo\r\nobjDrive = New<\/span> DriveInfo(\"c:\")\r\nobjDirectoryDrive = New<\/span> DirectoryInfo(objDrive.Name)\r\nFor Each objDirectory In objDirectoryDrive.GetDirectories\r\n     Debug.Print<\/span>(objDirectory.FullName)\r\nNext<\/span> objDirectory<\/pre>\n
Wir holen also das DriveInfo<\/b>-Objekt und erstellen ein DirectoryInfo<\/b>-Objekte mit dem Namen des DriveInfo<\/b>-Objektes als Parameter. Dann durchlaufen wir diese Verzeichnisse in einer For Each<\/b>-Schleife und geben mit der Eigenschaft FullName <\/b>den Pfad der Verzeichnisse aus – zum Beispiel so:<\/p>\n
c:\\Dokumente und Einstellungen\r\nc:\\inetpub\r\nc:\\Intel\r\nc:\\MSOCache\r\n...<\/pre>\n
Verzeichnisse suchen<\/h2>\n
Wir können der GetDirectories<\/b>-Methode auch noch einen Suchbegriff als Parameter übergeben. Folgender Aufruf liefert alle Verzeichnisse, die mit Windows <\/b>beginnen:<\/p>\n
objDirectoryDrive.GetDirectories(\"Windows*\")<\/pre>\n
Als Platzhalter können die von Access-SQL bekannten Platzhalter verwendet werden:<\/p>\n