Werken met datums en tijd

C# heeft een uitgebreide struct om te werken met datums en tijd: DateTime. Het is geen gegevenstype maar werken met datums en/of tijd komt zeer frequent voor, net als werken met strings en getallen.

Laten we beginnen met het instantiëren van een nieuw DateTime object:

DateTime dt = new DateTime();
Console.WriteLine(dt.ToString());

Het resultaat is vrij saai: 01-01-0001 00:00:00. Dit is het DateTime.MinValue veld maar DateTime heeft meer interessante eigenschappen. De meest gebruikte is DateTime.Now:

DateTime dt = DateTime.Now;
Console.WriteLine(dt.ToString());

Dit geeft ons de huidige datum en tijd. Dit wordt veelvuldig gebruikt zoals we in de volgende voorbeelden zullen zien. In vele gevallen is er een specifieke datum en tijd nodig. DateTime heeft hiervoor tal van constructors ter beschikking. Hier is een voorbeeld:

DateTime dt = new DateTime(2042, 12, 24);
Console.WriteLine(dt.ToString());

De volgorde in deze constructor is jaar, maand, dag. Dus dit DateTime object geeft ons kerstavond in het jaar 2042.

DateTime - met of zonder tijd?

En de tijd? Als er geen tijd gegeven wordt is de standaardwaarde 00:00:00 zoals het vorige voorbeeld laat zien. De tijd kan eenvoudig gegeven worden:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);
Console.WriteLine(dt.ToString());

De gegeven tijd is nu 18:42. Merk op dat het uur gegeven wordt met een getal tussen 0 en 23 omdat we de 24 uursklok gebruiken voor de ingave. Later zullen we zien dat het geen probleem is om de 12 uursklok te gebruiken met AM/PM.

Blijft de vraag: wat doen we als we alleen geïnteresseerd zijn in de datum? Een mogelijk antwoord zou zijn om de Date klasse te gebruiken in plaats van de DateTime klasse. Maar die bestaat niet! In de plaats daarvan heeft de DateTime klasse een Date eigenschap:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);
DateTime date = dt.Date;
Console.WriteLine(date.ToString());

De Date eigenschap is een DateTime object met het tijdsgedeelte op 00:00:00 gezet. Dit kan verwarrend lijken maar er is een goede reden voor. DateTime is een container die de gegevens bevat die aan de gebruiker op verschillende wijzen kunnen gepresenteerd worden. We hebben al de ToString() methode gebruikt maar er zijn veel meer manieren om een DateTime object voor te stellen.

DateTime output

Het presenteren van DateTime is zeer belangrijk maar het kan ook een ingewikkelde taak zijn. Alles hangt af van wat men nodig heeft. Tot nu toe hebben we de basisversie van de uitvoer gezien: de eenvoudige aanroep van de ToString() methode. Dit geeft datum en tijd weer die gebaseerd is op de cultuur van de toepassing en die standaard gebaseerd is op de systeeminstellingen. Dit betekent dat de ToString() methode de datum en tijd weergeeft volgens de lokale gewoonte. Want die wijkt nogal af van regio tot regio.

Er zijn meerdere manieren om de output te beheren. De snelste manier is gebruik te maken van de To* methoden: de ToShortDateString() methode.

Console.WriteLine(DateTime.Now.ToShortDateString());

Dit resulteert in een korte schrijfwijze van de datum door de tijdsaanduiding weg te laten. Zo kan ook de ToLongDateString() methode gebruikt worden:

Console.WriteLine(DateTime.Now.ToLongDateString());

Het resultaat kan verschillen naargelang de regio maar een lange datum omvat meestal een tekstnotatie van de maand in plaats van nummers.

Om meer controle te krijgen, bijvoorbeeld om de datum/tijd aan te passen voor een specifieke regio, kan overloading van de ToString() methode gebruikt worden, door expliciet op te geven welke regio bedoeld wordt:

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine(DateTime.Now.ToString(usCulture.DateTimeFormat));

Met de CultureInfo klasse kan een hele boel informatie over een taal verkregen worden. Zoals hoe datums en tijd worden geschreven (de CultureInfo klasse wordt later in deze handleiding beschreven). Deze informatie kunnen we dan doorgeven aan de DateTime klasse om deze gegevens precies zo te schrijven als in een bepaalde taal gebruikelijk is. Maar wat als we nog meer detail willen in onze weergave?

Standaard Date & Time Format Strings

Om nog meer controle over de uitvoer te hebben kunnen de standaard date & tijd format strings van .NET gebruikt worden. Door één letter kan de weergave van datum en tijd aangegeven worden. Een volledige lijst is te vinden op documentation, maar hier volgen alvast enkele voorbeelden:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);  

Console.WriteLine("Short date pattern (d): " + dt.ToString("d"));  
Console.WriteLine("Long date pattern (D): " + dt.ToString("D"));  
Console.WriteLine("Full date/time pattern (F): " + dt.ToString("F"));  
Console.WriteLine("Year/month pattern (y): " + dt.ToString("y"));

Het resultaat ziet er zo uit:

Short date pattern (d):         24-12-2042
Long date pattern (D):      24. december 2042
Full date/time pattern (F):     24. december 2042 18:42:00
Year/month pattern (y):         december 2042

Dit geeft wat meer controle over de uitvoer. Maar soms is dit niet voldoende, dan zijn er specifieke format strings nodig.

Specifieke Date & Time Format Strings

Voor volledige controle zijn er specifieke format strings. Het zijn een combinatie van letters en speciale tekens die toegevoegd worden aan de ToString() methode om exact de vorm te krijgen voor de datum en/of de tijd die men wenst. Dit omvat zowel de plaats, hoe en met welke scheidingstekens de datum/tijd delen worden weergegeven. De mogelijkheden zijn legio: ga naar documentation maar hier zijn enkele voorbeelden:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);

Console.WriteLine(dt.ToString("MM'/'dd yyyy"));
Console.WriteLine(dt.ToString("dd.MM.yyyy"));
Console.WriteLine(dt.ToString("MM.dd.yyyy HH:mm"));
Console.WriteLine(dt.ToString("dddd, MMMM (yyyy): HH:mm:ss"));
Console.WriteLine(dt.ToString("dddd @ hh:mm tt", System.Globalization.CultureInfo.InvariantCulture));

De uitvoer ziet er zo uit:

12/24 2042
24.12.2042
12.24.2042 18:42
onsdag, december (2042): 18:42:00
Wednesday @ 06:42 PM

In het algemeen geven d's een of andere versie van de dag, M's geven de maand (kleine letters m zijn voor minuten) en y's geven het jaar. Ga voor meer uitleg naar documentation maar bovenstaand voorbeeld geeft al een goed idee over de kracht van format strings.

Parsing datums

Tot nu toe werkten we met datums die gegenereerd werden in programmacode maar de gebruiker moet ook datums kunnen opgeven. Dit is niet eenvoudig want er zijn vele mogelijkheden om datums weer te geven. .NET bevat alle culturen en regio's, zoals hiervoor getoond, maar de gebruiker moet nog steeds geholpen worden met het bepalen van het formaat dat hij wenst. Daarna wordt de Parse() methode gebruikt om de opgegeven string in een DateTime object weer te geven.

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine("Please specify a date. Format: " + usCulture.DateTimeFormat.ShortDatePattern);
string dateString = Console.ReadLine();
DateTime userDate = DateTime.Parse(dateString, usCulture.DateTimeFormat);
Console.WriteLine("Date entered (long date format):" + userDate.ToLongDateString());

Dit voorbeeld toont hoe .NET helpt met de CultureInfo klasse (US Engels in dit geval, de CultureInfo klasse wordt later in detail besproken). De gebruiker wordt aangezet een bepaald formaat te gebruiken. In de vierde regel wordt de ingave ontleed (parse) en in de laatste regel wordt de gevraagde datum weergegeven, in dit geval gewoon de systeemweergave.

Maar opgelet. De Parse() methode is zeer strikt: als de gebruiker de datum niet ingeeft in het verwachte formaat volgt er een exception. Daarom wordt beter de TryParse() methode gebruikt. Zij doet hetzelfde maar laat toe of de datum geparsed wordt of niet en geeft ook geen exeption. Hier is een herziene versie van het voorgaande voorbeeld:

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine("Please specify a date. Format: " + usCulture.DateTimeFormat.ShortDatePattern);
string dateString = Console.ReadLine();
DateTime userDate;
if (DateTime.TryParse(dateString, usCulture.DateTimeFormat, System.Globalization.DateTimeStyles.None, out userDate))
    Console.WriteLine("Valid date entered (long date format):" + userDate.ToLongDateString());
else
    Console.WriteLine("Invalid date specified!");

Samenvatting

Werken met datums en tijd is belangrijk maar ook zeer complex. .NET schiet echter ter hulp in praktisch alle situaties met de uitstekende DateTime klasse.