System.IO Namespace richtig nutzen

    • VB.NET

    Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von ~blaze~.

      System.IO Namespace richtig nutzen

      Hey Leuts,

      mir fällt in letzter Zeit immer wieder auf, dass Neulinge in VB Fragen zu Pfaden und Dateien etc. stellen.
      Auch wenn es dazu genügend im Internet bzw. auf MSDN gibt, wollte ich nochmal klar stellen, was dieser Namepsace kann und wie Ihr damit arbeitet!


      Allgemein
      Spoiler anzeigen
      Der System.IO-Namespace enthält Typen, die das Lesen und Schreiben für Dateien und Datenstreams zulassen, sowie Typen, die grundlegende Unterstützung für Dateien und Verzeichnisse bieten.
      Also man kann damit praktisch auf dem Computer auf den Explorer zugreifen und Pfade erstellen, Dateien erstellen, verändern etc, aber auch Dateien auslesen, auf bestimmte Attribute prüfen, und auch auf Existenz prüfen usw.
      Mehr dazu: Hier



      Wie kann ich jetzt Dateien einfügen, löschen, umbenennen etc.?
      Spoiler anzeigen
      Dazu hat der Namespace auch eine eigene Klasse: Nämlich "File".
      Mit dieser Klasse hat man bestimmte Methoden, die genau das machen, was Ihr wollt.
      Um eine Datei einzufügen macht Ihr einfach:

      VB.NET-Quellcode

      1. System.IO.File.Copy(Ausgangspfad, Neuer Pfad)


      Also wie man sieht, wären jetzt viele verwirrt, wegen dem Copy!
      Das ist aber leicht...
      Wenn Ihr eine Datei kopiert, dann wollt Ihr sie ja woanders einfügen.
      Das bedeutet, Visual Basic macht euch weniger Arbeit, indem es beides in eine Methode mit zwei Argumenten zusammenfasst.
      Will heißen, die Datei wird aus dem "Ausgangspfad" (erstes Argument) kopiert und dann im "Neuer Pfad" (zweites Argument nach Komma getrennt) eingefügt.
      Das ist ganz einfach, man muss eben nur im Parameter zwei Argumente angeben.

      Das Problem bei dieser Methode mit den zwei Argumente ist, dass es nicht zulässt, eine gleichnamige Datei zu überschreiben. Es kann also sein, dass deshalb nichts eingefügt bzw. ersetzt wird.
      Aber auch dazu hat VB eine Lösung integriert.
      Es gibt die selbe Methode nämlich auch mit drei Argumenten.

      VB.NET-Quellcode

      1. System.IO.File.Copy(Ausgangspfad, Neuer Pfad, True)


      Wie Ihr seht, ist nun am Ende noch ein "True" als drittes Argument hinzugekommen.
      Wenn Ihr das so macht, dann habt Ihr also noch den Typ Boolean mit drin. Und damit legt Ihr fest, ob eine gleichnamige Datei überschrieben werden darf. In diesem Fall 'Ja', wegen dem "True".
      Ihr könnt das Ganze zwar auch auf "False" setzen, aber dann lohnt es sich eher gleich die Methode mit zwei Argumenten zu nehmen. Ist dann nämlich eine Aufgabe weniger für euren Prozessor ;).

      Um nun eine Datei umzubennen bzw. zu verschieben nehmen wir die Methode "Move"!
      Wieder mal fragt Ihr euch bestimmt, warum es keine "Rename" Methode zum Umbenennen gibt.
      Nun, es gibt hier wieder eine Methode für beides, ob es einfacher ist, kommt auf den Nutzer an...
      Erstmal, zum Verschieben einer Datei schreiben wir:

      VB.NET-Quellcode

      1. System.IO.File.Move(Ausgangspfad, Neuer Pfad)

      Somit verschiebt man eine Datei vom Ausgangspfad (erstes Argument) zum "Neuer Pfad" (zweites Argument).

      Um eine Datei nun umzubenennen, macht man genau das Selbe. Nur verschiebt man die Datei sozusagen an den selben Pfad mit einem geänderten Namen.

      Beispiel:
      Wir haben 1 Datei mit dem Pfad:
      C:\Hallo\Test.txt

      Nun soll die Datei in "Test1" umbenannt werden!
      Dazu schreiben wir:

      VB.NET-Quellcode

      1. System.IO.File.Move("C:\Hallo\Test.txt", "C:\Hallo\Test1.txt")


      Nun haben wir die Datei an den selben Pfad mit einem geänderten Namen verschoben.
      Dies ist also das Gleiche, wie die Datei umzubenennen.
      Es gibt also die "Move"-Methode für zwei Funktionen. Das ist sparsamer und schlau ausgedacht, finde ich...
      Wenn man also weiß, wie man es anwendet, ist es nicht schwer.

      Um eine Datei zu löschen, benötigt man nur ein Argument. Dies ist also eine der einfachsten Methoden dieser "File"-Klasse.

      Dazu schreiben wir:

      VB.NET-Quellcode

      1. System.IO.File.Delete(Datei)


      Das Argument Datei ist dann der Pfad eurer Datei.
      Beispiel: Wir wollen oben die Datei "C:\Hallo\Test.txt" löschen:

      Also:

      VB.NET-Quellcode

      1. System.IO.File.Delete("C:\Hallo\Test.txt")


      Somit wird diese Datei dann vom Computer entfernt.




      Das waren jetzt erstmal die Methoden, die man hauptsächlich braucht.
      Es gibt noch weitere zum Verschlüsseln, entschlüsseln von Dateien und und und, aber die möchte ich jetzt nicht alle nennen, da die auch zu den einfachen gehören! Also schaut ruhig auf MSDN.
      Kurz vielleicht noch erklärt, wie Ihr Dateien mit SaveFileDialogs speichert und mit OpenFileDialogs öffnet:

      Spoiler anzeigen

      Zum Speichern von Dateien nutzt man den SaveFileDialog!
      Um nun beispielsweise eine Textdatei zu speichern mit dem Inhalt einer TextBox1, macht man folgendes:

      Zuerst erstellt man den Filter des SaveFileDialogs, um nur .txt zu speichern!
      Das geht, indem man schreibt:

      VB.NET-Quellcode

      1. SaveFileDialog.Filter = "Text-Dateien (*.txt)|*.txt"


      Nun kann man mit diesem SaveFileDialog nur Text-Dateien speichern.
      So, um nun eine Texdatei mit Inhalt der TextBox1 zu erstellen machen wir folgendes:

      VB.NET-Quellcode

      1. If SaveFileDialog.ShowDialog() = DialogResult.OK Then 'Prüfen, ob im SaveFileDialog "OK" gedrückt wurde.
      2. System.IO.WriteAllText(SaveFileDialog.FileName, TextBox1.Text)
      3. End If


      So, nun wird in die Textdatei der Inhalt/Text von TextBox1 geschrieben.
      Das Attribut "FileName" gibt den Pfad der Datei an...

      Natürlich gibt es auch andere Methode, wie "WriteAllBytes", um Bytearrays in Dateien zu schreiben etc.
      Bei WriteAllText kann man auch wieder ein drittey Argument angeben, nämlich die Codierung.

      Die Syntax ist dann also:

      VB.NET-Quellcode

      1. System.IO.File.WriteAllText(String, String, Encoding)


      Dies ist wichtig, wenn Ihr die Datei später unter einer speziellen Codierung verwenden wollt!

      Zu guter Letzt jetzt noch wie man diese .txt Datei wieder öffnet:

      Dazu nehmen wir einen OpenFileDialog und machen exakt das Selbe!

      VB.NET-Quellcode

      1. OpenFileDialog.Filter = "Text-Dateien (*.txt)|*.txt


      VB.NET-Quellcode

      1. If OpenFileDialog.ShowDialog() = DialogResult.OK Then 'Prüfen, ob im OpenFileDialog "OK" gedrückt wurde.
      2. Dim readText As String = System.IO.ReadAllText(OpenFileDialog.FileName)
      3. TextBox1.Text = readtext
      4. End If


      So damit zeigen wir jetzt den Text der Datei in der TextBox1 an.
      Wie Ihr seht, muss man den Text der Datei erst noch in einer Variable speichern, da ReadAllText nur ein Argument besitzt.
      Dann können wir den Text der TextBox1 einfach dem der Variable entsprechen lassen.

      Auch hier gibt es wieder mehrere Methoden!
      Auch "ReadAllBytes" oder "ReadAllLines".
      Schaut euch die mal an!
      Natürlch kann "ReadAllText" auch zwei Argumente haben, wenn man die Codierung dazu nimmt.

      Die Syntax wäre dann:

      VB.NET-Quellcode

      1. System.IO.ReadAllText(String, Encoding)


      Um zu überprüfen, ob eine Datei vorhanden ist, nimmt man die Methode "Exists".

      VB.NET-Quellcode

      1. If File.Exists(Pfad zur Datei) Then
      2. 'Was tun
      3. End If




      Man kann noch viel mehr mit diesem Namespace machen!
      Dies war jetzt nur mal auf die "File"-Klasse bezogen! ABER:

      Nun noch zu FileInfo und DirectoryInfo etc.
      Spoiler anzeigen
      Damit das Thema auf Anfragen noch vollständig ist.
      Also zuerst zu FileInfo:
      Diese Klasse kann im Gegensatz zu "File" nicht vererbt werden.
      Es gibt auch hier wieder Methoden, wie kopieren, ersetzen, öffnen etc.
      Was ist jetzt der Unterschied?
      Der Unterschied zur "File"-Klasse ist, dass beim Erstellen, sowie beim Öffnen andere E/A Typen zurückgegeben werden.
      Mehr Infos könnt Ihr hier finden: Klick
      So, nun kommt der wichtigste Teil.
      Warum soll man "FileInfo" nun stattdessen verwenden?
      Das sollte geschehen, wenn Ihr mit den erstellten bzw. geöffneten Dateien weiterarbeiten wollt.
      Denn die hier zurückgegebenen Typen ermöglichen dies.
      Zudem ist nicht immer eine Sicherheitsprüfung erforderlich, wenn eine Datei mehrmals verwendet werden soll...
      Der Zugriff ist also hiermit dann problemlos gewährt!

      Nun zeige ich euch auch hier ein paar Methoden bzw. Eigenschaften:
      Da hier ja bereits vorher die Dateien geöffnet bzw. erstellt wurden, benötigt man hier bei den Parameter kein Argument für den Ausgangspfad etc.
      Allerdings müssen wir zuerst eine "FileInfo" deklarieren!

      VB.NET-Quellcode

      1. Dim fi As FileInfo = New FileInfo(Pfad zu eurer Datei)


      Um eine Datei nun in eine neue zu kopieren, schreiben wir:

      VB.NET-Quellcode

      1. System.IO.FileInfo.CopyTo(Neue Datei, True)


      Hier wird wegen dem "True" die Datei überschrieben, falls sie schon so existiert.
      Wenn Ihr das nicht wollt, dann spart euch das "False" und lasst das zweite Argument weg!


      Um eine Datei zu erstellen, benötigen wir einen "FileStream".
      Dann wird mit der "Create"-Methode eine neue Datei im oben angegebenen Pfad erstellt.

      VB.NET-Quellcode

      1. Dim fs As FileStream = fi.Create()


      So nun können wir noch Informationen zu dieser Datei hinzufügen!
      Wir nehmen an, es ist eine Textdatei.
      Dann schreiben wir:

      VB.NET-Quellcode

      1. Dim information As Byte() = New UTF8Encoding(True).GetBytes("Dies ist ein Text. ")


      Natürlich könnt Ihr auch ein anderes Encoding hernehmen.

      VB.NET-Quellcode

      1. fs.Write(information, 0, information.Length)


      Damit haben wir mit dem FileStream nun wie oben deklariert das "information" in die Datei geschrieben, sowie auch die Länge.

      Nun können wir sie jederzeit mit einem StreamReader wieder abrufen bzw. auslesen. Da wären wir auch schon bei der nächsten Methode. "OpenText".

      VB.NET-Quellcode

      1. Dim sr As New StreamReader = fi.OpenText()


      Natürlich gibt es auch nur "Open" als Methode für andere Dateitypen.
      Damit können wir nun den Text irgendwo anzeigen lassen, mit "ToString".
      Die einfachere Methode ist das Ganze mit "CreateText" und einem StreamWriter zu machen...
      Das war jetzt nur ein Beispiel, um gleich die Methoden zu implementieren.
      Es gibt auch Möglichkeiten schreibgeschützte Dateien zu erstellen etc.
      Wenn Ihr das Prinzip verstanden habt, dann schaut dazu hier.

      In den Eigenschaften könnt Ihr den Namen der Datei mit "Name, die Länge mit "Length" und alle Attribute mit "Attributes" abrufen.
      Es ist auch möglich den übergeordneten Pfad mit "Directory" abzurufen, was gleich zum nächsten Thema führt.
      Directories.
      Auch hier gibt es Methoden und Eigenschaften. (Wir nehmen DirectoryInfo aus dem selben Grund wie oben)
      Es ist eigentlich fast alles das Selbe wie oben mit FileInfo.

      Zuerst wieder den Pfad deklarieren:

      VB.NET-Quellcode

      1. Dim di As DirectoryInfo= New DirectoryInfo("Euer Pfad")


      Um einen Pfad zu erstellen schreiben wir dann genauso, nur mit "DirectoryInfo":

      VB.NET-Quellcode

      1. di.Create()


      Einen Pfad bzw. ein Verzeichnis löschen wir mit:

      VB.NET-Quellcode

      1. di.Delete()


      Auch hier kann man in einer "If"-Abfrage prüfen, ob der Pfad bereits existiert, um Fehler zu vermeiden.

      VB.NET-Quellcode

      1. If Directory.Exists(path) Then
      2. 'Etwas tun
      3. End If


      Dies ist sehr sinnvoll!

      Um nun zu guter Letzt noch Attribute abzurufen.

      Die Erstellzeit beispielsweise.
      Dazu gibt es "CreationTime"!

      Den letzten Zugriff können wir auch auslesen mit "LastAccessTime". Ich erkläre das jetzt nicht si genau, denn MSDN bietet da alle Attribute und wie man sie verwendet. ;)

      Mehr dazu hier.



      Ich hoffe, Ihr habt soweit alles ein wenig besser verstanden!
      Mfg programmer71

      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „programmer71“ ()

      Wenn du den Thread "System.IO Namespace richtig nutzen" nennst, dann würde ich eigentlich erwarten, dass vor allem die Klassen FileInfo und DirectoryInfo durchgenommen werden.
      Weil mit FileInfo kann man einerseits von ein und demselben Objekt alle wesentlichen DateiEigenschaften ablesen, wie Fullname, CreationTime, Length, Extension,... und v.a. obs ühaupt existiert.
      Weiters kann man mit demselben Objekt die Datei auch verschieben, kopieren, löschen - ja sogar öffnen kannmanse.
      Und wenn man FileInfo.Directory abruft hat man gleich das nächste Objekt, nämlich ein DirectoryInfo.
      Davon kann man direkt das ParentDirectory abrufen, aber auch alle ChildDirectories, sowie alle Files, auch gefiltert, wenns beliebt. Und natürlich gibt DirectoryInfo ebenso auch an, obs ühaupt existiert (und löschen, verschieben, neu erzeugen geht natürlich in gleicher Weise wie beim FileInfo).

      Also DriveInfo, FileInfo und DirectoryInfo sind wesentlich - alle anneren Vorgehensweisen, seis nun über den My-Namespace, über die File-Klasse, über die Directory-Klasse oder noch abstruseres - das alles sind fragwürdige Tricks ohne übergeordnetes Konzept, und im Grunde an den Prinzipien objektorientierter Programmierung vorbei.
      Zur Illustration gugge auch Keine Strings in die File-Listbox!
      Hi
      IO umfasst außerdem nicht nur Dateien, sondern i.A. Streams. D.h. du solltest ggf. auch noch BinaryReader, BinaryWriter, einen Bezug zum abstrakten Stream herausarbeiten und den allgemein beschreiben und wie man dann eben abstrakt auf Streambasis arbeitet. Da könnte man dann auch Pipes als Beispiel heranführen, um die Analogie zwischen Streams aufzuzeigen. Außerdem ist es eher kontraproduktiv, Dateien erst per Exists abzufragen und dann erst zu öffnen, da sie zwischendrin bereits fehlen können. Stattdessen einfach im richtigen Modus öffnen (siehe System.IO.FileStream-Konstruktoren) und FileNotFoundException und IOExeption abfangen. Da wäre es noch praktisch, wenn du kurz IO.FileMode darstellst.

      System.Text.Encoding enthält übrigens bereits Singletons, die die Standardencodings, also auch UTF8, bereitstellen.

      Ansonsten sicher praktisch. ;)

      Gruß
      ~blaze~

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()