Statements en de C# syntax

Om een werkend C#-programma te maken moeten we de C#-taal beheersen. Net zoals iedere taal, bestaat ook C# uit enerzijds grammatica, in de vorm van de C# syntax en anderzijds vocabulair in de vorm van de te gebruiken keywords.

Een C#-programma bestaat uit een opeenvolging van instructies ook wel statements genoemd. Deze eindigen steeds met een puntkomma (;) (zoals ook in het Nederlands een zin eindigt met een punt).

De volgorde van de woorden (keywords, variabelen, etc.) zijn niet vrijblijvend en moeten aan (grammaticale) regels voldoen. Enkel indien alle statements correct zijn zal het programma gecompileerd worden naar een werkend en uitvoerbaar programma (zoals in een vorige sectie besproken).

Enkele belangrijke regels van C#:

• Hoofdletter-gevoelig: C# is hoofdlettergevoelig. Dat wil zeggen dat hoofdletter T en kleine letter t totaal verschillende zaken zijn voor C#. Reinhardt en reinhardt zijn dus ook niet hetzelfde.

• Statements afsluiten met puntkomma: Iedere C# statement wordt afgesloten moet een puntkomma ( ; ). Doe je dat niet dan zal C# denken dat de regel gewoon op de volgende lijn doorloopt en deze als één (fout) geheel proberen te compileren.

• Witruimtes: Spaties, tabs en enters worden door de C# compiler genegeerd. Je kan ze dus gebruiken om de layout van je code (bladspiegel zeg maar) te verbeteren. De enige plek waar witruimtes wél een verschil geven is tussen aanhalingstekens " " die we later (bij string) zullen leren gebruiken.

• Commentaar toevoegen kan: met behulp van // voor een enkele lijn en /* */ voor meerdere lijnen commentaar. Alles dat in commentaar staat zal door de compiler genegeerd worden.

Keywords: de woordenschat

C# bestaat zoals gezegd niet enkel uit grammaticale regels. Grammatica zonder woordenschat is nutteloos. Er zijn binnen C# dan ook 80 woorden, zogenaamde reserved keywords die de woordenschat voorstellen. In deze cursus zullen we stelselmatig deze keywords leren kennen en gebruiken op een correcte manier om zo werkende code te maken.

Deze keywords zijn:

De keywords in vet zijn keywords die we dit semester zullen kennen. Die in cursief in het tweede semester. De overige zal je zelf moeten leren ;).

(indien je deze tabel in pdf bekijkt zal deze om zeep zijn. Onze gitbook gnomes proberen dit op te lossen maar voorlopig vinden we helaas geen oplossing, waarvoor onze excuses)

Variabelen, identifiers en naamgeving

We hebben variabelen nodig om (tijdelijke) data in op te slaan. Wanneer we een statement schrijven dat bijvoorbeeld input van de gebruiker moet vragen, dan willen we ook die input bewaren zodat we verderop in het programma (het algoritme) iets met deze data kunnen doen. We doen hetzelfde in ons hoofd wanneer we bijvoorbeeld zegen "tel 3 en 4 op en vermenigvuldig dat resultaat met 5". Eerst zullen we het resultaat van 3+4 in een variabele moeten bewaren. Vervolgens zullen we de inhoud van die variabele vermenigvuldigen met 5 en dat nieuwe resultaat ook in een nieuwe variabele opslaan (om vervolgens bijvoorbeeld naar het scherm te sturen).

Wanneer we een variabele aanmaken zal deze moeten voldoen aan enkele afspraken. Zo moeten we minstens 2 zaken meegeven:

• Het type van de variabele: het datatype dat aangeeft wat voor data we wensen op te slaan (tekst, getal, afbeelding, etc.).

• De naam van de variabele: de identifier waarmee we snel aan de variabele-waarde kunnen.

De verschillende datatypes bespreken we in een volgend hoofdstuk.

Regels voor identifiers

De code die we gaan schrijven moet voldoen aan een hoop regels. Wanneer we in onze code zelf namen (identifiers) moeten geven aan variabelen (en later ook methoden, objecten, etc.) dan moeten we een aantal regels volgen:

• Hoofdlettergevoelig: de identifiers tim en Tim zijn verschillend zoals reeds vermeld.

• Geen keywords: identifiers mogen geen gereserveerde C# keywords zijn. De keywords van hierboven mogen dus niet. Varianten waarbij de hoofdletters anders zijn mogen wel, bijvoorbeeld: gOTO en stRINg mogen dus wel, maar niet goto of string daar beide een gereserveerd keyword zijn maar dankzij de hoofdlettergevoelig-regel is dit dus toegelaten. INT mag ook ook, maar niet int.

• Eerste karakter-regel: het eerste karakter van de identifier mag enkel zijn:

  • kleine of grote letter

  • liggend streepje (_)

• Alle andere karakters: de overige karakters mogen enkel zijn:

  • kleine of grote letter

  • liggend streepje

  • een cijfer (0 tot en met 9)

• Lengte: Een legale identifier mag zo lang zijn als je wenst, maar je houd het best leesbaar.

Enkele voorbeelden

Enkele voorbeelden van toegelaten en niet toegelaten identifiers:

Naamgeving afspraken

Er zijn geen vaste afspraken over hoe je je variabelen moet noemen toch hanteren we enkele coding guidelines die doorheen je opleiding moeten gevolgd worden. Naarmate we meer C# leren zullen er extra guidelines bijkomen (zie deze pagina met richtlijnen).

• Duidelijke naam: de identifier moet duidelijk maken waarvoor de identifier dient. Schrijf dus liever gewicht of leeftijd in plaats van a of meuh.

• Camel casing: gebruik camel casing indien je meerdere woorden in je identifier wenst te gebruiken. Camel casing wil zeggen dat ieder nieuw woord terug met een hoofdletter begint. Een goed voorbeeld kan dus zijn leeftijdTimDams of aantalLeerlingenKlas1EA. Merk op dat we liefst het eerste woord met kleine letter starten. Uiteraard zijn er geen spaties toegelaten.

Commentaar

Soms wil je misschien extra commentaar bij je code zetten. Als je dat gewoon zou doen (bv Dit deel zal alles verwijderen) dan zal je compiler niet begrijpen wat die zin doet. Hij verwacht namelijk C# en niet een Nederlandstalige zin. Om dit op te lossen kan je in je code op twee manieren aangeven dat een stuk tekst gewoon commentaar is en mag genegeerd worden door de compiler:

Enkele lijn commentaar

Eén lijn commentaar geef je aan door de lijn te starten met twee voorwaartse slashes //. Uiteraard mag je ook meerdere lijnen op deze manier in commentaar zetten. Zo wordt dit ook vaak gebruikt om tijdelijk een stuk code "uit te schakelen". Ook mogen we commentaar achter een stuk C# code plaatsen (zie voorbeeld hieronder).

//De start van het programma
int getal=3;
//Nu gaan we rekenen
int result = getal * 5;
// result= 3*5;
Console.WriteLine(result); //We tonen resultaat op scherm: 15

Blok commentaar

We kunnen een stuk tekst als commentaar aangeven door voor de tekst /* te plaatsen en */ achteraan. Een voorbeeld:

/*
    Veel commentaar.
    Een heel verhaal
    Mooi he.
    Is dit een haiku?
*/
int leeftijd= 0;
leeftijd++;

Variabelen

In het vorige hoofdstuk zagen we dat er verschillende soorten datatypes bestaan. Deze types hebben we nodig om variabelen aan te maken. De data die we in een programma gebruiken bewaren we namelijk in een variabele van een bepaald type. Een variabele is een plekje in het geheugen dat in je programma zal gereserveerd worden om daarin data te bewaren van het type dat je aan de variabele hebt toegekend. Een variabele zal intern een geheugenadres hebben (waar de data in het geheugen staat) maar dat zou lastig programmeren zijn indien je steeds dit adres moet gebruiken. Daarom moeten we ook steeds een naam oftewel identifier aan de variabele geven zodat we makkelijk de geheugenplek kunnen aanduiden.

De naam (identifier) van de variabele moet voldoen aan de identifier regels onder "Inleiding -> Afspraken code".

Variabelen aanmaken en gebruiken

Om een variabele te maken moeten we deze declareren, door een type en naam te geven. Vanaf dan zal de computer een hoeveelheid geheugen voor je reserveren waar de inhoud van deze variabele in kan bewaard worden. Hiervoor dien je minstens op te geven:

1. Het datatype (bv int, double).

2. Een identifier zodat de variabele uniek kan geïdentificeerd worden (volgens de naamgevingsregel van C#).

3. (optioneel) Een beginwaarde die de variabele krijgt bij het aanmaken ervan.

Een variabele declaratie heeft als syntax:

datatype identifier;

Bijvoorbeeld: int leeftijd;

Je mag ook meerdere variabelen van het zelfde datatype in 1 enkele declaratie aanmaken door deze met komma's te scheiden:

datatype identifier1, identifier2, identifier3;

Bijvoorbeeld string voornaam, achternaam, adres;

Indien je reeds weet wat de beginwaarde moet zijn van de variabele dan mag je de variabele ook reeds deze waarde toekennen bij het aanmaken:

int mijnLeeftijd = 37;

Waarden toekennen aan variabelen

Vanaf dit punt kunnen we dus ten allen tijde deze variabele gebruiken om een waarde aan toe te kennen, de bestaande waarde te overschrijven, of de waarde te gebruiken, zoals:

• Waarde toekennen: mijnGetal= 15;. Toekenning gebeurt steeds van rechts naar links: het deel rechts van het gelijkheidsteken wordt toegewezen aan het deel links er van.

• Waarde tonen op scherm: Console.WriteLine(mijnGetal);

Met de toekennings-operator (=) kan je een waarde toekennen aan een variabele. Hierbij kan je zowel een literal toekennen oftewel het resultaat van een expressie.

Je kan natuurlijk ook een waarde uit een variabele uitlezen en toewijzen aan een andere variabele:

int eenAndereLeeftijd = mijnLeeftijd;

Literal toewijzen

Literals zijn expliciet ingevoerde waarden in je code. Als je in je code expliciet de waarde 4 wilt toekennen aan een variabele dan is het getal 4 in je code een zogenaamde literal. Wanneer we echter data bijvoorbeeld eerst uitlezen of berekenen (via bijvoorbeeld invoer van de gebruiker of als resultaat van een berekening) en het resultaat hiervan toekennen aan een variabele dan is dit geen literal.

Voorbeelden van een literal toekennen:

int temperatuurGisteren = 20;
int temperatuurVandaag = 25;

Het is belangrijk dat het type van de literal overeenstemt met dat van de variabele waaraan je deze zal toewijzen. Een string-literal (zie verder) stel je voor door aanhalingstekens. Volgende code zal dan ook een compiler-fout generen, daar je een string-literal aan een int-variabele wil toewijzen, en vice versa.

string eenTekst;
int eenGetal;

eenTekst = 4;
eenGetal = "4";

Als je bovenstaande probeert te compileren dan krijg je volgende error-boodschappen:

Literal bepaald het datatype

De manier waarop je een literal schrijft in je code zal bepalen wat het datatype van de literal is:

• Gehele getallen worden standaard als int beschouwd, vb: 125.

• Kommagetallen (met punt .) worden standaard als double beschouwd, vb: 12.5.

• Via een suffix na het getal kan je aangeven als het om andere types gaat:

  • U of u voor uint, vb: 125U.

  • L of l voor long, vb: 125L.

  • UL of ul voor ulong, vb: 125ul.

  • F of f voor float, vb: 12.5f.

  • M of m voor decimal, vb: 12.5M.

• Voor bool (zie verder) is dit enkel true of false.

• Voor char (zie verder) wordt dit aangeduid met een enkele apostrof voor en na de literal, vb: 'q'.

• Voor string (zie verder) wordt dit aangeduid met aanhalingsteken voor en na de literal, vb: "pikachu".

De overige types sbyte, short en ushort hebben geen literal aanduiding. Er wordt vanuit gegaan wanneer je een literal probeert toe te wijzen aan een van deze types dat dit zonder problemen zal gaan (ze worden impliciet geconverteerd).

Hexadecimale en binaire notatie

Je kan ook hexadecimale notatie (starten met 0x of 0X) gebruiken wanneer je bijvoorbeeld met int of byte werkt:

int myAge= 0x0024;
byte myByteValue = 0x00C9;

Ook binaire notatie (starten met 0b of 0B) kan:

int myAge= 0b00010110001101000010‬; //Vanaf C# 7.2 mag je ook schrijven: 0b0001_0110_0011_0100_0010
byte myByteValue =  0b‭00100100‬9;

Nieuwe waarden overschrijven oude waarden

Wanneer je een reeds gedeclareerde variabele een nieuwe waarde toekent dan zal de oude waarde in die variabele onherroepelijk verloren zijn. Probeer dus altijd goed op te letten of je de oude waarde nog nodig hebt of niet. Wil je de oude waarde ook nog bewaren dan zal je een nieuwe, extra variabele moeten aanmaken en daarin de nieuwe waarde moeten bewaren:

int temperatuurGisteren = 20;
temperatuurGisteren = 25;

In dit voorbeeld zal er dus voor gezorgd worden dat de oude waarde van temperatuurGisteren, 20, overschreven zal worden met 25.

Volgende code toont hoe je bijvoorbeeld eerst de vorige waarde kunt bewaren en dan overschrijven:

int temperatuurGisteren= 20;
//Doe vanalles
//...
//1 dag later
int temperatuurEerGisteren= temperatuurGisteren; //Vorige temperatuur in eergisteren bewaren
temperatuurGisteren = 25; //temperatuur nu overschrijven

We hebben dus aan het einde van het programma zowel de temperatuur van eergisteren, 20, als die van vandaag, 25.

Kennisclip

• Variabelen en datatypes

Expressies en operators

Zonder expressies is programmeren saai: je kan dan enkel variabelen aan elkaar toewijzen. Expressies zijn als het ware eenvoudige tot complexe sequenties van bewerkingen die op 1 resultaat uitkomen. De volgende code is bijvoorbeeld een expressie: 3+2.

Het resultaat van deze expressie is 5. Meer informatie over expressies hier.

Expressie-resultaat toewijzen

Meestal zal je expressies schrijven waarin je bewerkingen op en met variabelen uitvoert. Vervolgens zal je het resultaat van die expressie willen bewaren voor verder gebruik in je code.

Voorbeeld van expressie-resultaat toekennen:

int temperatuursVerschil = temperatuurGisteren - temperatuurVandaag;

Hierbij zal de temperatuur uit de rechtse 2 variabelen worden uitgelezen, van elkaar wordt afgetrokken en vervolgens bewaard worden in temperatuursVerschil.

De voorgaande code kan ook langer geschreven worden als:

int tussenResultaat = temperatuurGisteren - temperatuurVandaag;
int temperatuursVerschil = tussenResultaat;

Een ander voorbeeld van een expressie-resultaat toewijzen maar nu met literals (stel dat we temperatuursVerschil reeds hebben gedeclareerd eerder):

temperatuursVerschil = 21 - 25;

Uiteraard mag je ook combinaties van literals en variabelen gebruiken in je expressies:

int breedte = 15;
int hoogte = 20 * breedte;

Operators

Operators in C# zijn de welgekende 'wiskundige bewerkingen' zoals optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/). Deze volgen de wiskundige regels van volgorde van berekeningen:

1. Haakjes

2. Vermenigvuldigen: * en / (alsook % die we later zien)

3. Optellen: + en -

   (etc.)

Net zoals in de wiskunde kan je in C# met behulp van de haakjes verplichten het deel tussen de haakjes eerst te doen, ongeacht de andere operators en hun volgorde van berekeningen:

3+5*2 => zal 13 als resultaat geven
(3+5)*2 => zal 16 geven

Je kan nu complexe berekeningen doen door literals, operators en variabelen samen te voegen. Bijvoorbeeld om te weten hoeveel je op Mars zou wegen:

double gewichtOpAarde= 80.3;        //kg
double zwaartekrachtAarde= 9.81;    //m/s² 
double zwaartekrachtMars= 3.711;    //m/s²

double  gewichtOpMars= (gewichtOpAarde/zwaartekrachtAarde) * zwaartekrachtMars; //kg
Console.WriteLine("Je weegt op Mars" + gewichtOpMars + " kg");

Modulo operator %

De modulo operator die we in C# aanduiden met % verdient wat meer uitleg. Deze operator zal als resultaat de gehele rest teruggeven wanneer we het linkse getal door het rechtse getal delen:

7%2 => zal 1 geven, daar 7 gedeeld door 2,  3 met rest 1 geeft 
10%5 => zal 0 geven, daar 10 gedeeld door 5, 2 met rest 0 geeft

De modulo-operator zal je geregeld gebruiken om bijvoorbeeld te weten of een getal een veelvoud van iets is. Als de rest dan 0 is weet je dat het getal een veelvoud is van het getal waar je het door deelde.

Bijvoorbeeld om te testen of getal even is gebruiken we %2:

int getal= 1234234;
int rest= getal%2;
Console.WriteLine($"Indien het getal als rest 0 geeft weten we dat het even is. De rest is: {rest}");

Verkorte operator notaties

Heel vaak wil je de inhoud van een variabele bewerken en dan terug bewaren in de variabele zelf. Bijvoorbeeld een variabele vermenigvuldigen met 10 en het resultaat ervan terug in de variabele plaatsen. Hiervoor zijn enkele verkorte notaties in C#. Stel dat we een variabele int getal hebben:

Je zal deze verkorte notatie vaak tegenkomen. Ze zijn identiek aan elkaar en zullen dus je code niet versnellen. Ze zal enkel compacter zijn om te lezen. Bij twijfel, gebruik gewoon de lange notatie.

Expressiedatatypes

De types die je in je berekeningen gebruikt bepalen ook het type van het resultaat. Als je bijvoorbeeld twee int variabelen of literals optelt zal het resultaat terug een int geven.

int result= 3+4;

Je kan echter geen kommagetallen aan int toewijzen. Als je dus twee double variabelen deelt is het resultaat terug een double en zal deze lijn een fout geven daar je probeert een double aan een int toe te wijzen:

int otherResult= 3.1/45.2;

Let hier op!

But wait... it gets worse!

Wat als je een int door een int deelt? Het resultaat is terug een int. Je bent gewoon alle informatie na de komma kwijt. Kijk maar:

int getal1= 9;
int getal2= 2;
int result= getal1/getal2;
Console.WriteLine(result);

Er zal 4 op het scherm verschijnen! (niet 4.5 daar dat geen int is).

Wat als je datatypes mengt? Als je een berekening doet met een int en een double dan zal C# het 'grootste' datatype kiezen. In dit geval een double. Volgende code zal dus werken:

double result= 3/5.6;

Volgende niet:

int result= 3/5.6;

Wil je dus het probleem oplossen om 9 te delen door 2 dan zal je minstens 1 van de 2 literals of variabelen door een double moeten omzetten. Het voorbeeld van hierboven herschrijven we dan naar:

int getal1= 9;
double getal2= 2.0;
double result= getal1/getal2;
Console.WriteLine(result);

En nu krijgen we wel 4.5.

En complexer?

Het kan subtiel en ambetant worden in grotere berekeningen.

Stel dat ik afspreek dat je van mij de helft van m'n salaris krijgt. Ik verdien (fictief) 10000 euro per maand. Ik gebruik volgende formule:

double helft= 10000.0 * (1/2);

Hoeveel krijg je van me? 0.0 euro, MUHAHAHAHA!!!

De volgorde van berekeningen zal eerst het gedeelte tussen de haakjes doen: 1 delen door 2 geeft 0, daar we een int door een int delen en dus terug een int als resultaat krijgen. Vervolgens zullen we deze 0 vermenigvuldigen met 10000.0 waarvan ik zo slim was om deze in double te zetten. Niet dus. We vermenigvuldigen weliswaar een double (het salaris) met een int maar die int is reeds 0 en we krijgen dus 0.0 als resultaat.

Wil je het dus eerlijk spelen dan zal je de formule moeten aanpassen naar:

double helft = 10000.0 * (1.0/2);

Nu krijgt het gedeelte tussen de haakjes een double als resultaat, namelijk 0.5 dat we dan kunnen vermenigvuldigen met het salaris om 5000.0 te krijgen.

Kennisclip

• Expressies

Een essentieel onderdeel van C# is kennis van datatypes. Binnen C# zijn een aantal types gedefinieerd die je kan gebruiken om data in op te slaan. Wanneer je data wenst te bewaren in je applicatie dan zal je je moeten afvragen wat voor soort data het is. Gaat het om een getal, een geheel getal, een kommagetal, een stuk tekst of misschien een binaire reeks? Ieder datatype in C# kan één welbepaald soort data bewaren en dit zal telkens een bepaalde hoeveelheid computergeheugen vereisen.

Er zijn tal basistypes in C# gedeclareerd (zogenaamde primitieve datatypes). Dit semester leren we werken met datatypes voor:

• Gehele getallen: sbyte, byte, short, ushort, int, uint, long

• Kommagetallen: double, float, decimal

• Tekst: char, string

• Booleans: bool

Het datatype string heb je al gezien in het vorig hoofdstuk. Je hebt toen al een variabele aangemaakt van het type string door de zin string result;. Verderop plaatsen we dan iets waar de gebruiker iets kan intypen in die variabele (toekenning in C# gaat van rechts naar links): result = Console.ReadLine();.

Basistypen voor getallen

Alhoewel een computer digitaal werkt en enkel 0'n en 1'n bewaard zou dat voor ons niet erg handig werken. C# heeft daarom een hoop datatypes gedefinieerd om te werken met getallen zoals wij ze kennen, gehele en kommagetallen. Intern zullen deze getallen nog steeds binair bewaard worden, maar dat is tijdens het programmeren zelden een probleem.

Onthoudt echter dat onderaan je programma steeds hardware zal draaien die binair werkt.

De basistypen van C# om getallen in op te slaan zijn:

• Voor gehele getallen: sbyte, byte, short, ushort, int, uint, long

• Voor kommagetallen: double, float, decimal

Ieder type hierboven heeft een bepaald bereik en hoeveelheid geheugen nodig. Je zal dus steeds moeten afwegen wat je wenst. Op een high-end pc met ettelijke gigabytes aan werkgeheugen (RAM) is geheugen zelden een probleem waar je rekening mee moet houden...Of toch: zoals met real-time shooters die miljoenen berekeningen (3D) per seconde moeten uitvoeren. Daar zal iedere byte tellen. Op andere apparaten (smartphone, arduino, smart fridges, etc.) is iedere byte geheugen nog kostbaarder. Kortom: kies steeds bewust het datatype dat het beste 'past' voor je probleem qua bereik, precisie en geheugengebruik.

Deze datatypes hebben allemaal een bepaald bereik, wat een rechtstreeks gevolg is van de hoeveelheid geheugen die ze innemen.

Gehele getallen

Voor de gehele getallen:

We raden aan dat je de 'info' urls bekijkt om te ontdekken hoe je de literals van datatypes moet schrijven in C#.

Enkele opmerkingen bij deze tabel:

• De s vooraan sbyte types staat voor signed: m.a.w. 1 bit wordt gebruikt om het + of - teken te bewaren.

• De u vooraan ushort, uint en ulong staat voor unsigned. Het omgekeerde van signed dus. Kwestie van het ingewikkeld te maken. Deze twee datatypes hebben dus geen teken en zijn altijd positief.

• char bewaard karakters. We zullen verderop dit datatype uitspitten en ontdekken dat karakters (alle tekens op het toetsenbord, inclusief getallen, leesteken, etc.) als gehele, binaire getallen worden bewaard. Daarom staat char in deze lijst.

• Het grootste getal bij long is 2 tot de 63ste (

  negen triljoen tweehonderddrieëntwintig biljard driehonderd tweeënzeventig biljoen zesendertig miljard achthonderdvierenvijftig miljoen zevenhonderdvijfenzeventigduizend achthonderd en zeven). Dit zijn maar 63 bits?! Inderaad, de laatste bit wordt gebruikt om het teken te bewaren.

Kommagetallen

Voor de kommagetallen zijn er maar 3 mogelijkeden. Ieder datatype heeft een 'voordeel' tegenover de 2 andere, dit voordeel staat vet in de tabel:

Zoals je ziet moet je bij kommagetallen een afweging maken tussen 3 even belangrijke criteria. Heb je ongelooflijk grote precisie nodig dan ga je voor een decimal. Wil je vooral erg grote of erg kleine getallen kies je voor double. De precisie van een getal is het aantal beduidende of significante cijfers. Het getal 12,45 heeft een precisie van 4. Zoals je merkt zal je dus zelden decimal nodig hebben, deze zal vooral nuttig zijn in wetenschappelijke programma's waar met erg exacte cijfers moet gewerkt worden.

Bij twijfel opteren we meestal voor kommagetallen om het double datatype te gebruiken. Bij gehele getallen kiezen we meestal voor int.

Boolean datatype

Het bool (boolean) is het eenvoudigste datatype van C#. Het kan maar 2 mogelijke waarden bevatten: true of false. 0 of 1 met andere woorden.

Het gebeurt vaak dat beginnende programmeurs een int variabele gebruiken terwijl ze toch weten dat de variabele maar 2 mogelijke waarden zal hebben. Om dus geen onnodig geheugen te verbruiken is het aan te raden om in die gevallen steeds met een bool variabele te werken.

Tekst/String datatype

We besteden verderop een heel apart hoofdstuk aan tonen hoe je tekst en enkele karakters kan bewaren in variabelen. Sneak preview:

• Tekst kan bewaard worden in het string datatype

• Een enkel karakter wordt bewaard in het char datatype dat we ook hierboven al even hebben zien passeren.

Oefening: H1-variabelen_hoofdletters

Leerdoelen

• gebruik van variabelen om input en output via Console.ReadLine en Console.WriteLine op te slaan en terug te tonen

Functionele analyse

Een applicatie vraagt je tekst in te voeren die dan daarna zal worden getoond met allemaal hoofdletters.

Technische analyse

UI

console applicatie

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en slaag dit op in een variabele.

Zet de inhoud van deze variabele om in hoofdletters. Je kan dit doen door ToUpper() toe te voegen aan een variabele van het type string. Bijvoorbeeld myText.ToUpper() in plaats van myText.

Uiteindelijk geef je dan deze variabele weer in de console.

Testscenario's

• Voer tekst in met spaties

• Voer tekst in van meer dan 100 karakters

• Voer tekst in van 1 karakter

• Voer geen tekst in

Ondersteunend materiaal

Hou het voorlopig op de cursus.

Oefening: H1-optellen

Leerdoelen

• gebruik van variabelen om input via Console.ReadLine op te slaan

• berekeningen met de opgeslagen data uitvoeren

• het resultaat dat werd opgeslagen in een variabele via onsole.WriteLine te tonen

Functionele analyse

Een applicatie vraagt je twee getallen in te voeren. Na de invoer van het tweede getal worden beide getallen bij elkaar opgeteld. Het resultaat wordt uiteindelijk weergeven.

Technische analyse

UI

console applicatie

Werking

1. De vraag wordt gesteld om een getal in te typen en daarna op enter/return te drukken.

2. Er wordt gevraagd een tweede getal in te typen en dan op enter/return te drukken.

3. De twee getallen worden opgeteld.

4. Het resultaat wordt weergegeven.

voorbeeldinteractie(s)

Wat is het eerste getal?
> 1
Wat is het tweede getal?
> 4
De som is 5.

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en slaag dit op in een variabele voor wat het eerste getal betreft. Herhaal dit voor het tweede getal. Tel de twee getallen samen en bewaar deze in een derde variabele. Uiteindelijk geef je dan de inhoud van deze derde variabele weer in de console. Tip: getal1 = Convert.ToInt32(invoer1);

Testscenario's

• Voer tekst in.

• Voer een getal met 100 cijfers in.

• Voer geen getal in.

Ondersteunend materiaal

Hou het voorlopig op de cursus.

Oefening: H1-verbruik-wagen

Leerdoelen

• gebruik van variabelen om input via Console.ReadLine op te slaan

• berekeningen met de opgeslagen data uitvoeren

• het resultaat dat werd opgeslagen in een variabele via onsole.WriteLine te tonen

Functionele analyse

Een applicatie zal voor jou het gemiddelde verbruik van een wagen berekenen.

Hiervoor worden volgende vragen gesteld:

1. Hoeveel liter is er nog aanwezig in de benzinetank.

2. Hoeveel liter zit er nog in de benzinetank na de rit.

3. Ook de kilometerstand van bij de aanvang van de rit wordt gevraagd en ook deze nadat de rit werd uitgevoerd.

Op basis van deze parameters wordt het gemiddelde verbruik berekend en weergegeven.

Technische analyse

UI

console applicatie

Werking

1. De vraag wordt gesteld om het aantal liter, aanwezig in de benzinetank, op te geven.

2. Daarna wordt gevraagd om ook het aantal liter op te geven na de rit.

3. De kilometerstand van de aanvang van de rit wordt gevraagd.

4. Uiteindelijk ook de kilometerstand na het beëindigen van de rit wordt opgevraagd.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en slaag dit op in variabelen.

Zorg ervoor dat je het juiste gegevenstype kiest voor de verschillende variabelen.

Nadien voer je de berekening uit om op basis van de ingevoerde gegevens het gemiddeld verbruik te berekenen (100 * (aantalLiterinTank1 - aantalLiterinTank2) / (kilometerstand2 - kilometerstand1))

Uiteindelijk geef je dan het resultaat weer in de console.

Testscenario's

• Voer tekst in.

• Voer een getal met 100 cijfers in.

• Voer geen getal in.

Ondersteunend materiaal

Hou het voorlopig op de cursus.

Oefening: H1-beetje-wiskunde

Leerdoelen

• expressies schrijven

• voorrang van operatoren

• effect van operaties naargelang datatype begrijpen

Functionele analyse

Je schrijft een programma dat de rol vervult van een rekenmachine. Het voert volgende berekeningen uit:

• -1 + 4 * 6

• ( 35+ 5 ) % 7

• 14 + -4 * 6 / 11

• 2 + 15 / 6 * 1 - 7 % 2

Technische analyse

UI

console applicatie

voorbeeldinteractie(s)

23
5
12
3

Technische hulp

Programmaverloop

Eerst wordt een resultaat berekend, daarna wordt het geprint.

Testscenario's

• Test uit met getallen van het type int.

• Test uit met getallen van het type float.

Ondersteunend materiaal

Hier vind je een tabel terug die uitlegt welke operaties voorrang hebben.

Oefening: H1-gemiddelde

Leerdoelen

• expressies schrijven

• voorrang van operatoren

• effect van operaties naargelang datatype begrijpen

Functionele analyse

Je schrijft een programma dat het gemiddelde van 18, 11 en 8 berekent, d.w.z. deze drie getallen optelt en de som deelt door drie.

Technische analyse

UI

console applicatie

voorbeeldinteractie(s)

12

Technische hulp

Programmaverloop

Eerst wordt het resultaat berekend, daarna wordt het geprint.

Testscenario's

• Test uit met getallen van het type int.

• Test uit met getallen van het type float.

Ondersteunend materiaal

Hou het voorlopig op de cursus.

Oefening: H1-maaltafels

Leerdoelen

• de console leegmaken

• werken met wiskundige operatoren

• interactie met de gebruiker

Functionele analyse

Je schrijft een programma dat de tafel van vermenigvuldiging voor 411 geeft. Dit programma wacht steeds tot de gebruiker op ENTER duwt voor het het volgend resultaat toont. Verder maakt het steeds het scherm leeg voor het een nieuw resultaat toont. Zie "programmaverloop".

Technische analyse

UI

console applicatie

voorbeeldinteractie(s)

1 * 411 is 411.

2 * 411 is 822.

(enzovoort)

10 * 411 is 4110.

Technische hulp

Programmaverloop

Voor elk resultaat wordt het scherm eerst leeggemaakt. Daarna pas wordt het resultaat getoond. Wanneer de gebruiker op ENTER duwt, wordt deze handeling herhaald voor het volgende resultaat (of eindigt het programma, na het tiende resultaat). Het scherm leegmaken doe je met Console.Clear(). Plaats 411 ook in een variabele.

Testscenario's

• Test uit zoals gegeven.

• Test uit voor 511. Je zou maar één teken in je code moeten aanpassen als je de instructies hebt gevolgd.

Ondersteunend materiaal

Hou het voorlopig op de cursus.

Oefening: H1-ruimte

Leerdoelen

• werken met kommagetallen

Functionele analyse

Je massa is overal dezelfde en wordt uitgedrukt in kilogram. Je gewicht daarentegen is afhankelijk van de zwaartekracht van de plek waar je bent en wordt uitgedrukt in Newton. Je hebt dus een ander gewicht op andere planeten. Zo is je gewicht veel groter op Jupiter dan op Mars, omdat Jupiter meer zwaartekracht uitoefent dan Mars. Schrijf een programma dat je gewicht op aarde omzet naar je gewicht op een ander hemellichaam. Je krijgt volgende omzettingstabel:

• Mercurius: 0.38 (een persoon van 100kg voelt zich alsof hij 38kg weegt)

• Venus: 0.91

• Aarde: 1.00 (een persoon van 100kg voelt zich alsof hij 100kg weegt)

• Mars: 0.38

• Jupiter: 2.34

• Saturnus: 1.06

• Uranus: 0.92

• Neptunus: 1.19

• Pluto: 0.06

Technische analyse

UI

console applicatie

voorbeeldinteractie(s)

Op Mercurius heb je een schijnbaar gewicht van 26.22kg.
Op Venus heb je een schijnbaar gewicht van 62.79kg.
Op Aarde heb je een schijnbaar gewicht van 69kg.
Op Mars heb je een schijnbaar gewicht van 26.22kg.
Op Jupiter heb je een schijnbaar gewicht van 161.46kg.
Op Saturnus heb je een schijnbaar gewicht van 73.14kg.
Op Uranus heb je een schijnbaar gewicht van 63.48kg.
Op Neptunus heb je een schijnbaar gewicht van 82.11kg.
Op Pluto heb je een schijnbaar gewicht van 4.14kg.

Technische hulp

Programmaverloop

Plaats je gewicht in een variabele. Kies zelf een geschikt type.

Testscenario's

• Test uit voor je eigen gewicht.

• Test uit voor het gewicht van een persoon met een massa van 100kg.

Ondersteunend materiaal

Hou het voorlopig op de cursus.