02. variabelen en berekeningen

Op Youtube

Deze video maakt deel uit van de IIP playlist van de Youtube channel van Rogier van der Linde.

Let op: deze video's zijn al een paar jaar oud, dus hier en daar kunnen kleine afwijkingen voorkomen met deze cursus, die wel altijd up-to-date is.

• 0:00 Intro
• 2:11 types van variabelen
• 4:43 regels voor naamgeving
• 6:40 constanten
• 8:33 mixen en conversie tussen types
• 13:30 verkorte notaties
• 14:32 type bool, logische operatoren
• 16:10 type string
  • 16:35 escapen
  • 18:13 Environment.NewLine
  • 19:29 multiline strings
  • 20:07 string interpolatie
• 23:52 variabelen in WPF - random generator demo
• 29:47 stijregels en tips

Variabelen en constanten

Een variabele is een naam die een waarde van een bepaald type kan bevatten. Het vermelden van het bestaan van een variabele met type en naam noemt men declaratie, het geven van een eerste waarde initialisatie.

Declaratie

Een declaratie is een nieuwe variabele aanmaken met een naam.

string halloTekst; // tekst
int leeftijd; // geheel getal
double leeftijd; // kommagetal
char teken; // karakter
bool isCorrectAntwoord; // ja of nee

→ stijlregel: we noteren de naam in camelCaseNotatie

Initialisatie

De initialisatie betekent een variabele zijn initiële (eerste) waarde geven:

string halloTekst;
halloTekst = "Hallo Wereld!"; // variabele later geïnitialiseerd

Of declaratie en initialisatie in één keer:

string halloTekst = "Hallo Wereld!"; // variabele meteen geïnitialiseerd

Toewijzing

Je mag een variabele altijd een andere, nieuwe waarde geven – het is tenslotte "variabel". Het toekennen van een waarde heet een toekenning of toewijzing

string halloTekst = "Hallo Wereld!"; // declaratie en initialisatie
halloTekst = "Hallo Iedereen!"; // toewijzing: variabele krijgt (nieuwe) waarde

Overzicht datatypes

Het datatype beperkt welke waarden de variabele kan bevatten. Types gebruikt in deze cursus:

Let op: nullable types (zie verder) hebben altijd standaardwaarde null.

Format specifiers

Het formaat waarin waarden weergegeven worden in een tekst kan ingesteld worden met zgn. format specifiers. De belangrijkste opties:

Je kan ze gebruiken als argument in ToString():

double getal = 12.3456789;
Console.WriteLine($"één cijfer na de komma: {getal.ToString("F1")}");
Console.WriteLine($"twee cijfers na de komma: {getal.ToString("F2")}");
Console.WriteLine($"als percentage (x100): {getal.ToString("P")}");
Console.WriteLine($"als bedrag: {getal.ToString("C")}");

Ook rechtstreeks in string interpolatie kan:

double getal = 12.3456789;
Console.WriteLine($"één cijfer na de komma: {getal:F1}");
Console.WriteLine($"twee cijfers na de komma: {getal:F2}");
Console.WriteLine($"als percentage (x100): {getal:P}");
Console.WriteLine($"als bedrag: {getal:C}");

één cijfer na de komma: 12,3
twee cijfers na de komma: 12,35
als percentage (x100): 1.234,50%
als bedrag: € 12,35

Constanten

Een constante is als een variabele, maar het moet een vaste waarde hebben en die waarde kan niet meer veranderen. Een constante duid je aan met const:

const int MaxAantalPogingen = 3;
const string Prefix = "ABC_";

→ stijlregel: de meest gangbare notatie voor constanten in C# is PascalCaseNotatie

Constanten kunnen na initialisatie niet meer toegewezen worden. Dit is dus fout:

MaxAantalPogingen = 4; // FOUT! waarde kan niet meer veranderen
const string Suffix; // FOUT! constante moet een waarde hebben
const string Name = Console.ReadLine();  // FOUT! constante moet vaste waarde hebben

De regels zijn niet altijd duidelijk. Maar geen nood ‐ je programmeeromgeving zal je wel op fouten wijzen.

Naamgeving

De naam van een variabele moet voldoen aan de volgende syntaxregels:

• bevat enkel letters, cijfers en underscore
• begint niet met een cijfer
• maximum lengte: afhankelijk van de compiler; de C# Roslyn compiler accepteert maximaal zo'n 511 tekens
• geen gereserveerde woorden, dus geen if, class, double, ... (complete lijst https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/)

Daarnaast houden we ons aan deze bijkomende stijlregels:

• camelCase-notatie voor variabelen (mijnVariabeleWaarde, niet mijn_variabele_waarde)
• PascalCase-notatie voor constanten (MijnConstanteWaarde, niet mijn_constante_waarde of mijnConstanteWaarde)
• betekenisvolle namen
• één taal (Engels/Nederlands), wees consistent!

Er bestaan andere voorkeuren voor deze stijlregels, maar deze regels zijn de meest gangbare in C# en aanbevolen door Microsoft

Nullable types

Nullable types zijn primitieve types int, float, bool… uitgebreid met de null waarde (wat "geen waarde" betekent):

int getal1; // alle waarden tussen -2,147,483,648 en 2,147,483,647
int? getal2; // nullable int alle waarden tussen -2,147,483,648 en 2,147,483,647 of null

bool test1 // true of false
bool? test2; // nullable boolean: true, false of null

Nullable types zijn handig als je een bepaald primitief type wil gebruiken dat ook geen waarde moet kunnen hebben ("leeg").

use case 1: optionele gegevens

Stel dat je een programma maakt waarin iemand zijn geboortedatum kan invoeren. Niet iedereen kan of wil dit invullen:

DateTime? geboortedatum = null;
// Pas later ingevuld als de gebruiker dat wil

use case 2: spelletjes / scores

In een game kun je een highscore hebben die nog niet bestaat als niemand heeft gespeeld:

int? highscore = null; // nog geen score behaald

use case 3: database waarden

In een database kan een kolom leeg zijn (NULL). Als je dit ophaalt in C#, moet je dat kunnen representeren:

int? huisnummer = null; // gebruiker woont in een appartement zonder nummer

Conversie/parsing

Het omzetten van een waarde van één type naar een ander noemt men conversie; het specifieke geval waarin je een string omzet heet parsing.

verbredend vs. vernauwend

Er zijn twee soorten conversies:

• verbredende conversie: van een kleiner naar een groter bereik, b.v. van een double (kommagetal) naar een string (tekst)
• vernauwende conversie: van een groter naar een kleiner bereik, b. van een double (kommagetal) naar een int (geheel getal)

impliciete conversie

Verbredende conversies gebeuren vaak automatisch of impliciet:

int int1 = 13;
double dbl1 = int1; // OK: int impliciet geconverteerd naar double
string str1 = "het kommagetal is " + dbl1; // OK: double impliciet geconverteerd naar een string
string str2 = $"het geheel getal is {int1}"; // OK: impliciete conversie van int naar string tijdens interpolatie

...maar niet altijd:

string str1 = int1; // FOUT! hier treedt geen impliciete conversie op

De logica wanneer wel en niet impliciete conversie optreedt is niet altijd even duidelijk. Maar geen nood, je programmeeromgeving zal je er wel op wijzen als een conversie ontbreekt.

expliciete (handmatige) conversie

Bij expliciete conversie forceer je handmatig de omzetting naar een ander type

ToString()

Conversie naar een string is eenvoudig: je kan altijd overal ToString() gebruiken

int int1 = 13;
string str1 = int1.ToString();

Convert klasse

Er zijn veel manieren om conversies door te voeren. De makkelijkste is met de methodes van de Convert klasse (zie 02. NET classes - Convert):

string str1 = "13"; string str2 = "13.45";
int int1 = Convert.ToInt32(str1);
double dbl1 = Convert.ToDouble(str2);

Parse(), TryParse()...

Er bestaan nog andere manieren om te converteren; voorbeelden:

string str1 = "13"; double dbl1 = 13.45;
int int1 = int.Parse(str1); // conversie met ...Parse() methode
int int2; bool success = int.TryParse(str1, out int2); // conversie met de ....TryParse() methode
int int3 = (int)dbl1; // conversie met (int)
string str2 = int1 + ""; // geforceerde conversie

Om het overzichtelijk te houden, raden we deze methodes af. Beperk je tot ToString() en Convert.To...()

Rekenkundige Operatoren

Dit zijn de klassieke bewerkingen die je uit de wiskunde kent: optellen, aftrekken...

Overzicht

Gehele deling

Als de twee getallen geheel zijn, wordt de deling geheel uitgevoerd:

int a = 13;
double b = a / 5; // resultaat is 2: gehele deling!
double c = Convert.ToDouble(a) / 5; // resultaat is 2.6
double d = a / Convert.ToDouble(5); // resultaat is 2.6
double e = a / 5.0; // resultaat is 2.6
double f = a * 2 / 5; // resultaat is 26 / 5, of 5: gehele deling!
double g = a * 2.0 / 5; // resultaat is 26.0 / 5, of 5.2

Verkorte Notaties

Math-klasse

Voor bewerkingen als Round(), Max() enz... en constanten als PI zie 02. NET classes - Math