Je hebt vast al eens een digitaal horloge of de klok op je smartphone bekeken. Maar heb je je ooit afgevraagd hoe een computer tijd bijhoudt? Hoe kan een computer weten wat “nu” is, of hoeveel tijd er is verstreken tussen twee momenten? In dit leesmateriaal duiken we in de fascinerende technische achtergrond van hoe C# (en computers in het algemeen) met tijd werken.
Computers zijn geweldig in het werken met getallen, maar tijd is een ingewikkeld concept. Denk maar eens na over al deze vragen:
De oplossing die computers gebruiken is verrassend elegant: ze tellen gewoon!
In C# wordt tijd intern opgeslagen als een getal genaamd ticks. Een tick is een ongelooflijk kleine tijdseenheid:
1 tick = 100 nanoseconden = 0,0000001 seconden
Dat is één tien-miljoenste van een seconde! Waarom zo klein? Omdat dit computers toelaat om tijd met extreme precisie bij te houden.
Maar tellen vanaf waar? C# heeft een vast startpunt gekozen: 1 januari 0001, om 00:00:00. Dit wordt ook wel de “epoch” genoemd (let op: dit is anders dan bijvoorbeeld Unix-tijd, die start op 1 januari 1970).
Elk moment in de tijd kan dus worden uitgedrukt als het aantal ticks sinds dit nulpunt. Bijvoorbeeld:
Het gebruik van ticks heeft belangrijke voordelen:
Verschil = Moment2.Ticks - Moment1.Ticks
Geen verwarring: Een getal is een getal, geen gedoe met “30 of 31 dagen in een maand?” of “was 2000 een schrikkeljaar?”.
Precisie: Je kunt tot op de nanoseconde nauwkeurig zijn als dat nodig is.
Natuurlijk is “637890240000000000 ticks” niet erg handig voor mensen. Daarom heeft C# de DateTime class, die deze ticks voor ons vertaalt naar begrijpelijke waarden zoals jaar, maand, dag, uur, minuut en seconde.
DateTime nu = DateTime.Now;
Console.WriteLine(nu.Ticks); // Bijvoorbeeld: 638360640000000000
Console.WriteLine(nu); // Bijvoorbeeld: 12/11/2025 14:32:15
Achter de schermen slaat DateTime gewoon één getal op (de ticks), maar biedt het handige properties zoals Year, Month, Day, Hour, Minute en Second om dit getal te interpreteren.
Omdat DateTime intern een long gebruikt (een 64-bit geheel getal) om ticks op te slaan, heeft het een enorm bereik:
Dit is ruim voldoende voor alle praktische toepassingen!
Naast DateTime heeft C# ook TimeSpan, wat een tijdsduur voorstelt (in plaats van een specifiek moment). Een TimeSpan gebruikt ook ticks intern:
DateTime start = new DateTime(2025, 1, 1, 10, 0, 0);
DateTime einde = new DateTime(2025, 1, 1, 12, 30, 0);
TimeSpan verschil = einde - start; // 2 uur en 30 minuten
Console.WriteLine(verschil.Ticks); // 90000000000 ticks
Console.WriteLine(verschil.TotalHours); // 2,5 uur
De echte wereld heeft verschillende tijdzones. Om dit te beheren, gebruikt C# twee belangrijke concepten:
UTC (Coordinated Universal Time): Een universele tijd die overal ter wereld hetzelfde is. Dit is de “absolute waarheid” voor tijd.
Lokale tijd: De tijd zoals die wordt weergegeven in jouw tijdzone.
DateTime utcNu = DateTime.UtcNow; // Bijvoorbeeld: 13:32:15 (UTC)
DateTime lokaalNu = DateTime.Now; // Bijvoorbeeld: 14:32:15 (België, UTC+1)
Intern slaat C# ook op welk type tijd het is (UTC, lokaal, of niet gespecificeerd) met de Kind property.
Je zou denken dat alle jaren 365 dagen hebben, maar de werkelijkheid is complexer:
Gelukkig hoef jij je hier geen zorgen over te maken. De DateTime class kent alle regels:
DateTime schrikkeljaar = new DateTime(2024, 2, 29); // Geldig!
// DateTime fout = new DateTime(2025, 2, 29); // Error! Geen schrikkeljaar
De DateTime class weet ook dat:
Omdat DateTime intern slechts één long (8 bytes) opslaat, is het:
DateTime is goedkoopDit maakt DateTime perfect geschikt voor bijvoorbeeld:
De belangrijkste punten om te onthouden:
DateTime class maakt ticks begrijpelijk voor mensen.TimeSpan.DateTime regelt dit allemaal voor jou!Nu je de technische achtergrond begrijpt, ben je klaar om te leren hoe je DateTime in de praktijk gebruikt. In het volgende leesmateriaal gaan we alle handige functionaliteiten en voorbeelden bekijken!