Dateien lesen, schreiben und verarbeiten
C# Workshop, TU Darmstadt 2008,
Präsentation von Qiong Wu (Microsoft Junior Student Partner)

 Input / Output
 Zugriff auf Dateien und Ordner
 Arbeiten mit Byte Streams
 Reader und Writer Klassen verwenden
 Komprimieren und Dekomprimieren von Daten
 Isolated Storage

Output
Input

Application Output

Application Input

 System.IO Namespace
 Informelle Klassen
▪ FileSystemInfo
▪ FileInfo
▪ DirectoryInfo
▪ DriveInfo
 Manipulierende Klassen
▪ File
▪ Directory
▪ Path

 Bietet Zugriff auf Informationen von Dateien
und Ordnern
 Basisklasse für FileInfo und DirectoryInfo

 Bietet Zugriff auf Informationen von Dateien

FileInfo deklarieren Dateipfad
FileInfo NewFile = new FileInfo(@\"C:\\NewTextFile.txt\");
if (NewFile.Exists) Existiert die Datei?
{
Console.WriteLine(\"Name: \" + NewFile.Name);
Console.WriteLine(\"Fullname: \" + NewFile.FullName);
Console.WriteLine(\"Size: \" + NewFile.Length + \" bytes\");
}
Attribute abfragen

FileInfo deklarieren Dateipfad
FileInfo NewFile = new FileInfo(@\"C:\\NewTextFile.txt\");
if (NewFile.Exists) Existiert die Datei?
{
NewFile.CopyTo(@\"C:\\NewTextFileCopy.txt\", true);
}
Überschreiben
wenn Datei bereits
vorhanden Datei kopieren

 Bietet
 Zugriff auf Informationen von Ordnern
 Auflistung von Ordnerinhalten
 Elementaren Zugriff auf Ordner

DirectoryInfo deklarieren Ordnerpfad
DirectoryInfo ourDir = new DirectoryInfo(@\"C:\\windows\");
Console.WriteLine(\"Directory: \" + ourDir.FullName);
foreach (FileInfo file in ourDir.GetFiles()) Attribute
{ abfragen
Console.WriteLine(\"File: \" + file.Name);
}
Ordnerinhalt
enumerieren

 Bietet
 Zugriff auf Informationen von Laufwerken
▪ Speicherplatz
▪ Format
▪ Laufwerkstyp
▪ Name
▪ Status
 Erbt nicht von FileSystemInfo

Laufwerke
abrufen
DriveInfo[] drives = DriveInfo.GetDrives();
foreach (DriveInfo drive in drives)
{
Console.WriteLine(\"Drive: \" + drive.Name);
Console.WriteLine(\"Type: \" + drive.DriveType);
if (drive.IsReady)
{
Console.WriteLine(\"Free Space: \" + drive.AvailableFreeSpace +
\" bytes\");
}
}
Attribute
abfragen

 Bietet Zugriff auf Pfadmanipulationen
 Größtenteils oft benutzte
Stringmanipulationen für Dateipfade
 Path.Combine für Plattformunabhängigkeit
wichtig!

2 Pfade kombinieren
Console.WriteLine(Path.Combine(\"C:\\\\Windows\",
\"System32\\\\rundll.exe\"));
Console.WriteLine(Path.GetExtension(Path.Combine(\"C:\\\\Windows\",
\"System32\\\\rundll.exe\")));
Dateierweiterung
abfragen

 Auf Veränderungen im Dateisystem reagieren
 FileSystemWatcher
 Enable/disable
 Filter Events
 Auf Events registrieren
 Changed
 Created
 Deleted
 Renamed

FileSystemWatcher
static void FileSystemWatcherTest() deklarieren
{
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = @\"c:\\\";
Zu überwachendes Verzeichnis
watcher.Created += new FileSystemEventHandler(watcher_Changed);
watcher.Renamed += new RenamedEventHandler(watcher_Changed);
watcher.Deleted += new FileSystemEventHandler(watcher_Changed);
watcher.Changed += new FileSystemEventHandler(watcher_Changed);
watcher.EnableRaisingEvents = true; Auf Events
}
Eventauslösung
aktivieren registrieren
static void watcher_Changed(object sender, FileSystemEventArgs e)
{
Console.WriteLine(\"Directory changed(\" + e.ChangeType + \"): \" + e.FullPath);
}
Auf Änderungen
reagieren

 Zugriff auf Datenströme
 Stream Objekt
 Stream Klassen
▪ MemoryStream
▪ CryptoStream
▪ NetworkStream
▪ GZipStream
 Zugriff über StreamWriter / StreamReader

 Zugriff auf Streams wie
auf ein Videoband
 Abstraktion für
sequentielle
Datenvorgänge

 FileStream Objekt erstellen
 Zu öffnende Datei bestimmen
 mit Konstruktor
 mit File.Open
 FileMode festlegen
 Öffnen
 Schreiben
▪ Erstellen
▪ Anhängen

 statische Methoden für
 Erzeugung von Datenstreams
▪ FileAccess
▪ FileMode
 Einfache Dateimanipulation
▪ Kopieren
▪ Löschen
▪ Existenz prüfen
▪ Größe
▪ Etc.

 Statische Methoden für
 Erzeugung von Verzeichnissen
 Verändern von Verzeichnissen
 Löschen von Verzeichnissen
 Abfragen von Verzeichnisattributen

 Schreiben / Lesen von Text in einen
beliebigen Stream
 Zeichen
 Zeile
 Absatz
 Bis zum Ende
 Übergabe eines Stream Objekts
 Benutzung wie Console
 Gesamten Inhalt auslesen mit ReadToEnd()

Datei erstellen mit File
StreamWriter deklarieren Klasse
StreamWriter Tex;
Tex = File.CreateText(\"C:\\\\NewTextFile.txt\");
Wert schreiben
Tex.WriteLine(\"Hello World with StreamWriter\");
Console.WriteLine(\"File with name: \" +
((FileStream)Tex.BaseStream).Name + \" was written succesfully\");
Tex.Close();
BasisStream abfragen
StreamWriter schließen

StreamReader deklarieren
StreamReader re;
re = File.OpenText(\"C:\\\\NewTextFile.txt\");
Console.WriteLine(re.ReadToEnd());
re.Close();
Datei öffnen mit File Klasse
StreamReader schließen
Inhalte der Datei ausgeben

 Schreiben / Lesen von binären Daten in einen
beliebigen Stream
 Gleiches Handling wie StreamWriter / Reader

FileStream erstellen
FileStream BinaryStream = File.Create(@\"C:\\NewBinary.bin\");
BinaryWriter bTex = new BinaryWriter(BinaryStream);
bTex.Write(\"this is binary\"); BinaryWriter mit
bTex.Write(true); Stream
bTex.Write('4'); initialisieren
bTex.Close();
Daten in
Stream schließen Stream
schreiben

FileStream erstellen
FileStream newFile =
File.Open(@\"C:\\NewBinary.bin\", FileMode.Open);
BinaryReader reader = new BinaryReader(newFile);
string s = reader.ReadString(); BinaryReader mit
bool b = reader.ReadBoolean(); Stream
char c = reader.ReadChar(); initialisieren
reader.Close();
Daten aus
Stream schließen
Stream
lesen

 Warum
 Schreiben auf Festplatte oft inperfomant
 Kein Erstellen von temporären Dateien erwünscht
 Benutzbar mit StreamWriter / Reader
 Handling wie FileStream

MemoryStream memStrm = new MemoryStream();
MemoryStream deklarieren
StreamWriter writer = new StreamWriter(memStrm);
writer.WriteLine(\"Hello\");
writer.WriteLine(\"Goodbye\");
Daten
Schreiben Stream an Writer übergeben
schreiben writer.Flush();
erzwingen
FileStream theFile = File.Create(@\"c:\\inmemory.txt\");
memStrm.WriteTo(theFile);
Stream in
writer.Close(); Datei
theFile.Close(); schreiben
memStrm.Close();

 Warum
 FileStream schreibt direkt auf Festplatte
▪ Inperfomant
 Hybride Mischung aus MemoryStream &
FileStream
 Kompatibel mit StreamWriter / Reader
 Handling wie FileStream

FileStream
erstellen
FileStream newFile = File.Create(@\"c:\\test.txt\");
BufferedStream buffered = new BufferedStream(newFile);
StreamWriter writer = new StreamWriter(buffered);
writer.WriteLine(\"Some data\");
FileStream
writer.Close();
übergeben
BufferedStream
deklarieren
StreamWriter mit
BufferedStream
erstellen

 Speichern von Rohdaten benötigt viel Platz
 Kompression – ein wichtiges Feld der
Informatik
 Durch Kompression wird mehr Bandbreite
ermöglicht als durch Hardwareoptimierung
 Digitales Zeitalter setzt auf Kompression
 Eingebaute Kompression in C#
 DeflateStream
 GZipStream
 NameSpace: System.IO.Compression

 Gleicher Kompressionsalgorithmus
 Ähnlicher Umgang
 GZipStream
 Header mit zusätzlichen Informationen
▪ Bessere Kompatibilität
 Für Verteilung von Komprimierten Daten
 Arbeit auf mehreren Platformen
 DeflateStream
 verzichtet auf zusätzliche Informationen
▪ Geringerer Speicherverbrauch
 Single System Kompression

 Handling wie FileStream
 Wrapping um bestehenden FileStream
 CompressionMode Enum als
Konstrukturargument

FileStreams
FileStream sourceFile = File.OpenRead(@\"c:\\test.txt\"); erstellen
FileStream destFile = File.Create(@\"c:\\test.zip\");
GZipStream GZipStream =
new GZipStream(destFile, CompressionMode.Compress);
int theByte = sourceFile.ReadByte();
while (theByte != -1) GZipStream um
{ FileStream
GZipStream.WriteByte((byte)theByte); wrappen
theByte = sourceFile.ReadByte();
}
GZipStream.Close();
sourceFile.Close(); Daten
destFile.Close(); schreiben

FileStream sourceFile = File.OpenRead(@\"c:\\test.zip\");
FileStream destFile = File.Create(@\"c:\\test.txt\");
GZipStream compStream =
new GZipStream(sourceFile,
CompressionMode.Decompress);
int theByte = compStream.ReadByte();
while (theByte != -1)
{
destFile.WriteByte((byte)theByte);
theByte = compStream.ReadByte();
}
compStream.Close();
destFile.Close();
sourceFile.Close();

 SharpZipLib
 Tar
 GZIP
 ZIP
 BZIP2

 OpenFileDialog
 SaveFileDialog

OpenFileDialog
deklarieren
OpenFileDialog NewFileDialog = new OpenFileDialog();
NewFileDialog.Filter = \"Textdateien (*.txt)|*.txt|Alle Dateien
(*.*)|*.*\";
if (NewFileDialog.ShowDialog() == DialogResult.OK) Filter festlegen
{
string s = NewFileDialog.FileName;
MessageBox.Show(s);
}
Dateinamen Result abfragen
abfragen

SaveFileDialog
deklarieren
SaveFileDialog NewFileDialog = new SaveFileDialog();
NewFileDialog.Filter = \"Textdateien (*.txt)|*.txt|Alle Dateien
(*.*)|*.*\";
if (NewFileDialog.ShowDialog() == DialogResult.OK) Filter festlegen
{
string s = NewFileDialog.FileName;
MessageBox.Show(s);
}
Result abfragen
Dateinamen
abfragen

 Warum
 Direkter Zugriff auf das Dateisystem birgt Risiken
 SandBox Konzept bietet optimalen Tradeoff
zwischen Sicherheit und Funktion
 IsolatedStorageFile Klasse
 Erstellung eines Stores
 NameSpace: System.IO.IsolatedStorage

 Scope definiert den Kontext des Stores
 Assembly / Machine
▪ Spezifiziert für die Maschine / Assembly
▪ Anwendungsdaten
▪ GetMachineStoreForAssembly()
 Assembly / User
▪ Spezifiziert für die Assembly / User
▪ Userbezogene Daten
▪ GetUserStoreForAssembly()

 Wie FileStream aber
 Speziell um Dateien aus Isolated Storage zu lesen
 Kompatibel mit StreamReader / Writer

Isolated Storage
anfordern
IsolatedStorageFile userStore =
IsolatedStorageFile.GetUserStoreForAssembly(); Isolated FileStream
erstellen
IsolatedStorageFileStream userStream = new
IsolatedStorageFileStream(\"UserSettings.set\", FileMode.Create,
userStore);
StreamWriter userWriter = new StreamWriter(userStream);
userWriter.WriteLine(\"User Prefs\");
userWriter.Close();
Daten in Stream
schreiben

 Isolated Storage ist wie ein virtuelles
Laufwerk
 Ordnerstruktur
 Dateistruktur
 Abrufen von Ordnerliste mit
GetDirectoryNames()
 Abrufen von Dateiliste mit GetFileNames()

Isolated Storage
anfordern
IsolatedStorageFile userStore =
IsolatedStorageFile.GetUserStoreForAssembly();
foreach (string isofilename in userStore.GetFileNames(\"*\"))
{
MessageBox.Show(isofilename);
}
Dateien abrufen

 Wir haben gelernt
 Umgang mit Dateien
▪ Datei / Ordner / Laufwerksinformationen abfragen
▪ Änderungen in der Ordnerstruktur überwachen
▪ Streams aus Dateien erstellen
 Umgang mit Streams
▪ Dateien bearbeiten mit FileStream
▪ Speicher schreiben / lesen mit MemoryStream
▪ Effizient Dateien schreiben mit BufferedStream
▪ Schreiben und Lesen mit StreamWriter / Reader
▪ Komprimierung mit GZipStream / DeflateStream
 FileDialoge
▪ Abfragen von Speicherorten
 Isolated Storage
▪ Sandboxfunktionen des .net Frameworks nutzen