Manipuleren van bestanden en directories

In het vorige hoofdstuk bekeken we het lezen en schrijven van tekst met eenvoudige bestanden. We gebruikten de File class hiervoor, maar die kan veel meer dan alleen maar lezen en schrijven. Als we hem combineren met de Directory class, kunnen we vrijwel elke bestandssysteem handeling uitvoeren, zoals 'naam wijzigen', 'verplaatsen', 'wissen' enzovoorts.

Dit hoofdstuk geeft talloze voorbeelden om die dingen te doen. De uitleg zal beperkt zijn, want de methods zijn simpel en gemakkelijk te gebruiken. Je moet aan twee dingen denken: Denk allereerst aan de invoer van de System.IO namespace. Doe dat op deze manier:

using System.IO;

Weet ook dat we hier niet aan exception handling doen. We checken vooraf of bestanden en directories bestaan, maar omdat er geen exception handling is, zal de zaak crashen als er iets fout gaat. Exception handling is over het algemeen juist een goed idee als je bezig bent met IO operaties. Lees voor meer informatie het hoofdstuk over exception handling in dit tutorial.

In alle voorbeelden gebruiken we eenvoudige bestands- en directory namen, die in dezelfde directory moeten bestaan als het gecreëerde EXE bestand van je applicatie. In de project settings kun je zien waar het EXE bestand is opgeslagen.

Het wissen van een bestand

if(File.Exists("test.txt"))
{
    File.Delete("test.txt");
    if(File.Exists("test.txt") == false)
    Console.WriteLine("File deleted...");
}
else
    Console.WriteLine("File test.txt does not yet exist!");
Console.ReadKey();

Het wissen van een directory

if(Directory.Exists("testdir"))
{
    Directory.Delete("testdir");
    if(Directory.Exists("testdir") == false)
    Console.WriteLine("Directory deleted...");
}
else
    Console.WriteLine("Directory testdir does not yet exist!");
Console.ReadKey();

Als testdir niet leeg is, ontvang je een exception. Waarom? Omdat deze versie van Delete() in de Directory class alleen werkt bij lege directories. Dat is echter gemakkelijk te veranderen:

Directory.Delete("testdir", true);

De extra parameter maakt het zeker dat de Delete() method recursief is, wat betekent dat het door subdirectories heenloopt en de bestanden erin wist, alvorens de directories te wissen.

Bestandsnaam wijzigen

if(File.Exists("test.txt"))
{
    Console.WriteLine("Please enter a new name for this file:");
    string newFilename = Console.ReadLine();
    if(newFilename != String.Empty)
    {
    File.Move("test.txt", newFilename);
    if(File.Exists(newFilename))
    {
        Console.WriteLine("The file was renamed to " + newFilename);
        Console.ReadKey();
    }
    }
}

Je ziet dat we de Move() method gebruiken om de naam van het bestand te wijzigen. Waarom geen Rename() method? Omdat zo'n method niet bestaat en verplaatsen en hernoemen in essentie hetzelfde is.

Een directorynaam wijzigen

Hetzelfde doen met een directory is net zo gemakkelijk:

if(Directory.Exists("testdir"))
{
    Console.WriteLine("Please enter a new name for this directory:");
    string newDirName = Console.ReadLine();
    if(newDirName != String.Empty)
    {
    Directory.Move("testdir", newDirName);
    if(Directory.Exists(newDirName))
    {
        Console.WriteLine("The directory was renamed to " + newDirName);
        Console.ReadKey();
    }
    }
}

Een nieuwe directory maken

Een splinternieuwe directory maken is eveneens gemakkelijk. Gebruik gewoon de CreateDirectory() method in de Directory class, zoals hier:

Console.WriteLine("Please enter a name for the new directory:");
string newDirName = Console.ReadLine();
if(newDirName != String.Empty)
{
    Directory.CreateDirectory(newDirName);
    if(Directory.Exists(newDirName))
    {
    Console.WriteLine("The directory was created!");
    Console.ReadKey();
    }
}

Lezen & Schrijven van Bestanden

Als laatste voorbeeld laat ik je zien hoe de File class het ons gemakkelijk maakt om te lezen ván en te schrijven náár een bestand. Dit kan met C# op een heleboel manieren gebeuren, maar de Read* en Write* methods van de File class zijn wellicht het gemakkelijkst in het gebruik. Er zijn drie versies: WriteAllBytes(), WriteAllLines() en WriteAllText(), met corresponderende Read methods. De simpelste is de laatste die een simpele string als input neemt. Via een eenvoudig voorbeeld zal ik illustreren hoe het werkt:

string fileContents = "John Doe & Jane Doe sitting in a tree...";
File.WriteAllText("test.txt", fileContents);

string fileContentsFromFile = File.ReadAllText("test.txt");
Console.WriteLine(fileContentsFromFile);

Kijk maar eens hoe weinig code nodig is om iets naar een bestand te schrijven en het daarna terug te lezen! De eerste parameter in beide methods is het pad waar naartoe de tekst moet worden geschreven en waarvan moet worden gelezen. Normaal gesproken zou je hier een volledig pad specificeren, maar om het voorbeeld duidelijker te maken, specificeer ik alleen de bestandsnaam, hetgeen ertoe leidt dat het bestand naar dezelfde directory wordt geschreven als van het EXE bestand.

Samenvatting

Zoals je kunt zien, zijn File en Directory classes een geweldige steun als je met bestanden en directories moet werken. Ze helpen je de meeste noodzakelijke handelingen te doen, en als je nog meer gevorderd spul zou moeten doen, dan kunnen deze classes en hun methods prima dienen als geweldige bouwstenen om op voort te bouwen.