In alle lessen (hoorcollege en practica) hebben we 2 zaken nodig:

1. Deze cursus

2. Een laptop met daarop Visual Studio Code editie geïnstalleerd.

Introductie tot programmeren met C-Sharp

Het algoritme

De essentie van een computerprogramma is het zogenaamde algoritme (het "recept" zeg maar). Dit is de reeks instructies die het programma moet uitvoeren telkens het wordt opgestart. Het algoritme van een programma moet je zelf verzinnen. De volgorde waarin de instructies worden uitgevoerd zijn uiteraard zeer belangrijk. Dit is exact hetzelfde als in het echte leven: een algoritme om je fiets op te pompen kan zijn:

1. Haal dop van het ventiel
2. Plaats pomp op ventiel
3. Begin te pompen

Eender welke andere volgorde van bovenstaande algoritme zal vreemde (en soms fatale) fouten geven.

C-Sharp

Om een algoritme te schrijven dat onze computer begrijpt dienen we een programmeertaal te gebruiken. Net zoals er ontelbare spreektalen in de wereld zijn, zijn er ook vele programmeertalen. C# (spreek uit 'siesjarp') is er een van de vele. In tegenstelling tot onze spreektalen moet een computertaal 'exact' zijn en moet het op ondubbelzinnige manier door de computer verstaan worden. C# is een taal die deel uitmaakt van de .NET (spreek uit 'dotnet') omgeving die meer dan 15 jaar geleden door Microsoft werd ontwikkeld (juli 2000).

Deze cursus werd geschreven in Markdown. Helaas ondersteunt deze geen # in titels. Daardoor heet dit hoofdstuk "C-Sharp" en niet "C#". Niets aan te doen.

De geschiedenis en de hele .NET-wereld vertellen zou een cursus op zich betekenen en gaan we hier niet doen. Het is nuttig om weten dat er een gigantische bron aan informatie over .NET en C# online te vinden is, beginnende met docs.microsoft.com.

Met .NET Core kun je zowel webapplicaties, desktopapplicaties, microservices en Internet of Things toepassingen ontwikkelen.

Doelstelling

1. weet je hoe de basisstructuur van een C# programma in elkaar steekt

2. ken je de basiselementen van het programmeren:

   1. declaratie: gegevens en variabelen

   2. statement: één instructie

   3. functie of methode: een reeks instructies om één specifiek doel te realiseren, bijvoorbeeld voor het bereken van de oppervlakte van een cirkel In Object Oriented jargon spreekt men van een methode en vermits C# een OO taal is, zullen we in deze cursus verder het woord methode gebruiken. Als jullie JavaScript leren ga je het niet over een methode hebben maar over een functie omdat JavaScript geen strikte OO taal is.

De basisstructuur van een C# programma

Schema

Detail

Beschrijving van bovenstaande basisstructuur

1. sleutelwoorden (keywords) In de editor zie je dat sommige woorden in blauw worden weergegeven. Visual Studio geeft alle sleutelwoorden in het blauw weergeven. Sleutelwoorden zijn vooraf gedefinieerde, gereserveerde woorden die een speciale betekenis hebben voor de C# compiler. Je kan ze niet als namen (identifiers) in je programma gebruiken. Een lijst van alle gereserveerde sleutelwoorden vind je op C# Keywords.

2. namespace Letterlijk vertaald is dat een naamruimte. Deze structuur biedt de mogelijkheid om namen van o.a. klassen en methode - in programmeerjargon spreekt men van identifiers - in een naamspace te groeperen. Je moet er dan enkel voor zorgen dat deze namen uniek zijn binnen de namespace. De regels en afspraken voor het geven van namen aan namespaces vind je op Names of Namespaces. Je kan een namespace vergelijken met een familienaam. Binnen de 'naamruimte' van een familienaam moeten de voornamen uniek zijn. Maar dezelfde voornaamen kunnen in verschillende familienamen gebruikt worden: De namespace in het voorbeeld hierboven is BeginnenMetCSharp. Visual Studio gebruikt de naam van het project voor het benoemen van deze namespace.

3. klasse Gegevens (data) en algoritmes (programma's) worden ondergebracht in klassen. Dit maakt een programma overzichtelijker. In het tweede semester gaan we dieper in op klassen en objecten ('exemplaren' van een klasse). In het eerste semester gebruiken we klassen alleen om code te ordenen. De klassenaam in het voorbeeld hierboven is Program. Deze klassenaam wordt door Visual Studio standaard gebruikt wanneer je een nieuw project aanmaakt. De regels en afspraken voor het geven van namen aan klassen vind je op Names of Classes, Structs, and Interfaces.

4. methode In C# staat code altijd in een methode. Je kan geen statement schrijven zonder eerst een methode te hebben gemaakt. Hier moeten enkele zaken worden opgemerkt:

   1. naamgeving De namen van methoden worden in pascalnotatie geschreven, meer info op Names of Methods.

   2. static Het sleutelwoord static is een modifier. Met een modifier geven we aan hoe we de methode willen gebruiken. Vermits we in het eerste semester klassen enkel en alleen gaan gebruiken om code te ordenen en niet om objecten te maken en te gebruiken, gaan we meestal de modifier static vóór de methode naam plaatsen, zoals in het voorbeeld hierboven. Met static bedoelen we dan deze methode tot de klasse behoort en niet tot de objecten die op basis van die klasse worden gemaakt.

   3. void In C# spreken we van methoden. Maar een methode is eigenlijk een functie. Een functie retourneert meestal een waarde. Is dat niet zo moet je aangegeven dat de methode geen waarde retourneert door er void vóór de plaatsen zoals de Main methode in het voorbeeld hierboven.

   4. Main Dit is de naam van de methode. De moeder aller methoden in een C# programma draagt de naam Main methode. Elk programma dat je ooit gaat schrijven in C# moet een Main methode bevatten. Het is bovendien de enige methode die zal worden uitgevoerd als je het programma runt. Alle andere methode worden niet automatisch uitgevoerd. Wil je een bepaalde methode laten uitvoeren moet je die in de Main methode oproepen.

   5. (string[] args) Na de naam staan twee ronde haakjes. Tussen de ronde haken kan je parameters plaatsen. In deze parameters worden de argumenten die bij het oproepen van de methode worden meegegeven opgevangen. In het voorbeeld hierboven is dat string[] args. Dat wil zeggen dat je de Main methode kan oproepen en een reeks van argumenten kan meegeven. We komen hier later op terug. Je mag deze parameter gerust verwijderen vermits we pas later leren werken array's. De Main methode hierboven bevat slechts 1 statement.

5. statement Er is maar 1 statement. In het statement roepen we de WriteLine methode op die in de klasse Console staat. De klasse Console staat in de namespace met de naam System. Bovenaan, op regel 1, geven we aan dat we die bibliotheek in ons programma zullen gebruiken met het statement using System; Het statement ziet er zo uit:

   Copy

   Console.WriteLine("Hello World!");

   Het eerste wat we opmerken is dat een statement eindigt met een ; (een puntkomma). In dit statement roepen we de methode WriteLine op en geven als argument de tekst "Hello World" mee. De methode WriteLine beschikt over 1 parameter die deze tekst aanneemt en voor ons in de console zal tonen.

Opzettelijk een fout maken

We willen zien wat er gebeurt als er een fout in het programma staat. We verwijderen het puntkomma aan het einde van het statement in de Main functie. We vervangen

Console.WriteLine("Hello World!");

door

Console.WriteLine("Hello World!")

Het enige dat we hebben gewijzigd is de puntkomma op het einde.

Opzettelijke fout testen

Probeer het programma opnieuw uit te voeren. Je krijgt een melding dat er iets mis is. Vink eerst aan dat er onthouden moet worden wat je nu doet en geef dan aan dat je de fouten wil tonen via "Show Errors". Dit geeft je een overzicht, waarin je opmerkt dat er iets niet klopt op de regel en in de kolom waar de puntkomma ontbreekt. In de screenshot staat [9,46] en dat wijst op regel 9 van de code, positie 46. Waar de puntkomma moet staan, dus.

Je ziet ook dat het haakje net na "World!" rood onderlijnd is. Dat wijst op de positie van de fout. Let op: ook hier weet de ontwikkelomgeving niet precies wat je uiteindelijk wil, dus zie dit eerder als een hint.

Fout corrigeren

Plaats de puntkomma opnieuw op het einde van het statement op regel 9.

Opnieuw testen

Voer het programma opnieuw uit.

Meest voorkomende fouten

De meest voorkomende fouten in deze eerste weken zullen zijn:

• Puntkomma vergeten.

• Schrijffouten in je code RaedLine i.p.v. ReadLine.

• Geen rekening gehouden met hoofdletter gevoeligheid Readline i.p.v. ReadLine (zie volgende hoofdstuk).

• Per ongeluk accolades verwijderd.

• Code geschreven op plekken waar dat niet mag.

String

Een string is een reeks van 0, 1 of meerdere lettertekens, zoals je ook kan zien als je even met je muis boven een string keyword hovert in je code:

Strings declareren

Merk op dat we bij een string literal gebruik maken van aanhalingstekens (") terwijl bij chars we een apostrof gebruiken ('). Dit is de manier om een string van een char te onderscheiden.

Volgende code geeft twee keer het cijfer 1 onder elkaar op het scherm, maar de eerste keer gaat het om de weergave van een string (reeks van tekens) en de tweede keer van een int (effectief getal):

string eenString = "1"; 
int eenGetal = 1;

Console.WriteLine(eenString);
Console.WriteLine(eenGetal);

De output van dit programma zal dan zijn:

1
1

Fout gebruik van strings zal code geven die niet zal gecompileerd worden:

string eenString = 1; //fout
int eenGetal = "1"; //fout

1. In de tweede toekenning proberen we een literal van het type int toe te kennen aan een variabele van het type string.

2. In de laatste toekenning proberen we een literal van het type string toe te kennen aan een variabele van het type int.

Strings bevatten veel ingebouwde functionaliteit. Als je deze leert gebruiken, kan je al snel nuttige programmaatjes voor tekstverwerking schrijven.

Length

De lengte van een string is het aantal symbolen in de weergegeven versie. Je plaatst .Length achter de string om de lengte te weten te komen. Enkele voorbeelden:

Console.WriteLine("hallo".Length); // levert 5 want: 5 symbolen in de uiteindelijke weergave
Console.WriteLine("hallo ".Length); // levert 6 want: 6 symbolen in de uiteindelijke weergave

Substring

Een string is een reeks van 0 of meer symbolen in een bepaalde volgorde. Dat wil zeggen dat we elk symbool een nummer kunnen toekennen. Misschien wat vreemd, maar het eerste symbool krijgt nummer 0, het tweede krijgt nummer 1, het derde nummer 2,... en het laatste krijgt een nummer gelijk aan de Length van de string min één. Dit nummer heet de index van het symbool.

We kunnen een substring (= deel van een string) opvragen door de index van het eerste symbool en de lengte mee te geven als volgt:

Console.WriteLine("Hallo, wereld".Substring(4,5)); // toont o, we

Je mag de lengte achterwege laten om vanaf de gegeven index tot het einde van de string te gaan:

Console.WriteLine("Hallo, wereld".Substring(4)); // toont o, wereld

Deze methode verandert een string niet. Er is geen enkele methode die dat doet, want je kan een string niet veranderen in C#. Je kan er alleen een nieuwe mee bouwen. De methode berekent wel een nieuwe string met de gewenste eigenschappen. Dit is een belangrijk onderscheid. Volgende drie voorbeelden tonen het verschil. Voer uit en verklaar.

string hallo1 = "hallo";
hallo1.substring(0,2);
Console.WriteLine(hallo1);

string hallo1 = "hallo";
Console.WriteLine(hallo1.substring(0,2));

string hallo1 = "hallo";
string hallo2 = hallo1.substring(0,2);
Console.WriteLine(hallo2);

IndexOf

Een index is, zoals hierboven aangegeven, de positie van een teken in de string. Als we willen weten waar een bepaalde substring in een string voorkomt, gebruiken we IndexOf:

Console.WriteLine("C# is cool".IndexOf("cool")); // geeft 6
Console.WriteLine("C# is cool".IndexOf("z")); // geeft -1 want komt niet voor
Console.WriteLine("C# is cool".IndexOf("Cool")); // geeft -1 want "Cool" MET HOOFDLETTER komt niet voor

ToUpper / ToLower

Met deze twee methodes bereken je een versie van de string waarop je ze toepast, maar dan in hoofdletters of in kleine letters. Let op: je past de oorspronkelijke string niet aan!

Console.WriteLine("C# is cool".ToUpper()); // C# IS COOL
Console.WriteLine("C# is cool".ToLower()); // c# is cool
string tekst = "DiT iS EnGe TeKsT";
tekst.ToLower();
Console.WriteLine(tekst); // DiT iS EnGe TeKsT -> tekst wordt niet aangepast door ToLower
tekst.ToUpper();
Console.WriteLine(tekst); // DiT iS EnGe TeKsT -> tekst wordt niet aangepast door ToLower
string berekendeTekst = tekst.ToUpper();
Console.WriteLine(berekendeTekst); // DIT IS ENGE TEKST -> uit tekst is iets anders berekend, wel in hoofdletters

Replace

Met deze methode kan je een substring vervangen door een andere substring. Ook deze methode past de oorspronkelijke tekst niet aan.

Console.WriteLine("C# is cool".Replace("C#","Racket")); // Racket is cool
Console.WriteLine("C# is cool".Replace("Java","Racket")); // C# is cool -> Java kwam niet voor dus is niet vervangen
string tekst = "C# is cool";
tekst.Replace("C#","Racket");
Console.WriteLine(tekst); // C# is cool -> uit tekst is iets anders berekend, tekst is niet aangepast

TrimStart / TrimEnd / Trim

Met deze methodes verwijder je witruimte (spaties, tabs, newlines,...) aan het begin of aan het einde van een string:

Console.WriteLine("     C# is cool".TrimStart()); // C# is cool, eerste teken is C en geen spatie
Console.WriteLine("C# is cool     ".TrimEnd()); // zelfde resultaat
Console.WriteLine("    C# is cool     ".Trim()); // zelfde resultaat

Scope van variabelen

De locatie waar je een variabele aanmaakt bepaalt de scope, oftewel de gegarandeerde levensduur, van de naam van de variabele. Ruwweg: als je binnen hetzelfde stel accolades werkt waarin een variabele is gedeclareerd, dan is die naam in scope en kan je hem gebruiken. Indien je de variabele dus buiten die accolades nodig hebt, dan heb je een probleem: de variabele is enkel bereikbaar binnen de accolades vanaf het punt in de code waarin het werd aangemaakt.

Zeker wanneer je begint met if, loops, methoden, etc. zal de scope belangrijk zijn: deze code-constructies gebruiken steeds accolades om codeblocks aan te tonen. Een variabele die je dus binnen een if-blok aanmaakt zal enkel binnen dit blok bestaan, niet erbuiten.

if( something == true)
{
    int getal = 0 ;  //Start scope getal
    getal = 6;
} // einde scope getal

Console.WriteLine(getal); // zal niet werken daar de scope van getal al gedaan was

Wil je dus getal ook nog buiten de if gebruiken zal je je code moeten herschrijven zodat getal voor de if wordt aangemaakt:

int getal = 0 ;  //Start scope getal
if( something == true)
{
    getal = 6;
} 

Console.WriteLine(getal);

Variabelen met zelfde naam

Zolang je in de scope van een variabele bent kan je geen nieuwe variabele met dezelfde naam aanmaken:

Volgende code is dus niet toegestaan:

{
    int getal = 0;
    {
        int getal = 5; //Deze lijn is niet toegestaan
    }

}

Je krijgt de error: A local variable named 'getal' cannot be declared in this scope because it would give a different meaning to 'getal', which is already used in a 'parent or current' scope to denote something else

Enkel de tweede variabele een andere naam geven is toegestaan in het voorgaande geval.

Dit is wel geldig, daar de scope van de eerste variabele afgesloten wordt door de accolades:

{
    int getal = 0 ;
    //....
}
//Verder in code
{
    int getal = 5;
}

Debuggen

Debugging is een essentiële skill. Bekijk onderstaande clip en zorg dat je de werking van elk gedemonstreerd onderdeel begrijpt. Gebruik voortaan altijd de debugger als je programma wel uitvoert, maar verkeerde resultaten produceert vooraleer je de lector aanspreekt.

Intussen kan je hopelijk stap voor stap een Flowgorithm programma in je hoofd uitvoeren. Als je de software gedownload hebt, kan je dit ook op je machine doen door telkens F6 te gebruiken. Je kan ook op elk punt in het programma kijken wat de waarden van je variabelen zijn via de knop met het symbooltje x=.

Voor C#-programma's is er een gelijkaardige tool in Visual Studio Code: de debugger. De naam is wat misleidend: deze zal geen bugs verwijderen uit je programma, maar zal je wel helpen stap voor stap door je programma te gaan. Als je programma bugs vertoont, is de kans groot dat je op deze manier de oorzaak kan vinden.

Dit wordt geïllustreerd door volgende code:

using System;

namespace Demonstratie_debugger
{
    class Program
    {
        public static void MethodeB() {
            int getal = 2;
            double kommagetal = 4.9;
            Console.WriteLine("B");
        }
        public static void MethodeA() {
            Console.WriteLine("A1");
            MethodeB();
            int getal1 = 56;
            int getal2 = 13;
            Console.WriteLine("A2");
        }
        static void Main(string[] args)
        {
            Program.MethodeA();
        }
    }
}

Eerst zet je ergens in deze code een breakpoint. Dit ziet er uit als een rood bolletje naast de code waar je programma moet "stilstaan". Je doet dit door op de plaats van het bolletje te klikken.

Dan start je je programma op via "Run -> Start debugging" (of via F5). De regel waarop je code gepauzeerd is, wordt aangeduid.

In dit geval is er maar één instructie: "voer MethodeA uit". We kunnen dit als één geheel doen via "step over" of we kunnen ook de stappen binnenin MethodeA bekijken via "step into".

In dit geval kunnen we in detail kijken hoe MethodeA werkt via "step into". We kunnen "step into" niet altijd uitvoeren: we hebben hiervoor toegang nodig tot de broncode van de instructie die we verder willen bekijken.

Door enkele stappen uit te voeren, kunnen we pauzeren op de toekenning van getal2:

Op dit punt in de code, kunnen we onder "variables" bekijken welke waarden onze variabelen op dit moment hebben (merk op: de toekenning van 13 is nog niet gebeurd, we staan stil vlak ervoor):

En via de "call stack" zien we dat we niet gewoon in MethodeA zitten, maar dat MethodeA is opgeroepen door Main:

Een List<> collectie is de meest standaard collectie die je kan beschouwen als een flexibelere variant op een een doodnormale array.

List aanmaken

De klasse List<T> is een zogenaamde generieke klasse. Tussen de < >tekens plaatsen we het type dat de lijst zal moeten gaan bevatten. Vaak wordt dit genoteerd als T voor "type". Bijvoorbeeld:

• List<int> alleGetallen= new List<int>();

• List<bool> binaryList = new List<bool>();

• List<Pokemon> pokeDex = new List<Pokemon>();

• List<string[]> listOfStringarrays = new List<string[]>();

Zoals je ziet hoeven we bij het aanmaken van een List geen begingrootte mee te geven, wat we wel bij arrays moeten doen. Dit is een van de voordelen van List: ze groeien mee. Als we toch een begingrootte meegeven (zoals in de kennisclip even getoond wordt) is dat enkel om de performantie van de code wat te verhogen in bepaalde scenario's. Wij gaan dit nooit doen.

Elementen toevoegen

Via de Add() methode kan je elementen toevoegen aan de lijst. Je dient als parameter aan de methode mee te geven wat je aan de lijst wenst toe te voegen. Deze parameter moet uiteraard van het type zijn dat de List verwacht.

In volgende voorbeeld maken we een List aan die objecten van het type string mag bevatten en vervolgens plaatsen we er twee elementen in.

List<String> myStringList = new List<String>();
myStringList.Add("This is the first item in my list!");
myStringList.Add("And another one!");

Elementen indexeren

Het leuke van een List is dat je deze ook kan gebruiken als een gewone array, waarbij je met de indexer elementen kan aanspreken. Stel bijvoorbeeld dat we een lijst hebben met minstens 4 strings in. Volgende code toont hoe we de string op positie 3 kunnen uitlezen en hoe we die op positie 2 overschrijven:

Console.WriteLine(myStringList[3]);
myStringList[2] = "andere zin";`

Ook de klassieke werking met for blijft gelden. De enige aanpassing is dat List<T> niet met Length werkt maar met Count.

for(int i = 0 ; i < myStringList.Count; i++)
{
    Console.WriteLine(myStringList[i])
}

Wat kan een List nog?

Interessante methoden en properties voorts zijn:

• Clear() :methode die de volledige lijst leegmaakt

• Insert(): methode om element op specifieke plaats in lijst toe te voegen, bijvoorbeeld:

  Copy

  myStringList.Insert(1,"A fourth sentence");

  voegt de string toe op de tweede plek en schuift de rest naar achter

• Contains(): geef als parameter een specifiek object mee (van het type T dat de List<T> bevat) om te weten te komen of dat specifieke object in de List<> terug te vinden is. Indien ja dan zal true worden teruggeven.

• IndexOf(): geeft de index terug van het element item in de rij. Indien deze niet in de lijst aanwezig is dan wordt -1 teruggegeven.

• RemoveAt(): verwijder een element op de index die je als parameter meegeeft.

• Remove(): verwijder het gegeven element

Foreach loops

Je kan met een eenvoudige for of while-loop over een lijst itereren, maar het gebruik van een foreach-loop is toch handiger.

Dit is dan ook de meestgebruikte operatie om eenvoudig en snel een bepaald stuk code toe te passen op ieder element van de lijst:

List<int> integerList=new List<int>();
integerList.Add(2);
integerList.Add(3);
integerList.Add(7);

foreach(int prime in integerList)
{
   Console.WriteLine(prime);
}

Oefeningen

Oefening: H6-ArrayTrueFalse

Leerdoelen

• Declareren van arrays

• Initialiseren van arrays

• Opvullen van arrays

• Arrays gebbruiken - afprinten

Functionele analyse

Maak een array gevuld met afwisselend true en false (de array is 30 lang)

Per array: output de array naar het scherm, maar ieder element naast elkaar met komma gescheiden. Dus niet:

1 true

2 false

3 true

4 \\etc

maar wel: true, false, true, ...

Implementeer onderstaande flowchart in C#.

Technische analyse

Voorbeeldinteractie

Oefening: H6-ArrayOefener1

Leerdoelen

• Declareren van arrays

• Initialiseren van arrays

• Opvullen van arrays

• Arrays gebruiken

Functionele analyse

Maak een programma dat aan de gebruiker vraagt om 10 waarden (int) in te voeren in een array. Vervolgens toont het programma de som, het gemiddelde en het grootste getal van deze 10.

Vervolgens vraagt het programma de gebruiker om een getal in te voeren. Het programma toont dan alle getallen die groter of gelijk zijn aan dit ingevoerde getal zijn die in de array aanwezig zijn. Indien geen getallen groter zijn dan verschijnt een bericht Niets is groter op het scherm.

Implementeer onderstaande flowchart in C#. Merk op: je kan in principe de statistieken al bijhouden terwijl de getallen worden ingevoerd, maar hier worden ze pas achteraf berekend. Doe het ook zo.

Technische analyse

Voorbeeldinteractie

Oefening: H6-Boodschappenlijst

Leerdoelen

• Declareren van arrays

• Initialiseren van arrays

• Opvullen van arrays

• Arrays gebruiken

Functionele analyse

Maak een programma dat de gebruiker een boodschappenlijstje laat samenstellen.

• Het programma vraagt eerst hoeveel items de boodschappenlijst moet bevatten en laat dan de lijst vullen.

• Vervolgens wordt een gesorteerde lijst van de items getoond.

• Daarna, in de winkel, kan de gebruiker aangeven welke items er gekocht worden. De gebruiker kan dit blijven doen zolang er 'ja' geantwoord wordt op de vraag 'Nog winkelen?'. Als de gebruiker een item intypt dat niet op de lijst staat, wordt er een bericht getoond.

• Na het winkelen toont het programma welke items van de lijst niet gekocht zijn.

Implementeer onderstaande flowchart in C#.

Technische analyse

Voorbeeldinteractie

Oefening: H6-Kerstinkopen

Leerdoelen

• Declareren van arrays

• Initialiseren van arrays

• Opvullen van arrays

• Arrays gebruiken

• Array methodes gebruiken

Functionele analyse

Maak een programma dat kan gebruikt worden om kerstinkopen te doen, rekening houdend met een budget. Na de inkopen, wordt het totaal gespendeerd bedrag getoond en het hoogste, laagste en gemiddelde bedrag.

Technische analyse

Probeer zelf een flowchart te maken en zet die dan om naar C#.

Voorbeeldinteractie

Oefening: H6-Lotto

Leerdoelen

• Arrays in flowcharts gebruiken

• Declareren van arrays

• Initialiseren van arrays

• Opvullen van arrays

• Opzoeken waarde in arrays

Functionele analyse

Je vraagt de gebruiker zijn 6 lotto getallen (getal tussen 1 en 42) in te geven. Je hoeft geen controle te doen op de getallen die de gebruiker ingeeft. Je bewaart deze getallen in een array lottoFormulier.

Vervolgens simuleer je een trekking. Dat doe je door random 6 getallen te genereren (zie hiervoor Random) en die ook in een array lottoTrekking te bewaren. Let op: hier moet je wel controleren of het inderdaad 6 verschillende getallen zijn (hoe kan je nagaan of iets aanwezig is in je array?).

Dan doe je een validatie. Heeft de gebruiker 3 juiste cijfers wint hij 10 €, bij 4 juiste cijfers 1000 €, bij 5 juiste cijfers 100.000 € en bij 6 juiste cijfers 10.000.000 €.

Zorg dat alles mooi wordt getoond aan de gebruiker. Lotto getallen in stijgende volgorde, Trekking getallen in stijgende volgorde, winst. Zie voorbeeldinteractie.

Technische analyse

Maak een flowchart en zet die om naar C#

Wat betreft het random genereren van 6 getallen tussen 1 en 42. Daar krijg je het volgend stukje code voor (probeer te begrijpen hoe het werkt en zoek op internet het gebruik van Random eens op):

Random random = new Random();
int lottoGetal;
        
for (int i = 0; i < lottoTrekking.Length; i++) {
    do {
        lottoGetal = random.Next(42) + 1;
    }
    while (Array.IndexOf(lottoTrekking, lottoGetal) >= 0);
    lottoTrekking[i] = lottoGetal;
}

Voorbeeldinteractie

Uitbreiding

Test de ingegeven lotto getallen en zorg er voor dat er geen getallen kleiner dan 1 of groter dan 42 ingegeven kunnen worden en dat er ook geen dubbels voorkomen..

Oefening: H6-IntegerIndexOf

Leerdoelen

• Arrays in flowcharts gebruiken

• Opzoeken waarde in integer arrays – zelf geschreven methode

Functionele analyse

Probeer d.m.v. Flowgorithm de flowchart te gebruiken en zet dan om naar C#.

Technische analyse

Voorbeeldinteractie

Oefening: H6-BinarySearch

Leerdoelen

• Arrays in flowcharts gebruiken

• De array gebruiken, in een array zoeken.

Functionele analyse

Heel eenvoudig uitgelegd zal het algoritme de te zoeken waarde vergelijken met de middelste waarde (van een gesorteerde array). Als de waarde niet gelijk is wordt dat gedeelte van de array waar de waarde zich niet in kan bevinden weggegooid. De zoektocht gaat verder totdat de waarde is gevonden (of niet gevonden indien alle mogelijkheden zijn doorzocht)

Implementeer onderstaande flowchart in C#. Om twee strings te ordenen, gebruik je string1.CompareTo(string2). Dit levert -1 als string1 voor string2 komt, 1 als string1 na string2 komt en 0 als ze op dezelfde plaats komen.

Technische analyse

Voorbeeldinteractie

Oefening: H6-Boodschappenlijst-list

Leerdoelen

• Declareren van een List

• Initialiseren van een List

• List gebruiken

Functionele analyse

Maak een een alternatieve versie van H6-Boodschappenlijst. Maak ditmaal gebruik van List<T> in plaats van een array.

Technische analyse

• Je hoeft de grootte van de lijst niet meer op voorhand te vragen.

• Een lijst myList sorteren doe je door myList.sort() op te roepen.

• Je mag elementen die gekocht zijn gewoonweg verwijderen uit de lijst.

• Op het eindetoon je de resterende items met een foreach lus.

• Je geeft een lege regel in om aan te geven dat je niets wil toevoegen aan je lijstje.

• Noem je methode BoodschappenList

Voorbeeldinteractie

Wat is item 1 op je lijst?
> kaas
Wat is item 2 op je lijst?
> eieren
Wat is item 3 op je lijst?
> boter
Wat is item 4 op je lijst?
>
Dit is je gesorteerde lijst:
1: boter
2: eieren
3: kaas
Op naar de winkel!
Welk item heb je gekocht?
> kaas
Nog winkelen? (Ja of Nee)
> nee
Naar huis met de boodschappen!
Volgende items van je lijst ben je vergeten te kopen:
boter eieren

Oefening: H6-Kerstinkopen-list

Leerdoelen

• Declareren van een List

• Initialiseren van een List

• List gebruiken

Functionele analyse

Maak een een alternatieve versie van H6-Kerstinkopen. Maak ditmaal gebruik van List<T> in plaats van een array.

Technische analyse

• Je hoeft niet meer te vragen op voorhand hoe veel cadeautjes er gekocht zullen worden.

• Je mag stoppen bij een lege regel invoer.

• Je moet ook stoppen zodra je over budget gaat.

• Noem je methode KerstinkopenList

Voorbeeldinteractie

Wat is het budget voor je kerstinkopen?
> 500
Prijs van cadeau 1?
> 200
Prijs van cadeau 2?
> 330
Je bent al 30.0 euro over het budget!
Info over je aankopen:
Totaal bedrag: 530.0 euro
Duurste cadeau: 330.0 euro
Goedkoopste cadeau: 200.0 euro
Gemiddelde prijs: 265.0 euro

Een stappenplan, en dus een methode, voer je uit met het oog op een bepaald resultaat. Soms moet dat resultaat terugbezorgd worden aan een opdrachtgever. Soms niet. Methodes staan toe beide variaties op een stappenplan te schrijven.

We gebruiken opnieuw een proces uit het echte leven om de interactie te omschrijven voor we de sprong maken naar code.

Voorbeeld uit het echte leven

Denk aan een ouderwetse bakker. Het stappenplan dat deze bakker volgt is er een om brood te maken. Om brood te maken heb je bloem nodig. Bloem maken is niet echt een onderdeel van het takenpakket van de bakker. Hij laat de molenaar dit voor hem doen. Hij vraagt niet gewoon aan de molenaar om bloem te maken, maar ook om deze aan hem te bezorgen zodat hij er zelf mee verder kan werken. De bakker is niet geïnteresseerd in hoe de molenaar bloem maakt, maar hij heeft het eindproduct nodig om zijn brood af te maken.

We vertalen nu deze interactie naar code en verklaren daarna de vertaling:

Hier vallen twee zaken op: in de signatuur (d.w.z. alles van het begin van de regel tot en met het gesloten ronde haakje) van de methode Molenaar staat niet void, maar string. Dit komt omdat deze methode een resultaat teruggeeft aan de opdrachtgever en dat resultaat van het type string is. Daarnaast heb je het sleutelwoord return, gevolgd door de tekst "bloem". Het woordje return betekent: "bezorg dit aan de code die deze methode heeft opgeroepen". Anders gezegd: dit is hoe de molenaar de geproduceerde bloem overhandigt aan zijn opdrachtgever, de bakker. Waar je de call Molenaar() schrijft komt tijdens de uitvoering het geproduceerde resultaat dankzij die return.

Het return type

Je moet dus noteren wat voor resultaat er achter return staat: een string of eventueel iets anders. Als er een string volgt na return, zeggen we dat string het return type is van die methode. Als een methode een geheel getal produceert, heeft ze het return type int of een verwant getaltype.

Maar niet alle methodes bezorgen iets terug aan hun opdrachtgever. Sommige hebben gewoon een effect. Voor deze methodes schrijven we void als return type. Als een methode dit return type heeft, kunnen we het resultaat van een call dus niet toekennen aan een variabele, want er is geen resultaat.

We kunnen dus wel doen: string ingredient3 = Molenaar(); (want het return type van Molenaar() is string) maar we kunnen niet schrijven: string product = Bakker(); (want Bakker() heeft return type void en produceert dus geen resultaat). Deze code compileert dan ook niet.

Gekend voorbeeld van een vaak gemaakte fout

Je kent de methode Replace van strings. Je gebruikt deze als volgt:

Veel beginners doen het volgende:

Dit is fout. Replace berekent het resultaat van de aanpassing en geeft dat terug aan de opdrachtgever. Het past de ingevoerde tekst niet aan. In de code van Replace staat dus ook een return!

Parameters en returnwaarden samen

Als je parameters en returnwaarden combineert, worden methoden erg flexibel. Dan kan je al echte bouwsteentjes van een programma gaan schrijven.

Een voorbeeld: de stelling van Pythagoras vertelt ons hoe lang de schuine zijde van een driehoek met twee rechte hoeken is:

Als we deze berekening regelmatig uitvoeren voor verschillende waarden van a en b, kunnen we ze als volgt in een methode gieten:

Nu kunnen we heel snel allerlei schuine zijdes uitrekenen, bv.:

Bovendien maken we gebruik van het feit dat de methode Sqrt (square root is vierkantswortel) ook een parameter heeft en een resultaat teruggeeft. Eigenlijk verloopt een uitvoering dus zo:

1. de methode Main start op

2. we willen bepaalde tekst uitprinten, maar we moeten die eerst nog bepalen met de methode Pythagoras

3. de methode Pythagoras start op met de argumenten 4 en 3

4. de methode berekent de som van de kwadraten en noemt deze som

5. de methode maakt zelf gebruik van nog een methode, Sqrt, en geeft daarbij som als argument

6. Sqrt rekent de vierkantswortel uit en geeft deze terug aan Pythagoras

7. Pythagoras geeft deze verder door aan Main

8. de zin wordt correct afgeprint

Meestal is het dus een goed idee zo weinig mogelijk informatie te communiceren met WriteLine en zo veel mogelijk met return te werken. Meerbepaald: gebruik WriteLine wanneer je de uiteindelijke informatie in haar uiteindelijke vorm hebt en deze echt aan de gebruiker moet tonen. Gebruik return wanneer je het resultaat van een deeltaak aan een opdrachtgever wil bezorgen.

Volgend Flowgorithm toont aan hoe je dankzij methoden een probleem kan opbreken in meerdere kleine stappen, waarbij je informatie doorgeeft via parameters en returnwaarden:

Berekeningen

Een groot deel van je leven als ontwikkelaar zal bestaan uit het bewerken van variabelen in code. Meestal zullen die bewerkingen de vorm aannemen van berekeningen. De Math klasse zal ons hier bij kunnen helpen.

De Math klasse

De Math klasse bevat aardig wat handige methoden. Deze klasse bevat methoden voor een groot aantal typische wiskundige methoden (sinus, cosinus, vierkantswortel, macht, afronden, etc.) en kan je dus helpen om leesbaardere expressies te schrijven.

Stel dat je de derde macht van een variabel getal wenst te berekenen. Zonder de Math-klasse zou dat er zo uitzien:

double result = getal*getal*getal;

Met de klasse kunnen we schrijven:

double result = Math.Pow(getal, 3);

Het voordeel is dat je dit makkelijk kan aanpassen naar een hogere macht.

De Math klasse ontdekken

Als je in Visual Studio Code Math schrijft, gevolgd door een punt . krijg je alles te zien wat de Math-klasse kan doen.

Methoden gebruiken

1. Schrijf de Methode zonder argumenten. Bijvoorbeeld Math.Pow() (je mag de rode error negeren).

2. Je krijgt nu de help-files te zien van deze methode op MDSDN.

3. Klik desnoods op de pijltjes voor de verschillende versies van deze methode.

PI (π)

Ook het getal Pi (3.141...) is beschikbaar in de Math klasse. Dit is geen methode, maar een gewone waarde. Het woordje const betekent dat je deze waarde niet kan aanpassen.

Je kan deze als volgt gebruiken in berekeningen:

double straal = 5.5;
double omtrek = Math.PI * 2 * straal;

Klassiek afronden

"Klassiek" afronden is afronden tot het dichtstbijzijnde getal. Dit doe je met Math.Round. Deze methode heeft twee parameters: het getal dat je wil afronden en het aantal cijfers na de komma dat je wil bewaren. Let hierbij goed op: dit berekent een nieuwe waarde (van type double) met de gewenste precisie, maar zorgt er niet automatisch voor dat deze waarde ook met dat aantal cijfers getoond wordt. Anders gezegd: Math.Round(12.0, 2) kan exact voorgesteld worden met hooguit twee cijfers na de komma, maar wordt standaard niet getoond met twee cijfers na de komma. Dat laatste behandelen we verder bij stringformattering.

Afronden naar boven of beneden

Naast "klassiek" afronden kan je ook zuiver in één richting afronden. Dan krijg je het dichtstbij gelegen gehele getal waarvoor geldt benadering =< getal (bij naar beneden afronden) of benadering >= getal (bij naar boven afronden). Dit doen we met Math.Floor en Math.Ceiling. Bijvoorbeeld: Math.Floor(12.6) is 12.0, ook al is 13 een benadering die dichter bij ligt. Dat komt omdat 12 =< 12.6, terwijl 13 > 12.6.

Random getallen genereren

Random getallen genereren in je code kan nuttig zijn om verschillende scenario's te simuleren, om software te beveiligen of om de gebruiker een interactievere ervaring te geven.

Random generator

De Random-klasse laat je toe om eenvoudig willekeurige gehele en komma-getallen te maken. Je moet hiervoor twee zaken doen:

1. Maak eenmalig een Random-generator aan: Random randomgen = new Random(); (wat dit juist wil zeggen zien we in Semester 2).

2. Roep de Next methode aan telkens je een nieuw getal nodig hebt, bijvoorbeeld: int mijnGetal = randomgen.Next(); De aanroep van de methode Next() zal een geheel getal willekeurig genereren.

De eerste stap dien je dus maar één keer te doen. Vanaf dan kan je telkens aan de generator een nieuw getal vragen m.b.v. Next.

Volgende code toont bijvoorbeeld 3 random getallen op het scherm:

Random mygen = new Random();
int getal1 = mygen.Next();
int getal2 = mygen.Next();
int getal3 = mygen.Next();
Console.WriteLine(getal1);
Console.WriteLine(getal2);
Console.WriteLine(getal3);

Next mogelijkheden

Je kan de Next methode ook 2 waarden meegeven, namelijk de grenzen waarbinnen het getal moet gegenereerd worden. De tweede waarde wordt nooit gegenereerd. Wil je dus een getal tot en met 10 dan schrijf je 11, niet 10.

Enkele voorbeelden:

Random somegenerator = new Random();

int a = somegenerator.Next(0,10);  //getal tussen 0 tot en met 9
int b = somegenerator.Next(5,101);  //getal tussen 5 tot en met 100
int c = somegenerator.Next(0,b);  //getal tussen 0 tot en met het getal dat de lijn ervoor werd gegenereerd.

Genereer kommagetallen met NextDouble

Met de NextDouble methode kan je kommagetallen genereren tussen 0.0 en 1.0 (1.0 zal niet gegenereerd worden).

Wil je een groter kommagetal dan zal je dit gegenereerde getal moeten vermenigvuldigen naar de range die je nodig hebt. Stel dat je een getal tussen 0.0 en 10.0 nodig hebt, dan schrijf je:

Random myran = new Random();
double randomgetal= myran.NextDouble() * 10.0;

Via stringinterpolatie schrijf je je string min of meer zoals hij er uiteindelijk moet uitzien, maar vervang je de niet-letterlijke delen door geformatteerde waarden. Dit levert een goed leesbaar resultaat.

Door het $-teken VOOR de string te plaatsen geef je aan dat alle delen in de string die tussen accolades staan als code mogen beschouwd worden. Een voorbeeld maakt dit duidelijk:

string name = "Finkelstein";
int age = 17;
string result = $"Ik ben {name} en ik ben {age} jaar oud.";

In dit geval zal dus de inhoud van de variabele name tussen de string op de plek waar nu {name} staat geplaatst worden. Idem voor age. Dit mag, zelfs al is age geen string: hetgeen tussen de accolades staat, wordt altijd intern omgezet naar een string voor het in het resultaat wordt geplaatst. Dit gebeurt via de methode ToString, die voor elk soort data bestaat. Dus eigenlijk wordt het achter de schermen:

string result = $"Ik ben {name.ToString()} en ik ben {age.ToString()} jaar oud.";

Berekeningen doen bij string interpolatie

Je mag eender welke expressie tussen de accolades zetten bij string interpolation. Een expressie is iets dat je kan uitrekenen en dat je een resultaat oplevert. Bijvoorbeeld:

string result = $"Ik ben {name} en ik ben {age+4} jaar oud.";

Alle expressies tussen de accolades zullen eerst uitgevoerd worden voor ze tussen de string worden geplaatst. De uitvoer wordt nu dus: Ik ben Finkelstein en ik ben 17 jaar oud.

Eender welke expressie is toegelaten, dus je kan ook complexe berekeningen of zelfs andere methoden aanroepen:

string result = $"Ik ben {age*age+(3%2)} jaar oud.";

Mooier formatteren

Bij stringinterpolatie kan je ook bepalen hoe de te tonen variabelen en expressies juist weergegeven moeten worden. Je geeft dit aan door na de expressie, binnen de accolades, een dubbelpunt te plaatsen gevolgd door de manier waarop moet geformatteerd worden:

Wil je bijvoorbeeld een kommagetal tonen met maar 2 cijfers na de komma dan schrijf je:

double number = 12.345;
Console.WriteLine($"{number:F2}");

Hier stelt 2 het aantal cijfers na de komma voor. Je kan zelf kiezen om meer of minder cijfers te tonen door het getal aan te passen. Dit voorbeeld is gelijkaardig aan Console.WriteLine(Math.Round(number,2)), maar niet identiek. Dat komt omdat de geformatteerde string verplicht twee cijfers na de komma toont, zelfs als die niets veranderen aan de waarde van het getal. Als je een double zonder formattering weergeeft, worden nullen achteraan niet getoond. Dus voor getallen als 12 of 15.1 of 4.999(met minder dan twee cijfers na de komma na afronding) maakt het een verschil.

Nog enkele nuttige vormen:

• D5: geheel getal bestaande uit 5 cijfers (123 wordt 00123) (werkt enkel op gehele getallen en je kan het getal 5 vervangen door een positieve waarde naar keuze)

• C: geldbedrag (12,34 wordt € 12,34: teken van valuta afhankelijk van instellingen pc)

Alle format specifiers staan hier opgelijst. Voor deze cursus volstaat het dat je deze specifiers kent voor de verschillende soorten data.

Je kan je data ook een vaste breedte en uitlijning geven. Dit doe je door meteen na de waarde in kwestie een komma te plaatsen, met daarna de gewenste breedte. De tekst wordt dan rechts gealigneerd. Je kan ook een minteken gebruiken en dan wordt de tekst links gealigneerd. Bijvoorbeeld:

Console.WriteLine($"{"hallo",20} wereld");
Console.WriteLine($"{"hallo",-20} wereld");

Dit levert:

               hallo wereld
hallo                wereld

Dus de tekst "hallo" wordt opgevuld totdat hij in totaal 20 karakters telt. Elke regel telt 27 karakters, want " wereld" is niet mee geformatteerd, maar is gewoon achter de geformatteerde tekst gezet.

Manueel formatteren

Formattering is een handig hulpmiddel, maar het zal niet altijd alle scenario's dekken. In het voorbeeld hierboven is het bijvoorbeeld verplicht een constante waarde te gebruiken. Je kan geen variabele invullen waar 20 staat. Het is bijvoorbeeld ook niet mogelijk tekst te centeren (in plaats van links of rechts uit te lijnen). Dat hoeft geen probleem te zijn: je kan altijd een methode schrijven die tekst op de gewenste manier omzet.

Ingebouwde methodes voor formattering

Via PadLeft en PadRight kan je tekst opvullen tot de gewenste lengte met andere karakters dan een spatie. Bijvoorbeeld, voor hetzelfde effect als eerder:

Console.WriteLine($"{"hallo".PadLeft(20)} wereld");
Console.WriteLine($"{"hallo".PadRight(20)} wereld");

Zoals vaak lever je hiermee wat gemak in voor extra flexibiliteit. Je kan namelijk opvullen met een karakter naar keuze, tot een variabele lengte:

Console.WriteLine("Hoe breed wil je de string?");
int breedte = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"{"hallo".PadLeft(breedte,'!')} wereld");
Console.WriteLine($"{"hallo".PadRight(breedte,'!')} wereld");

Eigen methodes voor formattering

Als er geen mehode is om een string juist te tonen, kan je er altijd zelf een maken. Je zorgt dat de string en extra opties zoals de gewenste breedte parameters zijn en je geeft de geformatteerde string terug als resultaat. Er is bijvoorbeeld geen methode om tekst in te korten tot een maximale lengte, maar je kan ze zelf schrijven als volgt:

static string Trunkeer(string input, int lengte) {
    return input.Substring(0, Math.Min(input.Length, lengte));
}

Je zou bijvoorbeeld ook een methode kunnen schrijven om tekst centraal te aligneren.

Access modifiers bepalen welke code door welke andere code mag worden uitgevoerd of aangepast. We hebben al een aantal dingen public gemaakt bij wijze van demonstratie. Dit is handig om voorbeeldjes te tonen, maar in code van hoge kwaliteit, denk je grondig na voor je dit doet.

Public en private access modifiers

De access modifier geeft aan hoe zichtbaar een bepaald deel van de klasse is voor code buiten de klasse zelf. Wanneer je niet wilt dat "van buitenuit" (bv in Main, terwijl je een andere klasse dan Program schrijft) een bepaalde methode kan aangeroepen worden, dan dien je deze als private in te stellen. Wil je dit net wel dat moet je er expliciet public voor zetten.

Test in de voorgaande klasse Auto eens wat gebeurt wanneer je public verwijdert voor een van de methodes. Inderdaad, je krijgt een foutmelding. Lees deze. Ze zegt dat de methode die je wil oproepen wel bestaat, maar niet gebruikt mag worden. Dat komt omdat je testcode in de klasse Program staat en je methode deel uitmaakt van een andere klasse (meerbepaald Auto).

Als je duidelijk wil maken dat bepaalde code niet van buitenaf aangeroepen kan worden, schrijf dan private in plaats van public. Er zijn nog tussenliggende niveaus waar we later op ingaan en als je geen van beide modifiers schrijft, kan het zijn dat je code op zo'n tussenliggend niveau terecht komt. Als beginnende programmeur maak je er best een gewoonte van duidelijk te kiezen voor public of private.

Reden van private

Waarom zou je bepaalde zaken private maken? Het antwoord is opnieuw encapsulatie.

Neem als voorbeeld de kilometerstand. Het is wettelijk verboden een kilometerstand zomaar aan te passen. Hij mag alleen veranderen doordat er met een auto gereden wordt. Dan is het logisch dat dit ook alleen maar op deze manier kan voor onze auto-objecten. We kunnen dit realiseren door kilometers van public naar private te wijzigen. Dan kunnen we de kilometerstand nog wijzigen, maar enkel door de (publieke) methode Rijden te gebruiken. Als we hem dan nog willen kunnen bekijken (maar niet rechtstreeks wijzigen), kunnen we een extra (publieke!) methode ToonKilometerstand voorzien.

We kunnen ook methoden private maken. Dit gebeurt niet zo vaak als bij attributen, maar het kan wel. Dit doen we bijvoorbeeld als het gaat om een hulpmethode die binnen de klasse nuttig is, maar buiten de klasse fout gebruikt zou kunnen worden. Een typisch voorbeeld: een stukje code dat letterlijk herhaald wordt in twee of meer verschillende publieke methoden. In plaats van deze code te kopiëren, zonderen we ze af in een hulpmethode. Zo hoeven we eventuele bugfixes,... geen twee keer te doen.

SchoolAdmin project

Privé maken (en hernoemen) Cursussen

Het is moeilijk afspraken te maken over hoe Cursussen gebruikt mag worden. Iemand zou zich altijd kunnen vergissen en een cursus invullen op een positie die niet vrij is, of op een andere vrije positie dan de eerste. Daarom leggen we de regels rond dit attribuut vast in de klasse. We doen dit door over te schakelen op volgende structuur:

Hierbij gaat RegistreerVoorCursus zelf op zoek naar de eerste vrije positie. Als zo'n positie gevonden wordt, wordt de student ingeschreven voor de cursus.

Push je vooruitgang naar Gitlab!

Je kan objecten aanmaken door een omschrijving ervan in tekst om te zetten naar een constructoroproep. We noemen dit proces "deserialisatie". Een object omzetten naar een omschrijving noemen we "serialisatie". Deze omschrijving kan verschillende conventies volgen: XML, JSON, YAML, CSV,...

Objecten deserializeren met CSV

CSV wordt vaak gebruikt om objecten tussen programma's te verplaatsen. Een object inlezen vanaf een CSV bestand is een vorm van deserializeren.

// Speler voornaam, familienaam, geboortejaar
string[] lijnen = File.ReadAllLines(@"C:\spelers.csv");
Speler[] spelers = new Speler[lijnen.Length];
for (int i = 0; i < lijnen.Length; i++)
{
    string[] kolomwaarden = lijnen[i].Split(',');
    spelers[i] = new Speler(kolomwaarden[0],kolomwaarden[1],Convert.ToInt32(kolomwaarden[2]));
}

CSV wegschrijven

Je kan tekst uit een bestand lezen, maar uiteraard kan je ook naar een bestand wegschrijven. De 2 eenvoudigste manieren zijn:

• File.WriteAllText: deze gebruik je als je 1 enkele string wilt wegschrijven

• File.WriteAllLines: deze is de omgekeerde van ReadAllLines() en zal een array van strings wegschrijven.

Een voorbeeld:

string[] stringArray = new string[]
    {
        "cat",
        "dog",
        "arrow"
    };


File.WriteAllLines("file.txt", stringArray);

Opgelet met het schrijven naar bestanden: dit zal onherroepelijk het target bestand overschrijven. Gebruik if(File.Exists(pathtofile)) om te controleren of een bestand bestaat of niet. Eventueel kan je dan aan de gebruiker bevestiging vragen of je deze effectief wilt overschrijven.

Wil je CSV-bestand maken dan zal je eerst met String.Join of met stringinterpolatie een komma-separated lijst maken, bijvoorbeeld:

Speler[] spelers = {
    new Speler("Tim","Dams",1981),
    new Speler("Jos","Stoffels",1970),
    new Speler("Mounir","Hamdaoui",1984)
};

string[] lines = new string[spelers.Length];
for (int i = 0; i < lines.Length; i++)
{
    Speler speler = spelers[i];
    lines[i] = $"{speler.Voornaam},{speler.Familienaam},{speler.Geboortejaar}";
}

System.IO.File.WriteAllLines("spelers.csv", lines);

Naast de generieke List collectie, zijn er nog enkele andere nuttige generieke 'collectie-klassen' die je geregeld in je projecten kan gebruiken.

In een dictionary wordt ieder element voorgesteld door een sleutel (key) en de waarde (value) van het element. Het idee is dat je de sleutel kan gebruiken om de waarde snel op te zoeken. De sleutel moet dan ook uniek zijn. Dictionaries stellen geen reeks met een volgorde voor, maar geven je de mogelijkheid data met elkaar in verband te brengen.

Enkele voorbeeldjes die het idee achter Dictionary kunnen verduidelijken:

• een papieren telefoonboek is als een Dictionary met gecombineerde namen en adressen als keys en telefoonnummers als values

• een echt woordenboek is als een Dictionary met woorden als keys en omschrijvingen als values

• een array is als een Dictionary met getallen als keys en waarden van het type van de array als values

Bij de declaratie van de Dictionary<K,V> dien je op te geven wat het datatype van de key zal zijn , alsook het type van de waarde (value). Met andere woorden, K en V komen niet letterlijk voor, maar je vervangt ze door types die je al kent.

Voor bovenstaande voorbeelden:

• een echt woordenboek stel je best voor met string als type van de key en string als type van de value, want een woord stel je voor als string en een omschrijving ook

• een array van double kan je nabootsen door uint te gebruiken als type van de key en double als type van de value

• het telefoonboek moeten we wat vereenvoudigen, maar als we op basis van naam meteen een telefoonnummer konden opzoeken (zonder adresgegevens,...), dan zou string (de naam) het type van de key zijn en string (telefoonnummer) het type van de value. Het telefoonnummer is geen getal omwille van zaken die je niet met een getaltype kan voorstellen zoals +32 of 0473.

Gebruik Dictionary

In het volgende voorbeeld maken we een Dictionary van klanten aan. Iedere klant heeft een unieke ID (de key, die we als int gebruiken) alsook een naam (die niet noodzakelijk uniek is en de waarde voorstelt):

Dictionary<int, string> customers = new Dictionary<int, string>();
customers.Add(123, "Tim Dams");
customers.Add(6463, "James Bond");
customers.Add(666, "The beast");
customers.Add(700, "James Bond");

Bij de declaratie van customers plaatsen we dus tussen de < > twee datatypes: het eerste duidt het datatype van de key aan, het tweede dat van de values.

Merk op dat je niet verplicht bent om een int als type van de key (of value) te gebruiken, dit mag eender wat zijn, zelfs een klasse.

Dictionary<int,Pokemon> pokedex;
Dictionary<Student,PuntenLijst> puntenTabel;

We kunnen nu met behulp van bijvoorbeeld een foreach-loop alle elementen tonen. Hier kunnen we de key met de .Key-property uitlezen en het achterliggende object of waarde met .Value. Value en Key hebben daarbij ieder het type dat we hebben gedefinieerd toen we het Dictionary-object aanmaakten, in het volgende geval is de Key dus van het type int en Value van het type string:

foreach (var item in customers){
    Console.WriteLine($"{item.Key}\t:{item.Value}");
}

We kunnen echter ook een specifiek element opvragen aan de hand van de key. Stel dat we de waarde van de klant met key 123 willen tonen:

Console.WriteLine(customers[123]);

De key werkt dus net als de index bij gewone arrays, alleen heeft de key nu geen relatie meer met de positie van het element in de collectie.

Je kan de syntax met rechte haakjes ook gebruiken om een element toe te voegen. In tegenstelling tot Add, geeft deze syntax geen fout als de key al bestaat, maar vervangt hij het bestaande verband:

// dit gaat, terwijl het met Add verboden is
customers[123] = "klant A";
customers[123] = "klant A, opnieuw";

Als je wil weten of een bepaalde key voorkomt in een Dictionary, gebruik je de instantiemethode ContainsKey.

Voor de graduaatsopleiding volgen we een reeks afspraken (ook "conventies" genoemd) die bepalen welke code wel en niet aanvaardbaar is. Wanneer een groep programmeurs dezelfde afspraken volgt, is het voor iedereen makkelijker code uit te wisselen.

Als je deze pagina voor de eerste keer ziet, zullen de meeste van deze afspraken je nog niet veel zeggen. Dat is logisch. We zullen je tijdens de les wijzen op de afspraken die horen bij een nieuw concept, maar hier heb je een handig overzicht:

naamgeving

Onderstaande richtlijnen zijn gebaseerd op deze algemeen aanvaarde richtlijnen. We beperken ons tot de zaken die we tijdens de cursus zien.

• We kiezen namen in het Engels. Enkel tekst die aan de gebruiker getoond wordt, schrijven we in het Nederlands.

• Merk op dat het verschil tussen PascalCase en camelCase samenhangt met de default zichtbaarheid. Wanneer afgeweken wordt van de default zichtbaarheid, kan de conventie voor de notatie ook veranderen. Wij zullen ons in deze cursussen voor de eenvoud strikt aan de default zichtbaarheid houden.

• "meervoud toegestaan" betekent dat we iets noteren als een meervoud als de data ook meerdere objecten voorstelt. Bijvoorbeeld een lokale variabele met naam studenten en datatype Student[], maar een lokale variabele student met datatype Student.

• We beginnen niet elke identifier voor een private member met een underscore. Sommige programmeurs doen dit wel, maar wij volgen één richtlijn.

• Namen van klassen voor custom exceptions eindigen op Exception.

• Vermijd afkortingen in namen.

  • Uitzondering: algemeen aanvaarde afkortingen zoals ID, HTML,...

  • Afkortingen van één of twee letters

• Andere talen hebben soms andere conventies!

codeerstijl

We baseren ons op de afspraken van Microsoft. Je hoeft deze conventies niet te lezen. Hieronder volgt een vereenvoudigd overzicht van de afspraken die aan bod kunnen komen in de cursus en enkele eigen conventies:

using directieven

• Deze komen alleen vooraan in het bestand voor en worden steeds gevolgd door de declaratie van de namespace.

namespaces

• In het eerste semester groeperen we al onze code in de namespace Programmeren, in het tweede semester in de namespace ObjectgerichtProgrammeren.

een datatype per bestand

• Elk zelf gedefinieerd datatype (klasse, struct, interface, enum type, later ook delegate) plaatsen we in een afzonderlijk bestand met dezelfde naam als dat datatype.

strings bouwen

• In de eerste twee lessen mag dit met behulp van +.

• Gebruik stringinterpolatie om kleine aantallen strings aan elkaar te hangen of data weer te geven in stringformaat.

• Gebruik een StringBuilder om strings aan elkaar te hangen in een lus.

types declareren

• Gebruik steeds een expliciet, statisch type.

  • Dat wil zeggen: geen variabelen declareren als var. Dat doe je pas later.

  • Dat wil zeggen: geen variabelen declareren als dynamic. Dat doe je pas later.

arrays

• Gebruik de kortste syntax voor arrays van literals, dus string[] vowels1 = { "a", "e", "i", "o", "u" }; en niet string[] vowels2 = new string[] { "a", "e", "i", "o", "u" };.

static members

• Plaats voor een static member altijd uitdrukkelijk de naam van de klasse waarin dat static member gedefinieerd is.

• Klassen die uitsluitend static members bevatten ("library classes") maken we ook static met de syntax static class.

vergrendelen van data

• Klassen die niet bedoeld zijn om van over te erven maken we final.

• Als iets een constante is voor een bepaald programme, gebruiken we ook de access modifier const.

algemeen

We gebruiken alleen zaken die in de les aan bod zijn gekomen. We zien geen lambda's, delegates, LINQ,... dus je gebruikt deze ook niet, zelfs als je ze al ergens anders gezien hebt.

Nuttige extra's

Boeken

Er zijn quasi oneindig veel boeken over C# geschreven, althans zo lijkt het. Hier een selectie van boeken met een korte bespreking waarom ik denk dat ze voor jou een meerwaarde kunnen zijn bij het leren programmeren in C#:

Beginner boeken

• C# Programming van Mike McGrath: een uiterst compact, maar zeer helder en kleurrijk boekje dat ik ten stelligste aanbeveel als je wat last hebt met de materie van de eerste weken.

• Microsoft Visual C# 2015: An introduction to OOP van Joyce Farrell: Niet het meest sexy boek, maar wel het meest volledige qua overlap met de leerstof van deze cursus. Aanrader voor zij die wat meer in detail willen gaan en op zoek zijn naar oneindig veel potentiele examenvragen ;)

• Head First C# van Andrew Stellman & Jennifer Greene: laat de ietwat bizarre, bijna kleuterachtige look and feel van de head first boeken je niet afschrikken. Ieder boek in deze serie is goud waar. De head first boeken zijn d� ideale manier als je zoekt naar een alternatieve manier om complexe materie te begrijpen. Bekijk zeker ook de Head First Design Patterns en Head First Sql boeken in de reeks!

Geavanceerd

• C# Unleashed van Bart De Smet: in mijn opinie dé referentie om C# tot op het bot te begrijpen. Geschreven door een Belg die bij Microsoft in Redmond aan C# werkt.

• Code Complete van Steve McConnell: een referentiewerk over 'programmeren in het algemeen'. Het boek is al jaar en dag het te lezen boek als je je als programmeur wilt verdiepen in wat nu 'correct programmeren' behelst. Als je op je CV kunt zetten dat je dit boek door en door kent dan zal elk IT-bedrijf je stante pede aannemen ;)

Online

Leren programmeren door enkele de opdrachten in deze cursus te maken zal je niet ver (genoeg) brengen. Onze dikke vriend het Internet heeft echter tal van schitterende bronnen. Hier een overzicht.

Cheat sheet

Volgende document bevat een overzicht van de basis C# syntax zaken van het eerste en (deel van het) tweede semester: download hier

Game-based programmeren

Ideale manier om programmeren meer in de vingers te krijgen op een speelse manier:

Apps

• SoloLearn: Verplichte app! Simple as that!

• Enki Net zoals SoloLearn maar dan anders.

• Memrise (aanrader!) Origineel vooral bedoeld om spreektalen te leren, maar bevat ook tal van andere zaken. Hoofdzakelijk nuttig om nieuwe aspecten te 'drillen'. Enkel dus nuttig indien je de basismaterie eerst hebt verwerkt. Bekijk zeker ook de tal van andere cursussen die er staan. Let er op dat je bij de filter Engels instelt, er zijn nog niet veel (goede) Nederlandstalige C# cursussen naar mijn weten. Opgelet: je kan je enkel via de browser inschrijven op niet-spreektaal-cursussen. De app toont enkel spreektaalcursussen.

• Mimo Speels en vrij beperkt in gratis versie, maar ideale aanvulling op SoloLearn.

• Screeps Een steam spel om te leren programmeren. Weliswaar Javascript (nuttig voor Web Programming) maar het concept is te cool om niet hier te vermelden en zoals je zal ontdekken: leren programmeren kan je in eender welke taal, en het zal ook je andere programmeer-ervaring verbeteren. Give it a go!

Websites

• Exercism

• Coding game

• Code Combat

• Pex For Fun (specifiek voor C#!)

• Code Academy

• RPG Game in C# (behandelt leerstof van volledig eerste jaar en meer)

• Advent of code Pittige programmeeroefeningen die jaarlijks in december verschijnen.

• Free Programming Book Handig vorm gegeven gratis ebooks met tal van onderwerpen waaronder ook C# en het .NET Framework.

• Tutorials teacher: De uitgebreidere, Engelstalige variant van deze cursus zeg maar.

Tutorials

• Dotnet beginning

• C# Getting started interactive quickstart tutorials: Aanrader.

• Online video c# cursus: Zeer aan te raden indien je een bepaald concept uit de les niet begrijpt.

• C-sharp.be : Nederlandstalige cursus met veel toffe oefeningen waarvan je sommige zelfs in deze cursus zal terugvinden.

• Microsoft Virtual Academy: Microsoft heeft een virtual academy cursus "C# fundamentals" uitgebracht. Ik kan deze cursus zeer erg aanbevelen.

• Rob Miles's The C# Programming Yellow book: Zeer vermakelijk, vlot geschreven C# boek(je)

• Open Source Game Clones: "This site tries to gather open-source remakes of great old games in one place." Je vindt er ook tal van C# projecten terug zoals GTA 2.Klik bovenaan op "languages" en filter maar eens op C#.

Oefenvragen

• Een lijst met oude oefenvragen uit 2010: nog steeds relevant.

• Veel kleine, fijne oefeningen

• Een dagelijkse programmeeruitdaging op reddit

• Pittige vragen van de jaarlijkse Vlaamse Programmeerwedstrijd:

  • 2013

  • 2014

  • 2015

Streaming programmeurs

Ja hoor, ze bestaan. Meer en meer professionele én beginnende programmeurs streamen terwijl te programmeren. Dit is een ideale manier om te zien hoe andere mensen problemen aanpakken. De meeste programming streamers kan je terugvinden op youtube, maar ook op Twitch zijn er steeds meer. Enkele aanraders (bekijk zeker de filmpjes uit de archieven eens):

• Handmade Hero: deze programmeur heeft een volledige RPG gemaakt en het hele proces gestreamd.

• CSharpFrits

• DevChatter

• Visual Studio Twitch

• NoopKat

• The Coding train

Voor de graduaatsopleiding hanteren we een vaste structuur voor de oefeningen.

vorm van de oefeningen

unieke titel

Elke oefening begint met een unieke titel. Deze gebruik je voor de organisatie van je bestanden.

korte toelichting

Eerst krijg je een omschrijving in tekst van wat de algemene bedoeling is van je programma. Deze bevat niet noodzakelijk elk detail, maar geeft je een big picture. Bijvoorbeeld:

In deze oefening maak je een echo. Dit is een programma dat tekst inleest vanaf het toetsenbord en deze tekst dan op het scherm toont.

vertrekpunt

Je hoeft niet altijd alle code zelf te schrijven. Code die je nog niet verondersteld wordt zelf te kunnen schrijven, of code die gewoon veel tijd in beslag neemt, krijg je. Bij de stukken code staat telkens de naam van het bestand waarin ze thuishoort. Commentaar bij de te wijzigen stukken code geeft aan welke aanpassingen je moet doen. Bijvoorbeeld:

Program.cs

using System;

namespace Programmeren {
    class Program {
        public static void Main(string[] args) {
            // zorg er zelf voor dat een regel tekst die gebruiker intypt weer verschijnt
            string message;
            Console.WriteLine(message);
        }
    }
}

voorbeeldinteractie

Ten slotte worden één of meerdere voorbeelden getoond van hoe je programma zich gedraagt. In deze voorbeelden stellen regels die niet beginnen met > iets voor dat op het scherm verschijnt. Regels die wel beginnen met > stellen iets voor dat door de gebruiker zelf wordt ingetypt. Bijvoorbeeld, voor het programma dat we hier als leidraad gebruiken:

> Hallo, wereld!
Hallo, wereld!

We gebruiken de speciale syntax <EOF> om aan te geven dat er een end-of-file signaal wordt gestuurd.

Een essentieel onderdeel van C# is kennis van datatypes. Een datatype is, zoals de naam het zegt, een soort waartoe bepaalde gegevens kunnen behoren. 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? Een variabele met een bepaald datatype kan een bepaald soort data bewaren en dit zal afhankelijk hiervan een bepaalde hoeveelheid computergeheugen vereisen.

Er zijn tal basistypes in C# gedeclareerd (zogenaamde built-in 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

result = Console.ReadLine();

Basistypen voor getallen

C# heeft een hoop datatypes gedefinieerd om te werken met getallen zoals wij ze kennen, gehele en kommagetallen. Intern zullen deze getallen steeds binair bewaard worden, maar dat merken we zelden tijdens het programmeren.

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

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:

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 heeft dezelfde kenmerken als ushort, maar dient voor iets anders. ushort gebruik je echt om getallen binnen dat bereik voor te stellen. char bewaart karakters, d.w.z. symbolen zoals letters. Een beetje vereenvoudigd kan je stellen dat er een tabel is waarin elk symbool gekoppeld is aan een getal, zodat een reeks nulletjes en eentjes ook een letter kan voorstellen.

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 zeer grote precisie (veel cijfers na de komma) nodig, dan ga je voor een decimal. Wil je vooral erg grote of erg kleine getallen (met meer kans op afrondingen), dan kies je voor double.

Boolean datatype

Het bool (boolean) is het eenvoudigste datatype van C#. Het kan maar 2 mogelijke waarden bevatten: true of false. 1 of 0 met andere woorden. In het Nederlands meestal uitgedrukt als "waar" en "niet waar".

We zullen het bool datatype erg veel nodig hebben wanneer we met beslissingen zullen werken, specifiek de if statements die afhankelijk van de uitslag van een bool bepaalde code wel of niet zullen doen uitvoeren.

Tekst/String datatype

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

• Tekst kan bewaard worden in het string datatype

  • Letterlijke tekst schrijf je tussen dubbele quotes, bijvoorbeeld "Hallo Wereld!"

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

  • Letterlijke karakter schrijf je tussen enkele quotes, bijvoorbeeld 'à'

Meer info vind je later in dit hoofdstuk.

Deze cursus is een fork van . We zijn Tim Dams en al zijn co-auteurs dank verschuldigd voor de stevige basis. Je mag veronderstellen dat alles Tims werk is, wij hebben vooral de vorm van de oefeningen aangepast voor een meer beroepsgerichte opleiding.

Deze cursus wordt gebruikt als handboek binnen de opleiding .

Indien bepaalde hoofdstukken of onderdelen niet duidelijk zijn of je hebt suggesties ter verbetering/aanvulling, aarzel dan niet om ons te contacteren.

Veel leer- en leesplezier...

Variabelen

In het vorige hoofdstuk zagen we dat er verschillende datatypes bestaan. Deze types hebben we nodig om variabelen aan te maken. Een variabele is een koppeling van een naam aan gegevens. In C# heeft elke variabele ook een type.

Een variabele wordt bijgehouden in het geheugen van je machine, maar in een programmeertaal als C# vragen we ons niet af waar in het geheugen. In plaats daarvan gebruiken we de naam van de variabele, de zogenaamde identifier, om de gekoppelde gegevens op te vragen.

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. Hiervoor dien je 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#).

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. Dit noemen we de initialisatie van de variabele.

int mijnLeeftijd = 37;

Eens een variabele is geïnitaliseerd, kunnen we deze (op de meeste plaatsen) gebruiken alsof we de gekoppelde waarde rechtstreeks gebruikten.

Waarden toekennen aan variabelen

Een initialisatie is een speciaal geval van een toekenning. Een toekenning houdt in dat je de waarde die bij een bepaalde naam hoort instelt. In C# mag dit ook indien de variabele al een waarde heeft.

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

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

int eenAndereLeeftijd = mijnLeeftijd;

Literal toewijzen

Literals (of "letterlijke waarden") zijn expliciet uitgeschreven 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 stel je voor met 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 bepaalt 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).

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.

Kleuren in console

Je kan in console-applicaties zelf bepalen in welke kleur nieuwe tekst op het scherm verschijnt. Je kan zowel de kleur van het lettertype instellen (via ForegroundColor) als de achtergrondkleur (BackgroundColor).

Je kan met de volgende expressies de console-kleur veranderen, bijvoorbeeld de achtergrond in blauw en de letters in groen:

Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.Green;

Vanaf dan zal alle tekst die je na deze 2 expressies via WriteLine naar het scherm stuurt met deze kleuren werken.

Een voorbeeld:

Console.WriteLine("Tekst in de standaard kleur");
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Deze tekst komt in het groen met blauwe achtergrond");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("En deze in het rood met blauwe achtergrond");

Als je deze code uitvoert krijg je als resultaat:

Kleur resetten

Soms wil je terug de originele applicatie-kleuren hebben. Je zou manueel dit kunnen instellen, maar wat als de gebruiker slecht ziend is en in z'n besturingssysteem andere kleuren als standaard heeft ingesteld?!

De veiligste manier is daarom de kleuren te resetten door de Console.ResetColor() methode aan te roepen zoals volgend voorbeeld toont:

Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error!!!! Contacteer de helpdesk");
Console.ResetColor();
Console.WriteLine("Het programma sluit nu af");

Mogelijke kleuren

Alle kleuren die beschikbaar zijn zijn beschreven in ConsoleColor deze zijn:

• ConsoleColor.Black

• ConsoleColor.DarkBlue

• ConsoleColor.DarkGreen

• ConsoleColor.DarkCyan

• ConsoleColor.DarkRed

• ConsoleColor.DarkMagenta

• ConsoleColor.DarkYellow

• ConsoleColor.Gray

• ConsoleColor.DarkGray

• ConsoleColor.Blue

• ConsoleColor.Green

• ConsoleColor.Cyan

• ConsoleColor.Red

• ConsoleColor.Magenta

• ConsoleColor.Yellow

Statements en de C# syntax

Om een uitvoerbaar C#-programma te maken moeten we bepaalde regels respecteren. We noemen deze regels de syntaxis of syntax van de taal.

Een C#-programma bestaat uit een opeenvolging van instructies ook wel statements genoemd. Met de uitzondering van blokken (ook blocks, afgebakend door { en }) eindigen deze steeds met een puntkomma (;)

De volgorde van de woorden is niet vrijblijvend en moet 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: Ieder C# statement dat geen block is, 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.

• Blocks: Een block begint met {, eindigt met } en bevat daartussen verdere statements (ook geneste blocks zijn toegelaten).

• Witruimtes: Spaties, tabs en newlines worden door de C# compiler genegeerd. Je kan ze dus gebruiken om de layout van je code 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. Commentaar zal door de compiler genegeerd worden.

Keywords

Er zijn binnen C# dan ook 80 woorden, zogenaamde reserved keywords die deel van de taal zelf uitmaken. 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:

Variabelen, identifiers en naamgeving

We hebben variabelen nodig om data een naam te geven, zodat we er later naar kunnen verwijzen. Wanneer we een statement schrijven dat bijvoorbeeld input van de gebruiker moet vragen, dan willen we die input ook bewaren. Zo kunnen we verderop in het programma iets met deze data doen. We doen hetzelfde in ons hoofd wanneer we bijvoorbeeld zeggen: "tel 3 en 4 op en vermenigvuldig dat resultaat met 5". In die zin is "dat resultaat" een manier om te verwijzen naar wat we eerder gedaan hebben. Met andere woorden, een variabele. Vervolgens zullen we de inhoud van die variabele vermenigvuldigen met 5.

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

• 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 .

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-regels: 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 houdt 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 ).

• 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.

• Pascal casing: Zoals camel casing, maar ook de eerste letter is een hoofdletter. Gebruik dit voor namespaces, klassen en voor methodes waarbij je public zet.

Commentaar

Soms wil je misschien extra opmerkingen 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 geen 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).

Blok commentaar

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

Via Console.WriteLine kan je iets op het scherm laten zien:

ReadLine: Input van de gebruiker verwerken

Met de console kan je met een handvol methoden reeds een aantal interessante dingen doen.

Zo kan je bijvoorbeeld input van de gebruiker inlezen en bewaren in een variabele als volgt:

Bespreking van deze code:

string result;

• Concreet zeggen we hiermee aan de compiler: maak in het geheugen een plekje vrij waar enkel data van het type string in mag bewaard worden;

• Noem deze geheugenplek result zodat we deze later makkelijk kunnen in en uitlezen.

result = Console.ReadLine();

• Vervolgens roepen we de ReadLine methode aan. Deze methode zal de invoer van de gebruiker uitlezen tot de gebruiker op enter drukt.

• Het resultaat van de ingevoerde tekst wordt bewaard in de variabele result (denk eraan dat de toekenning van rechts naar links gebeurt).

• Een stukje code van de vorm naam = waarde heet een toekenning. Dit is niet hetzelfde als een wiskundige gelijkheid. In een toekenning plaats je een waarde aan de rechterkant. Aan de linkerkant schrijf je een naam die je aan deze waarde geeft.

• Als we een naam voor de eerste keer in het programma koppelen aan een waarde, spreken we soms over een initialisatie. Dit is ook een soort toekenning.

Je programma zou nu moeten zijn:

Start nogmaals je programma. Je zal merken dat je programma nu een cursor toont en wacht op invoer. Je kan nu eender wat intypen en van zodra je op enter duwt gaat het programma verder (in dit geval stopt het programma hierna dus).

Input gebruiker verwerken en gebruiken

We kunnen nu invoer van de gebruiker, die we hebben bewaard in de variabele result gebruiken en tonen op het scherm.

Op de tweede lijn hier gebruiken we de variabele result (waar de invoer van de gebruiker in bewaard wordt) als parameter in de WriteLine-methode.

Met andere woorden: de WriteLine methode zal op het scherm tonen wat de gebruiker even daarvoor heeft ingevoerd.

Je volledige programma ziet er dus nu zo uit:

Test het programma en voer je naam in wanneer de cursor knippert.

Voorbeelduitvoer (lijn 3 is wat de gebruiker heeft ingetypt)

Aanhalingsteken of niet?

Wanneer je de inhoud van een variabele wil gebruiken in een methode zoals WriteLine() dan plaats je deze zonder aanhalingsteken! Bekijk zelf eens wat het verschil wordt wanneer je volgende lijn code Console.Write(result); vervangt door Console.Write("result");.

De uitvoer wordt dan:

Write en WriteLine

De WriteLine-methode zal steeds een line break (een 'enter' ) aan het einde van de lijn zetten zodat de cursor naar de volgende lijn springt.

De Write-methode zal geen enter aan het einde van de lijn toevoegen. Als je dus vervolgens iets toevoegt (met een volgende Write of WriteLine) dan zal dit aan dezelfde lijn toegevoegd worden.

Vervang daarom eens de laatste 3 lijnen code in je project door:

Voer je programma uit en test het resultaat. Je krijgt nu:

Wat is er verkeerd gelopen? Al je tekst van de laatste lijn plakt zo dicht bij elkaar? Inderdaad, we zijn spaties vergeten toe te voegen! Spaties zijn ook tekens die op scherm moeten komen (ook al zien we ze niet) en je dient dus binnen de aanhalingstekens spaties toe te voegen. Namelijk:

Je uitvoer wordt nu:

Opletten met spaties

Spaties zijn ook tekens die op scherm moeten komen (ook al zien we ze niet) en je dient dus binnen de aanhalingstekens spaties toe te voegen. Indien je deze erbuiten plaats dan heeft dit geen effect (je wist al uit het eerste hoofdstuk dat C# alle witregels negeert die niet tussen aanhalingstekens staan). In volgend voorbeeld zijn de spaties aangegeven als liggende streepjes ( _ ).

Fout (de code zal werken maar je spaties worden genegeerd):

Correct:

Zinnen aan elkaar plakken

We kunnen dit hele verhaal een pak korter tonen. De plus-operator (+) in C# kan je namelijk gebruiken om variabelen van het type string aan elkaar te plakken. De laatste 3 lijnen code kunnen korter geschreven worden als volgt:

Merk op dat result dus NIET tussen aanhalingstekens staat, in tegenstelling de andere stukken zin. Waarom is dit? Aanhalingstekens in C# duiden aan dat een stuk tekst moet beschouwd worden als tekst van het type string. Als je geen aanhalingsteken gebruikt dan zal C# de tekst beschouwen als een variabele met die naam.

Bekijk zelf eens wat het verschil wanneer je volgende lijn code vervangt door de lijn er onder:

Meer input vragen

Als je meerdere inputs van de gebruiker tegelijkertijd wenst te bewaren dan zal je meerdere geheugenplekken nodig hebben om de invoer te bewaren. Bijvoorbeeld:

Je mag echter ook de geheugenplekken al vroeger maken. In C# zet men de geheugenplek creatie zo dicht mogelijk bij de code waar je die plek gebruikt (zoals vorig voorbeeld), maar dat is geen verplichting. Dit mag dus ook:

Strings samenvoegen

Je kan strings en variabelen samenvoegen tot een nieuwe string op verschillende manieren. We bekijken volgende twee mogelijkheden:

• +-operator

• $ string interpolation

In dit hoofdstuk

We gaan van volgende informatie uit:

• Stel dat je 2 variabelen hebt int age=13 en string name="Finkelstein".

• We willen de inhoud van deze variabelen samenvoegen in een nieuwe string result die zal bestaan uit de tekst:

  Ik ben Finkelstein en ik ben 13 jaar oud.

Volgende 2 manieren tonen hoe je steeds tot voorgaande string zal komen.

Manier 1: String samenvoegen met de +-operator

Als je de + tussen strings plaatst, krijgt deze operator een andere betekenis dan tussen getallen. De strings worden dan achter elkaar geplakt. Als iets geen string is en op deze manier wordt gebruikt, wordt eerst een tekstvoorstelling bepaald, zoals hieronder bij age (want dat is een int).

string result = "Ik ben " + name + " en ik ben " + age + " jaar oud.";

Op het eerste zicht is dit een eenvoudige manier om strings op te bouwen, maar ze heeft een paar belangrijke nadelen:

• je moet vaak afwisselen tussen aanhalingstekens en plustekens

• het is lastig spaties en leestekens juist te noteren op deze manier (merk op dat de stukken tekst in het voorbeeld spaties op de zijkanten bevatten)

• er komt vrij veel extra werk bij kijken als je data in een specifiek formaat wil weergeven, bijvoorbeeld met een specifiek aantal cijfers na de komma

• als je grote, complexe strings op deze manier opbouwt, kost het erg veel rekentijd

Manier 2: String interpolation met $

Via stringinterpolatie schrijf je je string min of meer zoals hij er uiteindelijk moet uitzien, maar vervang je de niet-letterlijke delen door geformatteerde waarden. Dit levert een goed leesbaar resultaat.

Door het $-teken VOOR de string te plaatsen geef je aan dat alle delen in de string die tussen accolades staan als code mogen beschouwd worden. Een voorbeeld maakt dit duidelijk:

string result = $"Ik ben {name} en ik ben {age} jaar oud.";

In dit geval zal dus de inhoud van de variabele name tussen de string op de plek waar nu {name} staat geplaatst worden. Idem voor age. Dit mag, zelfs al is age geen string: hetgeen tussen de accolades staat, wordt altijd intern omgezet naar een string voor het in het resultaat wordt geplaatst.

Expressies en operators

Een bewerking die een waarde kan opleveren is een expressie. Anders gezegd: een expressie in C# is iets dat je kan toekennen aan een variabele. Bijvoorbeeld 3+2, Console.ReadLine(), of 7. Als je kan zeggen dat een bewerking een duidelijk resultaat heeft, is het waarschijnlijk een expressie.

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:

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:

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

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

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, delen: * (vermenigvuldigen), / (delen)

3. Optellen en aftrekken: + 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:

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

Automatische berekening van datatypes

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.

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:

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:

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 meest algemene datatype kiezen. In dit geval een double. Volgende code zal dus werken:

Volgende niet:

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:

En nu krijgen we wel 4.5.

En complexer?

Het kan subtiel 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:

Hoeveel krijg je van me? 0.0 euro!

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 . 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:

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.

Nu we de elementaire zaken van C# en Visual Studio kennen is het tijd om onze programma's wat interessanter te maken. De ontwikkelde programma's tot nog toe waren steevast lineair van opbouw, ze werden lijn per lijn uitgevoerd zonder de mogelijkheid om de flow van het programma aan te passen. Het programma doorliep de lijnen braaf na elkaar en wanneer deze aan het einde kwam sloot het programma zich af.

Onze programma's waren met andere woorden niet meer dan een eenvoudige oplijstingen van opdrachten. Je kan het vergelijken met een lijst die je vertelt over hoe je een brood moet kopen:

1. Neem geld uit spaarpot

2. Wandel naar de bakker om de hoek

3. Vraag om een brood

4. Krijg het brood

5. Betaal het geld aan de bakker

6. Keer huiswaarts

7. Smullen maar

Alhoewel dit algoritme redelijk duidelijk en goed zal werken, zal de realiteit echter zelden zo rechtlijnig zijn. Een beter algoritme (dat foutgevoeliger is én interactiever voor de eindgebruiker) zal afhankelijk van de omstandigheden (bakker gesloten, geen geld meer, etc.) mogelijke andere stappen ondernemen. Het programma zal beslissingen nemen op basis van aanwezige informatie.

In een typisch project, bijvoorbeeld een bestelsysteem, kunnen we beslissingen gebruiken voor tal van zaken:

• als we de voorraad van producten gaan bijhouden en we willen reageren wanneer de voorraad op is

• als we op bepaalde dagen van de week kortingen op bepaalde producten willen geven in plaats van de gebruiker deze zelf te laten kiezen

• als we spaarpunten willen introduceren en de gebruiker deze kan inwisselen

Al deze oefeningen maak je in een klasse Beslissingen

Oefening: H4-Schoenenverkoper

Leerdoelen

• flowchart omzetten naar conditionele code

• Eenvoudige conditie

• Uitbreiding: samengestelde booleaanse expressie

Functionele analyse

Basis: Maak een programma dat aan de gebruiker vraagt hoeveel paar schoenen hij/zij wenst te kopen. Ieder paar schoenen kost normaal 50 euro. Indien de gebruiker 2 paar of meer koopt, is er 10% korting. Toon aan de gebruiker de totale prijs.

Uitbreiding: Breid in een tweede stap je programma uit zodat de korting enkel geldt als de gebruiker een klantenkaart heeft.

Technische analyse

Maak een methode met de naam SchoenenVerkoper. Maak gebruik van een if. Zet volgende flowchart om in code. Een Real in Flowgorithm stemt overeen met een double in C#.

Basis:

Uitbreiding:

Voorbeeldinteractie(s)

Basis:

Uitbreiding:

Oefening: H4-EvenOneven

Leerdoelen

• flowchart omzetten naar conditionele code

• tweevoudige conditie

• gebruik modulo

Functionele analyse

Maak een programma dat aan de gebruiker een geheel getal vraagt. Het programma geeft terug of het ingegeven getal even of oneven is.

Technische analyse

Maak een methode met de naam EvenOneven.

Een getal is even als de rest van de deling door 2 nul is. Hiervoor kan je de modulo operator gebruiken. Het teken voor de modulo is het % -teken. Voorbeelden: 7%2 geeft 1 => 7 is oneven 8%2 geeft 0 => 8 is even

Zet volgende flowchart om in code:

Voorbeeldinteractie(s)

Oefening: H4-PositiefNegatiefNul

Leerdoelen

• flowchart omzetten naar conditionele code

• meervoudige conditie

Functionele analyse

Maak een programma dat aan de gebruiker een geheel getal vraagt. Het programma geeft terug of het ingegeven getal positief, negatief of 0 is.

Technische analyse

Maak een methode met de naam PositiefNegatiefNul.

Maak gebruik van een if – else if - else.

Zet volgende flowchart om in code:

Voorbeeldinteractie(s)

Oefening: H4-BMIBerekenaar

Leerdoelen

• meervoudige conditie

• gebruik van else if

Functionele analyse

Maak een programma om de BMI van de gebruiker te berekenen. (Meer info over BMI) De BMI wordt berekend aan de hand van de lengte en het gewicht van de persoon.

De formule is: BMI = gewicht / lengte².

Je toont niet enkel de BMI maar ook een beoordeling over de BMI:

- BMI lager dan 18,5 => ondergewicht

- BMI vanaf 18,5 maar lager dan 25 => normaal gewicht

- BMI vanaf 25 maar lager dan 30 => overgewicht

- BMI vanaf 30 maar lager dan 40 => zwaarlijvig

- BMI hoger dan 40 => ernstige obesitas

Technische analyse

Maak een methode met de naam BMIBerekenaar.

Maak gebruik van een if – else if – else if …

Voorbeeldinteractie

Oefening: H4-GrootsteVanDrie

Leerdoelen

• meervoudige conditie

• samengestelde booleaanse expressie

• gebruik van else if

Functionele analyse

Maak een programma om van 3 ingegeven getallen, het grootste te bepalen.

Technische analyse

Maak een methode met de naam GrootsteVanDrie.

Maak gebruik van een if – else if - else

Voorbeeldinteractie

Oefening: H4-Examens

Leerdoelen

• conditie

• samengestelde booleaanse expressie

Functionele analyse

Maak een programma waarmee je aan de gebruiker het resultaat van 3 examens opvraagt. De opgevraagde resultaten zijn de behaalde punten op 100. Om te slagen moet de student een gemiddelde van meer dan 50% hebben én maximaal 1 onvoldoende.

Technische analyse

Maak een methode met de naam Examens.

Maak gebruik van een if – else.

Voorbeeldinteractie

Oefening: H4-Wet van Ohm

Leerdoelen

- conditionele berekeningen

Functionele analyse

De Wet van Ohm houdt in dat een elektrische stroom (voorgesteld als I) gelijk is aan een spanningsverschil (U) gedeeld door een weerstand (R), dus I = U / R.

Vraag aan de gebruiker wat hij wenst te berekenen: Spanning, Weerstand of Stroomsterkte. Vraag vervolgens de twee andere waarden. Als dus de gebruiker "Spanning" kiest, vraag je aan de gebruiker de waarden van de stroomsterkte en de weerstand. Bereken m.b.v. de Wet van Ohm de gewenste waarde en toon aan de gebruiker.

Technische analyse

Maak een nieuwe methode genaamd WetVanOhm.

Denk eraan dat de gegeven formule wiskundig gedefinieerd is. Houd rekening met het feit dat deze drie maten uitgedrukt kunnen worden in kommagetallen.

Voorbeeldinteractie(s)

Keuzemenu's maken

Leerdoelen:

- Conditionele functionaliteit

Functionele analyse:

We willen dat de gebruiker een menu ter beschikking heeft om eerst te kiezen uit welk hoofdstuk er een oefening moet gekozen worden en vervolgens welke oefening er moet uitgevoerd worden.

Technische analyse

Maak in je klasse Program een hoofdmenu. Deze methode laat de gebruiker kiezen uit één van de hoofdstukken. Na de keuze wordt het scherm leeggemaakt en dan wordt de methode Keuzemenu van de juiste klasse opgeroepen. Elke klasse die je tot hiertoe in dit project gemaakt hebt, voorzie je dus van een methode Keuzemenu, zodat de gebruiker kan kiezen uit de oefeningen (=methodes) binnen het gekozen hoofdstuk.

Voorbeeldinteractie

Input van de gebruiker verwerken

Conversie

Zoals eerder aangegeven, kan je geen strings toekennen aan variabelen van type int of omgekeerd. Toch wil je soms een getal beschouwen als tekst, of tekst omzetten naar een getal .NET heeft hiervoor methoden die je kunnen helpen om data van het ene type naar het andere te brengen. Deze methoden zitten binnen de Convert-klasse.

Het gebruik hiervan is zeer eenvoudig. Enkele voorbeelden:

Je plaatst bij gebruik van Convert tussen de ronde haakjes de variabele of literal die je wenst te converteren naar een ander type. Merk op dat naar een int converteren met .ToInt32() moet gebeuren. Voor andere types zijn er overeenkomstige methoden. Je kan . Volgende conversies zullen je al ver vooruit helpen:

Foutloze input

Voorgaande code veronderstelt dat de gebruiker géén fouten invoert. De conversie zal namelijk mislukken indien de gebruiker bijvoorbeeld IKWEEG10KG invoert in plaats van 10,3.

In het begin van de leercurve moet je er altijd van uitgaan dat de gebruiker foutloze input geeft. Later leer je wel hoe je dit kan afhandelen.

Relationele operators

Om beslissingen te kunnen nemen in C# moeten we kunnen nagaan of een bepaalde uitspraak waar of niet waar is. Anders gezegd: we moeten stukjes code kunnen schrijven waarvan we achteraf kunnen zeggen of ze "waar" of "niet waar" zijn. Zo'n stukjes code noemen we booleaanse expressies. De meest typische booleaanse expressies schrijf je met de relationele operatoren. Deze stellen vergelijkingen tussen stukjes data voor. Gelukkig ken je deze al uit het lager onderwijs en moet je alleen de notatie hieronder leren:

Deze operatoren leveren je altijd één van twee mogelijkheden als uitkomst: true of false. Je kan dit ook uittesten: Console.WriteLine(4 < 7); of Console.WriteLine(4 < 2); toont je het verwachte resultaat.

Er bestaan nog simpelere booleaanse expressies dan die met de relationele operatoren: true en false zelf zijn hun eigen resultaat en zijn dus technisch gesproken ook booleaanse expressies. Je mag dus bv. ook true schrijven in plaats van 4 > 2.

Met een editor, zoals Visual Studio, krijgen we ondersteuning bij het schrijven van de code die we later zullen uitvoeren. Een editor vergemakkelijkt dus het schrijven van een specifiek soort tekst.

De "SDK" (software development toolkit) bevat alles wat je nodig hebt om de code daadwerkelijk uitvoerbaar te maken.

Vooraleer je begint

1. Voor deze opdrachten gebruiken we .NET Core 6.0, maar we gebruiken de (explicietere) template van .NET Core 5.0. Je moet dus beide SDK's installeren.

2. Sommige afbeeldingen hieronder dateren van de tijd van .NET Core 2.0 en Visual Studio 2017. Soms kunnen zaken er op jouw scherm dus wat anders uitzien dan in deze cursus.

Installatie

Visual Studio 2022 Community

1. https://visualstudio.microsoft.com/downloads/

2. Kies voor de "community" versie

3. Het installatiescherm ziet er als volgt uit, in de volgende punten wordt beschreven welke elementen je specifiek moet aanduiden.

   • Kies bij de installatie voor .NET desktop development

   • Bij de installation details kies je voor volgende elementen

   • In het tabblad individual components klik je .NET 5.0 Runtime (out of support) nog extra aan.
4. Vervolgens kies je rechts onderaan voor de knop Install

5. Log in met jouw account van de hogeschool, nl. s-nummer@ap.be

Opmerking .NET 5.0 Runtime kan je ook afzonderlijk installeren via https://dotnet.microsoft.com/en-us/download/dotnet/5.0

Flowgorithm

Flowgorithm is een visuele programmeertaal. We zullen deze gebruiken om bepaalde concepten duidelijk zichtbaar te maken. Je moet de Windows Installer van deze pagina halen. Tijdens de installatie klik je gewoonweg elke keer op "Next".

Gebruikers van Mac OS installeren dit best via Wine of in een virtuele machine. Als dit echt niet lukt, kunnen ze tijdelijk FlowRun gebruiken, maar deze software werkt wat anders en ondersteunt geen arrays.

Een voorbeeld van hoe je begint te werken met Flowgorithm kan je hier bekijken. https://www.youtube.com/watch?v=7SuYTvYCqOw

Eerste gebruik Visual Studio

1. Kies voor Create New Project
2. Vervolgens selecteer je Console App
3. Je geeft je project een goede naam, hieronder dien je de Project name dan aan te passen en je zal zien dat de Solution name automatisch mee wordt gewijzigd. Denk er ook aan om je project op de juiste plaats op te slaan door de Location te wijzigen.
4. In de volgende stap dien je als Framework .NET 6.0 te kiezen en de optie "Do not use top-level statements" aan te vinken.

Nadat je je project hebt aangemaakt, rechterklik je op je project in de Solution Explorer -> Properties -> Build -> General en schakel je "Implicit global usings" uit.

Code Snippet

Hierbij ga je ervoor zorgen dat je met afkortingen kan coderen die dan automatisch in het goede formaat worden omgezet.

Bv. cr (gevolgd door twee TABs) wordt dan Console.ReadLine()

Je kan volgende code kopiëren in een tekstbestand met als extensie .snippet of je kan het hieronder downloaden.

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
 <CodeSnippet Format="1.0.0">
 <Header>
 <Title>cr</Title>
 <Shortcut>cr</Shortcut>
 <Description>Code snippet for Console.ReadLine</Description>
 <Author>Community</Author>
 <SnippetTypes>
 <SnippetType>Expansion</SnippetType>
 </SnippetTypes>
 </Header>
 <Snippet>
 <Declarations>
 <Literal Editable="false">
 <ID>SystemConsole</ID>
 <Function>SimpleTypeName(global::System.Console)</Function>
 </Literal>
 </Declarations>
 <Code Language="csharp">
 <![CDATA[$SystemConsole$.ReadLine();$end$]]>
 </Code>
 </Snippet>
 </CodeSnippet>
</CodeSnippets>

Vervolgens dien je binnen Visual Studio in het menu Tools naar Code Snippets Manager gaan.

Je kiest voor Language CSharp en klikt op de knop Import.

Je kiest het snippet bestand en voegt dit toe.

In dit deel zullen we bekijken hoe we ons programma dynamischer kunnen maken met behulp van het if-statement, al dan niet uitgebreid met else en else if.

If

De if is een van de elementairste constructies in een programmeertaal. Vrijwel elke programmeertaal bezit deze constructie. We zullen de werking ervan eerst wat algemener bekijken, zodat je het concept goed begrijpt. Daarna zullen we inzoomen op de syntax in C#.

Het basisidee is als volgt: een if-constructie bevat code die enkel uitvoert als een booleaanse expressie true oplevert. Met andere woorden: als een voorwaarde naar keuze waar is. We noemen dergelijke code conditionele code, want een conditie is een voorwaarde.

We zullen dit tonen met een Flowgorithm programma. Dit is een beperkte, maar heel visuele programmeertaal. In een Flowgorithm programma start je bij Main en volg je steeds de pijlen.

De gele box stelt een declaratie voor. Ook in Flowgorithm moet je variabelen declareren. Het blauw parallellogram: de gebruiker geeft iets in (de waarde van wachtwoord). De rode ruit bevat een booleaanse expressie. Dan is er een vertakking, met daarop de waarden True en False. We volgen de pijl met daarop de uitkomst van de booleaanse expressie. Als we dus het juiste wachtwoord intypen, krijgen we de geheime info, anders gebeurt er niets.

Het if-statement stemt overeen met alles tussen de rode ruit en het rode bolletje. Dus als aan een bepaalde voorwaarde voldaan is, voeren we afgebakende code uit.

Uit dit programma kan je dan ook volgende C#-code afleiden:

In de gegenereerde code stemt de rode ruit dus overeen met de haakjes meteen na if en stemt de tak True overeen met de accolades.

Veelgemaakte if-fouten

Er zijn enkele veelgemaakte fouten waar je op moet letten:

Appelen en peren vergelijken

De types in je booleanse expressie moeten steeds vergelijkbaar zijn. Volgende code is dus fout: if( "4" > 3) daar we hier een string met een int vergelijken.

Accolades vergeten

Als je geen accolades schrijft, verandert de werking van if. Het gevolg zal zijn dat enkel het eerste statement na de if zal uitgevoerd worden indien true. Gebruiken we de if van daarnet maar zonder accolades dan zal het tweede statement altijd uitgevoerd worden ongeacht de if:

If/else

Het eerdere voorbeeld toont dat we soms actie willen ondernemen als aan een voorwaarde voldaan is, maar heel vaak willen we een andere actie ondernemen als aan diezelfde voorwaarde niet voldaan is. In dat geval maken we gebruik van de if ... else ....

We gaan terug naar onze login. Een fout wachtwoord ingeven heeft bepaalde gevolgen. Dit kan bijvoorbeeld een alarm doen afgaan, omdat indringers soms foute wachtwoorden ingeven tot ze toevallig het juiste vinden. We stellen dit hier voor door een actie toe te voegen als het wachtwoord niet klopt.

De overeenkomstige C# code:

In bovenstaande code stemt de rode ruit dus nog steeds overeen met de haakjes meteen na if, stemt de tak True overeen met de accolades vlak na de ronde haakjes en stemt else { ... } overeen met de tak False. Anders gezegd: als aan een bepaalde voorwaarde voldaan is, voeren we het eerste blok afgebakende code uit, anders voeren we het tweede blok afgebakende code uit.

Code voor beide gevallen

Als we iets altijd willen doen, hoort dat niet in een vertakking. Dan zetten we het in de flowchart na het rode bolletje. In ons programma zetten we het dan na de volledige if ... else ...:

De gegenereerde code is dan:

Nesting

Het is perfect mogelijk om bepaalde controles enkel te doen als eerdere controles wel of niet gelukt zijn. Dit kan er zo uitzien:

In de gegenereerde code leidt dit tot geneste conditionele code: een if binnenin een grotere if of else. In digt geval gaat het om een if in een else. Je mag zo diep nesten als je maar wil. Er is geen technische limiet, maar je code zal wel onleesbaar worden als je overdrijft.

else if

Nesten van conditionele code levert soms code op die moeilijk te ontrafelen is. Het gebeurt vaak dat we een else nodig hebben met meteen daarin terug een if, om zo verschillende gevallen af te handelen.

We kunnen een programma maken dat dit demonstreert: Er is niet aan de hoofdvoorwaarde voldaan, maar er is wel aan een andere voorwaarde voldaan:

De gegenereerde code voor dit frament is technisch juist:

Maar Flowgorithm is geen menselijke programmeur. Een menselijke programmeur zou volgende voorstelling gebruiken, die hetzelfde doet, maar makkelijker leesbaar is:

While

Voorbeeld werking

Volgend Flowgorithm programma demonstreert hoe een while lus wordt toegepast wanneer je systematisch boodschappen afwerkt.

Omdat de True-tak terug leidt naar de controle van de voorwaarde, blijven we dezelfde stappen herhalen tot niet meer aan de voorwaarde voldaan is. Dit is het basisconcept achter een while lus. Het woord "while" betekent dan ook "zolang als".

Dit is anders dan bij if: het woordje "if" betekent gewoonweg "als" en houdt dus niet in dat we dezelfde stappen zullen herhalen. Bij while blijven we dezelfde stappen uitvoeren zo lang dat nodig is.

Syntax

De syntax van een while loop is eenvoudig:

while (booleaanse expressie) 
{
  // C# die zal uitgevoegd worden zolang de booleaanse expressie waar is
}

Waarbij, net als bij een if statement, de conditie uitgedrukt wordt als een booleaanse expressie.

Zolang de conditie true is zal de code binnen de accolades uitgevoerd worden. Indien dus de conditie reeds vanaf het begin false is dan zal de code binnen de while-loop niet worden uitgevoerd.

Telkens wanneer het programma aan het einde van het while codeblock komt springt het terug naar de conditie bovenaan en zal de test wederom uitvoeren. Is deze weer true dan wordt de code weer uitgevoerd. Van zodra de test false is zal de code voorbij het codeblock springen en na het while codeblok doorgaan.

De code voor ons boodschappenlijstje ziet er dan ook zo uit:

Een tweede voorbeeld van een eenvoudige while loop:

int myCount = 0;

while (myCount < 100)
{
    myCount++;
    Console.WriteLine(myCount);
}

Zolang myCount kleiner is dan 100 (myCount < 100) zal myCount met 1 verhoogd worden en zal de huidige waarde van myCount getoond worden. We krijgen met dit programma dus alle getallen van 1 tot en met 100 op het scherm onder elkaar te zien.

Daar de test gebeurt aan het begin van de loop wil dit zeggen dat het getal 100 nog wel getoond zal worden. Begrijp je waarom? Test dit zelf!

Do while

In tegenstelling tot een while loop, zal een do-while loop sowieso minstens 1 keer uitgevoerd worden.

Voorbeelden werking

Volgende flowchart helpt je bepalen of je klaar bent om een commit operatie uit te voeren in Git. Zoals je in andere vakken leert, moet je in Git eerst de gewenste bestanden in de staging area zetten. Dat kan soms in één commando gebeuren en soms in meerdere commando's, maar je moet altijd wel minstens één keer stagen.

Een tweede voorbeeld: een opstel schrijven. Dat moet je altijd nog eens nakijken. Als het niet goed is, moet je je tekst aanpassen en opnieuw controleren. Pas wanneer je helemaal tevreden bent, mag je inzenden.

De syntax van een do-while is eveneens verraderlijk eenvoudig:

do{
      // C# die uitgevoerd zal worden zolang de booleaanse expressie waar is
} while (booleaanse expressie);

Voor het opstel ziet dit er bijvoorbeeld zo uit:

Je kan dit ook doen met een gewone while (je kan elke do while herschrijven met een gewone while), maar dan kost dat meer code. Dat verhoogt dan weer de kans op fouten.

Complexe condities

Uiteraard mag de conditie waaraan een loop moet voldoen complexer zijn door middel van de relationele operatoren.

Volgende while bijvoorbeeld zal de gebruiker aanraden in bed te blijven zolang deze ziek of moe is:

while(gebruikerVoeltZichZiek || gebruikerVoeltZichMoe)
{
  Console.WriteLine("Blijf in bed!");
  Console.ReadLine();
}

Oneindige loops

Indien de loop-conditie nooit false wordt, dan heb je een oneindige loop gemaakt. Soms is dit gewenst gedrag (bijvoorbeeld in een programma dat constant je scherm moet updaten, zoals in een game), soms is dit een bug.

Volgende twee voorbeelden tonen dit:

• Een bewust oneindige loop:

  Copy

  while(true)
  {
    // code die nooit hoort te stoppen of die zelf het programma kan afsluiten
  }

• Een bug die een oneindige loop veroorzaakt:

  Copy

  int teller = 0; 
  while(teller<10)
  {
    Console.WriteLine(teller);
  }

Scope van variabelen in loops

Let er op dat de scope van variabelen bij loops zeer belangrijk is. Indien je een variabele binnen de loop definieert dan zal deze steeds terug "verdwijnen" wanneer de cyclus van de loop is afgewerkt. Latere declaraties voor variabelen met dezelfde naam hebben niets meer te maken met de oorspronkelijke variabele.

Volgende code toont bijvoorbeeld foutief hoe je de som van de eerste 10 getallen (1+2+3+...+10) zou maken:

int teller= 1;
while(teller <= 10)
{
   int som = 0;
   som = som+teller;
   teller++;
}
Console.WriteLine(som); //deze lijn zal fout genereren

De correcte manier om dit op te lossen is te beseffen dat de variabele som enkel binnen de accolades van de while-loop gekend is. Op de koop toe wordt deze steeds terug op 0 gezet en er kan dus geen som van alle teller-waarden bijgehouden worden:

int teller= 1;
int som=0;  
while(teller <= 10)
{
   som = som+teller;
   teller++
}
Console.WriteLine(som);

Scope is eerder al in het algemeen behandeld, maar zeker in loops worden er veel fouten tegen gemaakt. Daarom beklemtonen we het hier nog eens.

Als je aanpassingen wil voorstellen specifiek voor de graduaatsopleiding, dan wordt aangeraden een fork van deze repository te maken op Github. De verschillen tussen de cursus voor de graduaatsopleiding en de bachelor hebben bijna uitsluitend betrekking tot de oefeningen. Als je aanpassingen wil doen met betrekking tot de inhoud, zie dan .

Al deze oefeningen maak je in een klasse Loops

Oefeningen WHILE en DO WHILE

Oefening: H5-CountDown

Leerdoelen

• flowchart omzetten naar code

• gebruik van een while-lus