Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

werken met System.IO: paden, bestanden en folders

tekst lezen en schrijven met StreamReader, StreamWriter en de File-klasse

het using-blok inzetten om bestanden netjes vrij te geven

binaire bestanden verwerken met BinaryWriter en BinaryReader

info opvragen met FileInfo en DirectoryInfo

objecten serialiseren naar en deserialiseren uit JSON

System.IO

Eén van de meest gebruikte namespaces: bestanden en folders lezen, schrijven, maken en verwijderen.

Tip

In een nieuw project staat System.IO al ter beschikking. Kent de compiler File of StreamWriter niet (een ouder project), zet dan bovenaan using System.IO;.

Je brengt echte wijzigingen aan op je harde schijf. Eén foutje wist zomaar gegevens (ja, ook mij is dat al overkomen)

Je hebt niet altijd de juiste rechten om een bestand te lezen of te schrijven

Twee tips voor je begint

Back-ups

Tot nu toe kon je code niets kapotmaken op je computer. Tijd voor die wekelijkse back-up!

Try-catch

Bestanden luisteren minder goed dan jij: niet waar je dacht, of geen rechten. Exception handling wordt vanaf nu essentieel.

Mijn eerste programma met bestanden

Welke films hebben nog geen ondertitels?

Rare tekens en reclame uit mp3-namen strippen

Darude Sandstorm for life.

Bestands- en folderlocaties

Paden

Elk bestand en elke folder heeft een unieke locatie, een path. In C# altijd een string.

c:\temp\mijnData.txt

De temp-folder zelf: c:\temp\

Een full path beschrijft de weg door de folders tot bij het bestand.

Een path is niet hoofdlettergevoelig: mijnData.txt en MijnData.TXT kunnen niet naast elkaar

macOS gebruikt forward slashes (/) in plaats van \

Een bestand zonder path

Geef je geen path, dan komt het bestand in de werkmap: de folder van waaruit je programma startte.

File.WriteAllText("doem.txt", "Het einde is nabij");
File.WriteAllText(@"c:\temp\doem.txt", "Het einde is nabij");

Vanuit Visual Studio: \bin\Debug\net10.0 van je project

Met dotnet run: de folder waarin je het commando typt

Waarschuwing

Lijn 2 werkt enkel op Windows. Op een Mac krijg je in de werkmap een bestand dat letterlijk c:\temp\doem.txt heet.

Geen schrijfrechten?

Heb je geen schrijfrechten voor een folder, dan krijg je een UnauthorizedAccessException. Gebruik dus exception handling:

try
{
    File.WriteAllText("doem.txt", "Het einde is nabij");
}
catch (UnauthorizedAccessException)
{
    Console.WriteLine("Geen schrijfrechten!");
}

System.IO.Path

Draait je programma op Windows of op een Mac? Met Path.Combine maak je paden die op beide werken:

string folder = "data";
string bestand = "dagboek.txt";
string fullPath = Path.Combine(folder, bestand);
Console.WriteLine(fullPath);

Windows:

data\dagboek.txt

macOS:

data/dagboek.txt

Tip

Ook in Path: ChangeExtension, GetFileNameWithoutExtension, GetRandomFileName (een naam die nog niet bestaat), GetTempPath (de temp-folder van de gebruiker), …

Speciale folders

Environment.GetFolderPath met de enum Environment.SpecialFolder vindt het bureaublad, “Mijn documenten”, … van de huidige gebruiker:

string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
string fullPath = Path.Combine(desktopPath, "doem.txt");
File.WriteAllText(fullPath, "Het einde is nabij");

Eerst controleren

if (File.Exists(fullPath))
{
    //werk met bestand
}
else
{
    Console.WriteLine("Dit bestand bestaat niet.");
}
string tempPath = Path.GetTempPath();
if (Directory.Exists(tempPath))
{
    //werk met folder
}

Overschrijf of verwijder nooit een bestand of folder zonder de gebruiker te waarschuwen.

Folder of bestand aanmaken

if (!Directory.Exists(tempPath))
{
    Directory.CreateDirectory(tempPath);
}
if (!File.Exists(fullPath))
{
    File.Create(fullPath);
}

Waarschuwing

File.Create geeft een FileStream terug die het bestand open houdt. Een volgende bewerking op dat bestand kan dan mislukken met een IOException. Sluit de stream meteen:

using (FileStream fs = File.Create(fullPath))
{
    //fs gaat automatisch dicht aan het einde van dit blok
}

Schrijven en lezen

Twee stromen

Een StreamWriter schrijft data naar het bestand; een StreamReader leest ze terug uit.

StreamWriter: schrijven

StreamWriter writer = new StreamWriter("doeeeeeem.txt", true);
writer.WriteLine("Game over!");

Net als bij Console gebruik je WriteLine. De tweede parameter:

true toevoegen achter de bestaande inhoud (append)

false inhoud weg, je start van een leeg bestand

Waarschuwing

Zo “bloot” gebruik je het beter niet. Een StreamWriter schrijft pas echt weg als hij gesloten wordt: vergeet je dat, dan staat er misschien niets in het bestand. Bij een fout blijft het bestand bovendien open (en gelockt). Verderop lossen we dat op met using.

StreamReader: lezen

StreamReader reader = new StreamReader("doeeeeeem.txt");
string regel;

while ((regel = reader.ReadLine()) != null)
{
    Console.WriteLine(regel);
}

De conditie op lijn 4 doet twee zaken:

de volgende lijn uitlezen met ReadLine

controleren op null: dat krijg je aan het einde van het bestand

Het using-blok

using kent je al voor namespaces. Rond een object zorgt het ervoor dat dat object netjes opgeruimd wordt, ook als er een fout optreedt:

using (StreamWriter writer = new StreamWriter("doem.txt"))
{
    writer.WriteLine("Het einde is nabij!");
    writer.WriteLine("Hou vol!");
}

Bij de accolade op lijn 5 roept C# de Dispose-methode van writer aan: het bestand wordt vrijgegeven.

Tip

Vanaf nu zetten we altijd een using rond een StreamWriter of StreamReader. (Klassen met Dispose implementeren de interface IDisposable.)

De kortere using-declaratie

Sinds C# 8 mag het ook zonder accolades. Het object wordt dan opgeruimd aan het einde van het omliggende blok, bv. de methode:

using StreamWriter writer = new StreamWriter("doem.txt");
writer.WriteLine("Het einde is nabij!");
writer.WriteLine("Hou vol!");
//writer gaat automatisch dicht aan het einde van de methode

Beide vormen zijn correct. Visual Studio stelt deze kortere vorm vaak voor.

File.ReadAllText of StreamReader?

De File-klasse kan een bestand in één keer inlezen, zonder lus:

string alles = File.ReadAllText("dagboek.txt");
string[] regels = File.ReadAllLines("dagboek.txt");

Klein bestand, in één keer

File.ReadAllText / ReadAllLines (kort en leesbaar)

Groot bestand of regel per regel

StreamReader met de while-lus: nooit het hele bestand tegelijk in het geheugen

Tip

Er bestaan ook asynchrone varianten, zoals await File.ReadAllTextAsync("dagboek.txt"), zodat je programma niet “bevriest”. Hoe async/await werkt, zien we hier nog niet.

Uitgewerkt: een dagboek

string dagboekPath = "dagboek.txt";
if (!File.Exists(dagboekPath))
{
    //meteen sluiten met using
    using (FileStream fs =
        File.Create(dagboekPath)) { }
}

// dagboek tonen
Console.WriteLine("Dagboek:");
using (StreamReader reader =
    new StreamReader(dagboekPath))
{
    string regel;
    while ((regel = reader.ReadLine()) != null)
    {
        Console.WriteLine(regel);
    }
}
//dagboek schrijven
Console.WriteLine(
    "\nGeef je volgende dagboekschrijfsel:");
string entry = Console.ReadLine();

using (StreamWriter writer =
    new StreamWriter(dagboekPath, true))
{
    writer.WriteLine($"\n{DateTime.Now}");
    writer.WriteLine(entry);
}

Bij elke start toont het programma de bestaande schrijfsels; daarna voeg je er één toe, met datum en tijd via DateTime.Now.

Binaire bestanden

Een bestand openen met File.Open

Een BinaryWriter schrijft elk primitief datatype weg, niet enkel strings. Je opent het bestand met File.Open en een FileMode:

FileStream fs = File.Open("bondData.dat",
    FileMode.Create);
using (BinaryWriter writer = new BinaryWriter(fs))
{
    //...

Dankzij IntelliSense hoef je de zes mogelijkheden niet vanbuiten te kennen.

Create: nieuw bestand, een bestaand wordt overschreven

Open: bestaand bestand openen (anders FileNotFoundException)

Verder nog Append, CreateNew, OpenOrCreate en Truncate

BinaryWriter: schrijven met Write

var fs = File.Open("bondData.dat", FileMode.Create);
using (BinaryWriter writer = new BinaryWriter(fs))
{
    writer.Write("Bond");
    writer.Write(7);
    writer.Write(true);
}

Een bestand van 10 bytes:

5 "Bond": 4 karakters + 1 byte voor de lengte

4 de int

1 de bool

Opmerking

Schrijf je ook nog "Gadget", 42, false, 3.14159 en 'A' weg: 7 + 4 + 1 + 8 (double) + 1 ('A' in UTF-8, in het geheugen is een char 2 bytes) = 21 bytes.

BinaryReader

var fs = File.Open("bondData.dat", FileMode.Open);
using (BinaryReader reader = new BinaryReader(fs))
{
    string naam = reader.ReadString();
    int code = reader.ReadInt32();
    bool leeftNog = reader.ReadBoolean();
    Console.WriteLine($"{naam} ({code}). Leeft nog = {leeftNog}");
}

Write("Bond") ReadString()

Write(7) ReadInt32()

Write(true) ReadBoolean()

Belangrijk

De volgorde is cruciaal: de methoden lezen gewoon het aantal bytes van hun type. Wissel je ReadInt32 en ReadBoolean om, dan crasht het niet, maar krijg je onzin (code wordt 16777216). Lees je meer bytes dan er zijn, dan volgt een EndOfStreamException.

De ruwe bytes bekijken

File.ReadAllBytes geeft een byte[]. Met X2 toon je elke byte hexadecimaal:

byte[] inhoud = File.ReadAllBytes("bondData.dat");
foreach (byte b in inhoud)
{
    Console.Write($"{b:X2} ");
}
04 42 6F 6E 64 07 00 00 00 01

04: de lengte van de string

42 6F 6E 64: “B, o, n, d”

07 00 00 00: het getal 7

01: true

Little-endian

Waarom staat 7 als 07 00 00 00 en niet als 00 00 00 07?

Een int wordt little-endian opgeslagen: de minst significante byte (least significant byte) eerst.

1000 is 3E8 hexadecimaal en staat in het bestand als:

E8 03 00 00

De FileInfo klasse

FileInfo: meer informatie

Je maakt eerst een object aan met het path:

FileInfo info =
    new FileInfo("bondData.dat");
if (info.Exists)
{
    Console.WriteLine(
      $"Bestandsnaam: {info.Name}");
    Console.WriteLine(
      $"Grootte: {info.Length/1024} kB");
}
Property Info
Name bestandsnaam
FullName volledige pad
Extension extensie, bv. “.txt”
Length grootte in bytes
CreationTime aangemaakt op (DateTime)
LastAccessTime laatst geopend
LastWriteTime laatst gewijzigd
Exists bestaat het?

Allemaal read-only.

Kopiëren, verplaatsen en verwijderen

FileInfo info = new FileInfo("bondData.dat");
if (info.Exists)
{
    info.CopyTo("supermanData.dat");
    info.MoveTo("bond2Data.dat");
    info.Delete();
}

Lijn 4: een kopie supermanData.dat

Lijn 5: bondData.dat heet nu bond2Data.dat

Lijn 6: het origineel wordt verwijderd, ook al werd het hernoemd

Opmerking

Wat blijft er over in de folder? Enkel supermanData.dat.

File of FileInfo?

File is een static klasse

Je roept de methoden rechtstreeks op de klassenaam aan, zoals File.Exists(...). Werkt altijd instantaan met het bestand. Handig voor iets kort en krachtig.

FileInfo maak je met new

Leest de info bij de constructie en bij een Refresh. Handig voor meerdere bewerkingen na elkaar.

Tip

Geen harde wet. Gebruik voorlopig wat jij het prettigst vindt. Hetzelfde verschil geldt voor Directory (static) en DirectoryInfo.

DirectoryInfo

GetFiles en GetDirectories geven een array van FileInfo- en DirectoryInfo-objecten:

DirectoryInfo tempInfo = new DirectoryInfo(@"C:\temp");
if (tempInfo.Exists)
{
    var bestanden = tempInfo.GetFiles();
    var folders = tempInfo.GetDirectories();

    foreach (var folder in folders)
        Console.WriteLine($"Folder:{folder.Name}");
    foreach (var bestand in bestanden)
        Console.WriteLine(bestand.Name);
}

Filteren en zoeken in subfolders

Een searchPattern met * en ?:

var tekstBestanden = tempInfo.GetFiles("*.txt");
var timBestanden = tempInfo.GetFiles("Tim?.*");

Tim?.*: start met “Tim”, dan nog 1 teken, extensie maakt niet uit.

Ook in de subfolders zoeken:

var gevonden = tempInfo.GetFiles("*.txt", SearchOption.AllDirectories);

Recursief een folderstructuur verwerken

Een recursieve methode roept zichzelf aan, tot er geen subfolders meer zijn:

static void ToonFoldersEnBestanden(string path)
{
    foreach (string bestand in Directory.GetFiles(path))
    {
        Console.WriteLine(bestand);
    }

    foreach (string folder in Directory.GetDirectories(path))
    {
        Console.WriteLine(folder);
        ToonFoldersEnBestanden(folder);
    }
}

Tip

Een klassieke fout bij recursie: geen stopvoorwaarde. Hier stopt het vanzelf. Maar voer je dit uit op “c:”, dan verschijnt er wel heel veel tekst.

Stagiair Steven

Steven opent een logbestand. De A.I. vulde een pad in, en bij Steven werkt het:

FileInfo info = new FileInfo(@"C:\Users\Steven\Documents\log.txt");
Console.WriteLine(info.Exists);

Hij stuurt het door naar een collega. Bij haar geeft Exists altijd false, terwijl het bestand er wél staat.

Waarom werkt Steven z’n code enkel op zijn eigen pc?

Stagiair Steven: wat liep er mis?

Opmerking

Steven hardcodeerde een absoluut pad met zijn eigen gebruikersnaam erin. Op de pc van zijn collega bestaat C:\Users\Steven\... niet.

Werk met een relatief pad (gewoon "log.txt", naast je programma), of bouw paden op met Path.Combine en Environment.GetFolderPath, zodat op elke computer de juiste map ingevuld wordt.

Klassen serialiseren

Serialiseren: het idee

Objecten wegschrijven met een StreamWriter (alles van en naar string) of een BinaryWriter (opletten met de volgorde) is lastig. Serialiseren zet de inhoud van een object “in serie” in een bestand; deserialiseren bouwt het terug op.

Serialiseren zet een object om naar tekst (bv. JSON); deserialiseren bouwt het object terug op.

Zo maak je letterlijk een savepoint van je programma.

Waarom JSON?

Binair: compact en snel, maar onleesbaar en haast niet met de hand aan te passen

Tekst: leesbaar, maar jij moet bepalen welke string welk datatype voorstelt

JSON (JavaScript Object Notation): het beste van beide werelden

{
    "student": {
        "naam": "barry",
        "leeftijd": 25,
        "uitgeschreven": true
    }
}
<student>
    <naam>Barry</naam>
    <leeftijd>25</leeftijd>
    <uitgeschreven>true</uitgeschreven>
</student>

JSON is de spirituele opvolger van XML: minder tags, beter leesbaar.

Arrays en geneste objecten in JSON

Sleutel-waarde-paren, en vierkante haken voor een array:

{
    "school": {
        "naam": "AP Hogeschool",
        "locatie": "Antwerpen",
        "studenten": [
            { "naam": "Barry", "leeftijd": 25, "uitgeschreven": true },
            { "naam": "Anna", "leeftijd": 22, "uitgeschreven": false }
        ]
    }
}

Serialiseren in C#

using System.Text.Json;
using System.Text.Json.Serialization;
using System.IO;

public class Student
{
    public string Naam { get; set; }
    public int Leeftijd { get; set; }
    public bool Uitgeschreven { get; set; }
}
var student = new Student
  { Naam = "Barry", Leeftijd = 25, Uitgeschreven = true };
string jsonString = JsonSerializer.Serialize(student);
File.WriteAllText("studentdata.json", jsonString);

Enkel de publieke kant van een object wordt geserialiseerd: hier merk je waarom properties zo belangrijk zijn. Maak ook je klasse public.

studentdata.json

{"Naam":"Barry","Leeftijd":25,"Uitgeschreven":true}

Leesbaarder, en hele lijsten

var opties = new JsonSerializerOptions
    { WriteIndented = true };
string jsonString =
    JsonSerializer.Serialize(student, opties);
{
  "Naam": "Barry",
  "Leeftijd": 25,
  "Uitgeschreven": true
}

Een hele List<Student> serialiseer je op dezelfde manier: je krijgt een JSON-array terug. Ook geneste objecten gaan mee, zolang het publieke properties zijn.

Tip

Online zie je vaak Newtonsoft.Json. Gebruik in de plaats de ingebouwde System.Text.Json van Microsoft.

Deserialiseren

De methode is generic: je geeft tussen < > het verwachte type mee, net zoals bij List<Student>. Uit een string alleen kan ze niet raden bij welke klasse de data hoort.

string jsonText = File.ReadAllText("studentdata.json");
Student ingeladen = JsonSerializer.Deserialize<Student>(jsonText);

Serialisatiegedrag bijsturen

Attributen staan tussen vierkante haken boven een klasse-element. Ze hebben niets met arrays te maken: ze geven je code meta-informatie.

public class Student
{
    public string Naam
        {get;set;}
    [JsonIgnore]
    public bool Uitgeschreven
        {get;set;}
}

Uitgeschreven wordt overgeslagen

public class Student
{
    [JsonPropertyName("VolledigeNaam")]
    public string Naam {get;set;}
}

in de JSON: {"VolledigeNaam":"Barry"}

public class Student
{
    public string Naam
        {get;set;}
    [JsonInclude]
    private int leeftijd = 20;
}

de private leeftijd gaat toch mee

Waarschuwing

Online vind je attributen van Newtonsoft.Json en van System.Text.Json. Die zijn vaak nét niet hetzelfde.

Bonus: Paste JSON as Classes

Onbekende, complexe JSON van bv. een web-API? Laat VS de klassen voor je schrijven:

kopieer de JSON

nieuw, leeg klasse-bestand (enkel de namespace blijft staan)

Edit - Paste Special - Paste JSON as Classes

BOEM!

De meest onderschatte VS-feature.

Conclusie

System.IO geeft toegang tot de harde schijf: werk voorzichtig, met Path.Combine en exception handling

StreamReader/StreamWriter (in een using-blok) en de File-klasse lezen en schrijven tekst

BinaryWriter/BinaryReader verwerken elk primitief datatype, maar de volgorde telt

FileInfo en DirectoryInfo geven info en bewerkingen; File en Directory zijn static

JSON-serialisatie maakt een leesbaar savepoint van je objecten

Tip

En dat was het laatste hoofdstuk. Je bent van “Hello World!” tot serialisatie geraakt: dik verdiend. Blijf vooral oefenen en bouwen.

Meer weten

Kennisclips

Oefeningen H18 · Quizlet flashcards

Zie verder

Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.

Zie verder: zoek de fout

Onderstaande Python-code schrijft een dagboekregel weg, maar het bestand blijft soms leeg of half geschreven, zeker als er verderop iets misloopt. Wat zou je beter doen?

f = open("dagboek.txt", "w")
f.write("Beste dagboek...")
# code die crasht voor de volgende regel
f.close()

Opmerking

Als de code tussen open en close crasht, wordt f.close() nooit bereikt en blijft het bestand open (en mogelijk leeg of gelockt). Gebruik een with open(...)-blok: dan sluit Python het bestand sowieso, net zoals een using-blok in C#.

with open("dagboek.txt", "w") as f:
    f.write("Beste dagboek...")

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf