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.

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 de overeenkomstige pagina in de cursus van de bachelor.

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.

Deze cursus is een fork van die van de richting toegepaste informatica. 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.

Herhalingen (loops) creëer je wanneer bepaalde code een aantal keer moet herhaald worden. Hoe vaak de herhaling moet duren is afhankelijk van de conditie die je hebt bepaald. Deze conditie is een booleaanse expressie, net zoals de conditie van if.

In het vorige hoofdstuk leerden we hoe we met behulp van beslissingen onze code konden branchen, aftakken zodat andere code werd uitgevoerd afhankelijk van de staat van bepaalde variabelen of invoer van de gebruiker. Wat we nog niet konden was terug naar boven vertakken. Soms willen we dat een heel stuk code 2 of meerdere keren moet uitgevoerd worden zo lang als of totdat aan een bepaalde conditie wordt voldaan. "Voer volgende code uit tot dat de gebruiker een bepaalde waarde invoert." Dit zal bijna net hetzelfde werken als bij if, maar nadat je code is uitgevoerd, wordt de conditie (opnieuw) gecontroleerd om na te gaan of de code (opnieuw) moet worden uitgevoerd.

Door herhalende code met loops te schrijven maken we onze code korter en bijgevolg ook minder foutgevoelig en beter onderhoudbaar.

Soorten loops

Er zijn verschillende soorten loops:

• Definite of counted loop: een loop waar het aantal iteraties vooraf van gekend is. (Bijvoorbeeld 100 keer of een aantal keer gelijk aan de waarde van de variabele x).

• Indefinite of sentinel loop: een loop waarvan op voorhand niet kan gezegd worden hoe vaak deze zal uitgevoerd worden. Input van de gebruiker of een interne test zal bepalen wanneer de loop stopt (bv. "Voer getallen in, voer -1 in om te stoppen")

• Oneindige loop: een loop die nooit stopt. Soms gewenst, vaak een bug.

Loops in C#

Er zijn 3 manieren om zogenaamde loops te maken in C#:

• while: zal 0 of meerdere keren uitgevoerd worden

• do while: zal minimaal 1 keer uitgevoerd worden

• for: een alternatieve iets compactere manier om loops te beschrijven

Al deze oefeningen maak je in een klasse VariabelenEnDatatypes. In de oefeningen van hoofdstuk 1 heb je gezien hoe je een nieuwe klasse maakt.

Oefening: H2-optellen

Leerdoelen

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

• berekeningen met de opgeslagen data uitvoeren

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

Functionele analyse

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

Technische analyse

Noem de methode voor deze oefening Optellen.

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

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

3. De twee getallen worden opgeteld.

4. Het resultaat wordt weergegeven.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en sla dit op in een variabele voor wat het eerste getal betreft. Herhaal dit voor het tweede getal. Tel de twee getallen samen en bewaar deze in een derde variabele. Uiteindelijk geef je dan de inhoud van deze derde variabele weer in de console.

Let op: met Console.ReadLine() lees je tekst in, dus waarden die je kan toekennen aan variabelen van type string. Om een getal in te lezen, vervang je Console.ReadLine() door Convert.ToInt32(Console.ReadLine()). De werking hiervan zie je later.

Testscenario's

• Voer tekst in.

• Voer een getal met 100 cijfers in.

• Voer geen getal in.

Oefening: H2-verbruik-wagen

Leerdoelen

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

• berekeningen met de opgeslagen data uitvoeren

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

Functionele analyse

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

Hiervoor worden volgende vragen gesteld:

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

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

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

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

Technische analyse

Noem de methode voor deze oefening VerbruikWagen.

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

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

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

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

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

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

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

Nadien voer je de berekening uit om op basis van de ingevoerde gegevens het gemiddeld verbruik te berekenen (100 * (aantalLiterinTankVoorRit - aantalLiterinTankNaRit) / (kilometerstandNaRit - kilometerstandVoorRit))

Uiteindelijk geef je dan het resultaat weer in de console.

Testscenario's

• Voer tekst in.

• Voer een getal met 100 cijfers in.

• Voer geen getal in.

Oefening: H2-beetje-wiskunde

Leerdoelen

• expressies schrijven

• voorrang van operatoren

• effect van operaties naargelang datatype begrijpen

Functionele analyse

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

• -1 + 4 * 6

• ( 35+ 5 ) * 7

• 14 + -4 * 6 / 11

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

Technische analyse

Noem de methode voor deze oefening BeetjeWiskunde.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Eerst wordt een resultaat berekend, daarna wordt het geprint.

Testscenario's

• Test uit met getallen van het type int.

• Test uit met getallen van het type float.

Ondersteunend materiaal

Oefening: H2-gemiddelde

Leerdoelen

• expressies schrijven

• voorrang van operatoren

• effect van operaties naargelang datatype begrijpen

Functionele analyse

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

Technische analyse

Noem de methode voor deze oefening Gemiddelde.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Eerst wordt het resultaat berekend, daarna wordt het geprint.

Testscenario's

• Test uit met getallen van het type int.

• Test uit met getallen van het type float.

Oefening: H2-maaltafels

Leerdoelen

• de console leegmaken

• werken met wiskundige operatoren

• interactie met de gebruiker

Functionele analyse

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

Technische analyse

Noem de methode voor deze oefening Maaltafels. Je kent nog geen lusstructuren, dus probeer deze niet te gebruiken, zelfs als je ze al ergens anders bent tegengekomen. Schrijf gewoon tien instructies.

voorbeeldinteractie(s)

(enzovoort)

Technische hulp

Programmaverloop

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

Testscenario's

• Test uit zoals gegeven.

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

Oefening: H2-ruimte

Leerdoelen

• werken met kommagetallen

Functionele analyse

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

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

• Venus: 0.91

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

• Mars: 0.38

• Jupiter: 2.34

• Saturnus: 1.06

• Uranus: 0.92

• Neptunus: 1.19

• Pluto: 0.06

Technische analyse

Noem de methode voor deze oefening Ruimte.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

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

Testscenario's

• Test uit voor je eigen gewicht.

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

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

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

• 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 ;)

• 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

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

• 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

Game-based programmeren

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

Apps

Websites

Tutorials

Oefenvragen

• Pittige vragen van de jaarlijkse Vlaamse Programmeerwedstrijd:

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

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

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

Flowgorithm

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.

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.

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:

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

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.

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

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:

   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:

   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.

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.

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

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

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

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

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 'à'

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:

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

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

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:

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

Een voorbeeld:

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:

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

Structuur van je oefeningen

Om je oefeningen ordelijk bij te houden, gaan we al een aantal zaken gebruiken die je pas verder in de cursus in detail leert. Hieronder krijg je een korte inleiding.

Stap 1: een project LaboOefeningen maken

Volg hiervoor de instructies in het document op DigitAP.

Stap 2: een klasse maken EenProgrammaSchrijvenInCSharp

Dit is nieuw. Klassen zijn een extra organisatie-eenheid van code. Ze spelen een grote rol in objectgeoriënteerd programmeren, maar kunnen ook gebruikt worden om stukken code verder te groeperen. Dit is voorlopig het enige dat wij er mee zullen doen. Via "File" maak je een nieuw bestand aan. Je kiest ervoor een nieuwe C#-klasse te maken met de naam EenProgrammaSchrijvenInCSharp.

Stap 3: een eigen methode maken

Een definitie van een methode bevat één taak die kan worden uitgevoerd. Onze eerste oefenprogramma's zullen telkens één methode zijn. De werking van methodes wordt verder in de cursus in detail omschreven. Soms moet je eerst iets overnemen voor je de functie van elk onderdeeltje kan begrijpen!

Neem aandachtig volgende code over, zodat jouw bestand exact dit bevat:

Belangrijke onderdelen:

• using System; maakt onderdelen uit de System namespace toegankelijk. Zonder dit kan je geen gebruik maken van Console.

• namespace LaboOefeningen geeft aan dat alles wat binnen de buitenste accolades (de symbolen op regels 4 en 11) staat behoort tot die namespace. Het is de "achternaam" van jouw code. Als er bijvoorbeeld twee stukken code EenProgrammaSchrijvenInCSharp zijn, kan je ze uit elkaar houden door te zeggen over welke namespace het gaat. Dit is hetzelfde als twee personen die dezelfde voornaam hebben, maar een andere achternaam.

• public: hier komen we pas een stuk later op terug. Voorlopig zetten we het standaard bij klassen en methoden.

• class: zie dit voorlopig als een verdere onderverdeling van je code. Eigenlijk zijn klassen veel meer dan dat, maar dat is voor later.

• static: dit is sowieso nodig wanneer we klassen enkel zien als een verdere onderverdeling van je code. We zetten het bij onze methoden.

• void: voorlopig zetten we dit altijd bij onze methoden. Het betekent ongeveer: "deze methode voert een commando uit, eerder dan een antwoord te geven op een vraag".

• MijnEersteMethode: dit is de naam van onze methode. We kiezen deze zelf.

• (): dit betekent dat de methode geen extra informatie nodig heeft om uit te voeren. Soms zetten we ook zaken tussen deze haakjes, de zogenaamde "parameters". Dit komt later aan bod.

• Alles tussen de accolades op regel 7 en 9: de "body" van de methode. Dit is eigenlijk wat er gebeurt als we de methode gebruiken.

Stap 4: je eigen methode oproepen

Standaard voert de code in de klasse Program, in de methode Main uit. Dat is het beginpunt van ons programma. We kunnen de body van Main aanpassen. We zullen hierin aangeven dat onze eigen methode moet worden opgeroepen als volgt:

We noemen de code in de body een "oproep" van de methode MijnEersteMethode. Hierin staat niet hoe die methode werkt. Er staat alleen dat we ze willen gebruiken.

Stap 5: opkuisen

Je mag nu zowel de definitie als de oproep van MijnEersteMethode wissen. In de oefeningen die volgen, maak je telkens nieuwe methodes. Test ze telkens uit door de oproep te vervangen. Laat de definitie staan wanneer je overgaat naar de volgende oefening. Later zullen we een keuzemenu maken dat ons toestaat makkelijk een oefening naar keuze te demonstreren.

Oefening: H1-MijnEersteProgramma

Leerdoelen

• een eigen programma kunnen uitvoeren

• input en output via Console.ReadLine en Console.WriteLine

Functionele analyse

Binnen een zgn. dos-box wordt een titel weergegeven, nl. dit is mijn eerste c# programma. Vervolgens wordt gevraagd je naam te noteren. Wanneer je je naam hebt genoteerd en op enter hebt gedrukt, verschijnt de tekst “hallo [en je ingegeven naam]”.

Technische analyse

voorbeeldinteractie(s)

Technische hulp

maak een methode met de naam MijnEersteProgramma

Programmaverloop

Wat het lezen en schrijven van tekst betreft moet gebruik gemaakt worden Console.WriteLine en Console.ReadLine.

Testscenario's

• Probeer meer dan 200 tekens in te voeren

• Probeer geen tekst in te voeren

Oefening: H1-rommelzin

Leerdoelen

• een eigen programma kunnen uitvoeren

• input en output via Console.ReadLine en Console.WriteLine

• de computer leren zien als "domme verwerker"

Functionele analyse

Dit programma verwerkt tekst die door de gebruiker wordt ingetypt. Het print nieuwe berichten die deze tekst bevatten uit. Het print niet de berichten die je verwacht: het zal de antwoorden door elkaar halen en je favoriete kleur tonen wanneer het beweert je favoriete eten te tonen, enzovoort. De verbanden worden duidelijk uit de voorbeeldinteractie.

Technische analyse

Organisatie van de code

Schrijf dit programma als een methode met de naam Rommelzin binnen de klasse EenProgrammaSchrijvenInCSharp. Test uit door deze methode op te roepen binnen de Main methode.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Per regel die getoond wordt op het scherm, maak je gebruik van Console.WriteLine. Per regel die je zelf intypt, maak je gebruik van Console.ReadLine. Zorg zelf voor de juiste ondersteunende code.

Testscenario's

• Test uit met een héél lang stuk tekst (meer dan 200 tekens) voor je favoriete kleur.

• Test uit met tekst met internationale karakters, bijvoorbeeld de ç.

• Ga na wat er gebeurt als je een lege regel invoert, dus als je meteen op ENTER duwt wanneer gevraagd wordt om invoer.

Oefening: H1-gekleurde-rommelzin

Leerdoelen

• de kleur van tekst in de console aanpassen

• herhaling van de leerdoelen uit H1-rommelzin

Functionele analyse

Dit programma werkt net als H1-rommelzin, maar elke regel die aan de gebruiker wordt getoond, krijgt een andere kleur. De namen van de kleuren die je gebruikt (in deze volgorde) zijn:

1. DarkGreen

2. DarkRed

3. DarkYellow

4. Blue

5. Cyan

6. Red

Technische analyse

Organisatie van de code

Schrijf deze oefening als een nieuwe methode met de naam GekleurdeRommelzin in de klasse EenProgrammaSchrijvenInCSharp. Test uit door deze methode op te roepen binnen de Main methode.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Voor elke regel die in kleur getoond wordt, wissel je de voorgrondkleur. Op de juiste plaatsen in de code herstel je de oorspronkelijke kleuren van de terminal.

Testscenario's

• Test opnieuw uit met een kleur, maaltijd, auto, film en boek naar keuze.

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

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:

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.

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.

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:

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:

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

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.

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:

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!

Replace

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

TrimStart / TrimEnd / Trim

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

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

De output van dit programma zal dan zijn:

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

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.

Al deze oefeningen maak je in een klasse StringsEnHunMethoden

Oefening: VariabelenEnHoofdletters

Leerdoelen

• gebruik van variabelen om input en output op te slaan en te tonen

• functionaliteit van strings

Functionele analyse

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

Technische analyse

Noem de methode voor deze oefening VariabelenEnHoofdletters.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en sla deze op in een variabele. Zet de inhoud van deze variabele om in hoofdletters. Je kan dit doen door ToUpper() te gebruiken. Uiteindelijk geef je dan het resultaat weer in de console.

Testscenario's

• Voer tekst in met spaties

• Voer tekst in van meer dan 100 karakters

• Voer tekst in van 1 karakter

• Voer geen tekst in

Oefening: H3-string-interpolation

Leerdoelen

• gebruik van string interpolation

Functionele analyse

Zelfde als oefeningen maaltafels en ruimte vorig hoofdstuk.

Technische analyse

Je moet twee methoden schrijven. Noem de eerste MaaltafelsStringInterpolatie en de tweede RuimteStringInterpolatie. Deze doen net hetzelfde als hun tegenhangers uit het vorige hoofdstuk, maar je bouwt de getoonde tekst op met stringinterpolatie in plaats van via + en/of Console.Write.

voorbeeldinteractie(s)

Zie oefening H2-maaltafels en H2-ruimte.

Technische hulp

Programmaverloop

Pas string interpolatie m.b.v. $ toe om de veranderlijke onderdelen van de output in te vullen.

Testscenario's

• Zie oefening H2-maaltafels en H2-ruimte.

Oefening: H3-bereken-btw

Leerdoelen

• gebruik van string interpolation

Functionele analyse

Een programma vraagt een bedrag en vervolgens btw percentage in te geven waarna het bedrag incl. btw-percentage wordt weergegeven.

Technische analyse

Noem de methode voor deze oefening BerekenBtw.

voorbeeldinteractie(s)

Technische hulp

Programmaverloop

Het bedrag dat wordt ingevoerd moet geconverteerd worden naar een int met Convert.ToInt32.

Pas string interpolatie toe om de output te tonen.

Testscenario's

• Typ tekst in

• Geef een veel te groot bedrag in

Oefening: H3-leetspeak

Leerdoelen

• functionaliteit van strings leren kennen

Functionele analyse

We willen tekst omvormen naar een ander formaat. Laat de gebruiker een lijn tekst ingeven en haal er alle tussenliggende spaties uit en vervang de a's door @

Technische analyse

Gebruik Console.ReadLine om tekst in te lezen en hou bij in een variabele. Pas de nodige string methodes toe om het resultaat te verkrijgen. Noem je methode voor dit programma LeetSpeak.

Programmaverloop

Testscenario's

• test met een zin zonder a's

• test met een zin met vijf a's of meer

• test met een lege string

Oefening: H3-instructies

Leerdoelen

• leren werken met stringinterpolatie

• leren werken met methodes van strings

Functionele analyse

We willen met behulp van een programma instructies genereren voor de gebruiker. Meerbepaald wordt automatisch aangegeven in welke map de gebruiker bepaalde bestanden op een UNIX-achtig systeem moet bijhouden.

Voor deze oefening is het verplicht gebruik te maken van een (geïnterpoleerde) string.

Technische analyse

Op basis van de voornaam van de student en de naam van de cursus wordt de map gegeven die de student moet aanmaken (/home/, eerste 3 letters voornaam, in hoofdletters met submap de naam van de cursus. Noem je methode Instructies.

Programmaverloop

Oefening: H3-lotto

Leerdoelen

• functionaliteit van strings

• stringinterpolatie

Functionele analyse

De gebruiker voert zijn lottocijfers in. We willen deze op een overzichtelijke manier weergeven.

Technische analyse

Laat de lottocijfers allemaal achter elkaar ingeven, gescheiden door komma's, zonder spaties. De gebruiker wordt verondersteld cijfers onder de 10 in te geven voorafgegaan door een nul. Gebruik de juiste methode om de cijfers uit te string te "knippen" en gebruik het karakter | om de uitvoer te scheiden. Noem je methode Lotto.

Voorbeeldinteractie

Oefening: H3-som-van-cijfers

Leerdoelen

• functionaliteit van strings

• stringinterpolatie

Functionele analyse

De gebruiker voert een getal in. Het programma berekent de som van de cijfers in de decimale voorstelling van dit getal.

Technische analyse

We veronderstellen dat de gebruiker een getal van exact vijf cijfers ingeeft, desnoods vooraan opgevuld met nullen. Noem je methode SomVanCijfers.

Voorbeeldinteractie

Onderstaand voorbeeld komt uit op 27, want 6 + 3 + 9 + 2 + 7 is 27.

Oefening: H3-naam-uit-mail

Leerdoelen

• functionaliteit van strings

• stringinterpolatie

Functionele analyse

De gebruiker voert een e-mailadres in. Jouw programma toont hieruit het gedeelte dat de naam voorstelt, in hoofdletters.

Technische analyse

We veronderstellen dat de gebruiker een juist mailadres invult. Noem je methode NaamUitEmail.

Voorbeeldinteractie

Oefening: H3-eerste-letter-en-achternaam

Leerdoelen

• functionaliteit van strings

• stringinterpolatie

Functionele analyse

De gebruiker voert zijn naam in. Je programma toont dan de eerste letter van de voornaam en de familienaam.

Technische analyse

We veronderstellen dat de gebruiker een voornaam zonder spaties invult. Noem je methode EersteLetterEnAchternaam.

Voorbeeldinteractie

Oefening: H3-toegangscode

Leerdoelen

• functionaliteit van strings

• stringinterpolatie

• omzetting tussen tekst en getal

Functionele analyse

De gebruiker voert enkele persoonlijke gegevens in en op basis hiervan wordt een persoonlijke toegangscode gegenereerd.

Technische analyse

Noem je methode Toegangscode. De code van vier tot vijf cijfers wordt als volgt bepaald:

• het eerste symbool is de voorlaatste letter van de naam, in kleine letters

• het tweede symbool is de laatste letter van de naam, in hoofdletters

• het derde symbool is het laatste cijfer van het geboortejaar

• het vierde (en eventueel vijfde) symbool is het eerste cijfer van de postcode, in het kwadraat (dus vermenigvuldigd met zichzelf)

Voorbeeldinteractie

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.

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:

Logische operatoren

De logische EN, OF en NIET-operatoren die je misschien kent uit de lessen technologie of elektronica kan je ook gebruiken in C#:

Je kan de &&-operator tussen twee booleaanse expressies zetten om een nieuwe, grote expressie te schrijven die afhangt van de kleinere expressies aan beide kanten. Idem voor de ||-operator. Je kan de niet-operator voor een booleaanse expressie zetten om het resultaat hiervan om te draaien. Bijvoorbeeld:

Hieronder krijg je nog eens het overzicht van de werking van de AND en OR operatoren:

Test jezelf

Wat zal de uitkomst zijn van volgende expressies? (tip: het zal steeds true of false zijn, niets anders)

• 3>2

• 4!=4

• 4<5 && 4<3

• "a"=="a" || 4>=3

• (3==3 && 2<1) || 5!=4

• !(4<=3)

• true || false

• !true && false

Booleaanse expressies algemeen

Je bent niet beperkt tot het gebruik van expressies met één relationele operator in de voorwaarde van een if. Je mag om het even welk type booleaanse expressie gebruiken. Anders gezegd: als het gedeelte tussen haakjes uiteindelijk maar true of false oplevert, is het goed. We kunnen dus ook gebruik maken van de logische operatoren &&, ||, ! in onze voorwaarden.

Goed gebruik van booleaanse expressies kan onze programma's drastisch vereenvoudigen. We tonen dit met een voorbeeld.

Volgend programma bepaalt of je korting krijgt op het openbaar vervoer. Volg zelf de flowchart om de logica te snappen:

Maar we kunnen dit eenvoudiger zo schrijven:

Deze code zegt dat je korting krijgt als je jonger bent dan 18 of als je ouder bent dan 65. Ze doet hetzelfde als de eerste versie, maar het diagram is eenvoudiger en de gegenereerde code is dat ook. Ook via de andere operatoren && en ! kan je gelijkaardige vereenvoudigingen verkrijgen.

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

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.

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

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:

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:

For

Het gebeurt heel vaak dat we een teller bijhouden die aangeeft hoe vaak een lus al doorlopen is. Wanneer de teller een bepaalde waarde bereikt moet de loop afgesloten worden.

Bijvoorbeeld volgende code om alle even getallen van 0 tot 10 te tonen:

Met een for-loop kunnen we deze veel voorkomende code-constructie verkort schrijven.

For syntax

De syntax van een for-loop is de volgende:

• setup: In het setup gedeelte voeren we code uit die klaar moet zijn voor de lus voor het eerst begint. Dat betekent in de praktijk bijna altijd dat we een loop variabele aanmaken waarmee we bijhouden hoe vaak we al door de lus zijn gegaan. Variabelen die je hier aanmaakt hebben dezelfde scope als de body van de lus. Wanneer de for eindigt, bestaan ze met andere woorden niet meer.

• test: Hier plaatsen we een booleaanse expressie die nagaat of de lus mag worden uitgevoerd. Deze heeft dus niet dezelfde functie als de booleaanse expressie van een while. Als ze false oplevert, wordt de body van de lus niet meer uitgevoerd. Dit betekent in de praktijk heel vaak dat we nagaan of de loop variabele al een zekere waarde heeft bereikt.

• update: Hier plaatsen we wat er moet gebeuren telkens de loop body is afgewerkt. Meestal zullen we hier de loop variabele verhogen of verlagen.

In Flowgorithm (dit stemt helaas niet 100% overeen met C# omwille van een klein verschil in scope):

Gebruiken we deze kennis nu, dan kunnen we de eerder vermelde code om de even getallen van 0 tot en met 10 tonen als volgt:

Voor de indexvariabele kiest men meestal niet teller, maar i, maar dat is niet noodzakelijk. In de setup wordt dus een variabele op een start-waarde gezet. De test zal aan de start van iedere loop kijken of de voorwaarde nog waar is, indien dat het geval is dan wordt een nieuwe loop gestart en wordt i met een bepaalde waarde, zoals in update aangegeven, verhoogd.

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:

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:

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:

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:

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:
• Een bug die een oneindige loop veroorzaakt:

Scope van variabelen in loops

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

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:

Array principes

Arrays

Stel je voor dat je, met de kennis die je nu hebt, een boodschappenlijstje moet programmeren. Met andere woorden, een programma dat vraagt om een aantal regels tekst in te typen, waarbij je dan items kan aanduiden als gekocht.

Je zou ruimte kunnen voorzien voor 3 items, voorgesteld als string, als volgt:

Een groot nadeel van deze aanpak: als je vier items wil ondersteunen, heb je meer code nodig. Als je vijf items wil ondersteunen, heb je nog meer code nodig. Deze code kan geen basis zijn voor een degelijk boodschappenlijstje.

Een tweede mogelijkheid bestaat erin heel het lijstje voor te stellen als een string, als volgt:

Hiermee kan je elk gewenst aantal items toevoegen, maar de voorstelling is erg onhandig. Als je bijvoorbeeld item zeven op je lijstje wil zoeken, moet je plustekens eerst zes plustekens tellen. Als je het lijstje op een andere manier wil tonen aan de gebruiker, bijvoorbeeld met één item per regel, is dat lastig. Als je wil bijhouden of iets gekocht is, kan je daar geen boolean voor gebruiken, maar moet je bijvoorbeeld een vinkje vlak voor het item plaatsen. Dat is allemaal vrij ingewikkelde code voor een vrij eenvoudige taak.

Arrays bieden een oplossing voor deze problemen. Arrays zijn reeksen van waarden, maar ze zijn zelf ook waarden. Met andere woorden, ze maken het mogelijk één variabele te maken die verschillende waarden voorstelt. Hierdoor wordt je code leesbaarder en eenvoudiger in onderhoud. Arrays zijn een zeer krachtig hulpmiddel, maar er zitten wel enkele addertjes onder het gras.

Laat ons beginnen bij het begin: een array is een reeks waarden van één type en heeft een bepaalde lengte. Bijvoorbeeld een reeks van 10 ints of 5 strings. Je kan dus geen reeks hebben met een mengeling van int en string, of van boolean en double, of wat dan ook. Je kan een array toekennen aan een variabele, maar je kan ook individuele waarden uit de reeks halen door middel van een index. Dit is een getal dat een positie in de reeks aanduidt, zoals je dat ook kent van de substring methode.

We zullen het eerst even voordoen in Flowgorithm.

Basisgebruik arrays

Arrays declareren

Net als andere datatypes moet je aangeven dat een variabele van een bepaald array type is. Je moet dus de compiler informeren dat er een array bestaat met een bepaalde naam en een bepaald type. Dit is bijna hetzelfde als het declareren van een variabele van een van de types die je al kent, maar je geeft aan dat het om een reeks gaat door middel van rechte haken.

We geven hier enkele voorbeelden:

De rechte haken betekenen dus "een reeks van" en een declaratie van een reeks kan een heleboel declaraties van individuele variabelen vervangen. Met deze voorstelling heb je bijvoorbeeld item1 en item2 en item3 niet meer nodig.

Als we naar de Flowgorithm code van het boodschappenlijstje kijken, zien we dit ook:

Merk wel op: hier vindt ook meteen een initialisatie plaats.

Een initialisatie vertelt de compiler niet alleen dat deze variabele bestaat, maar ook wat zijn eerste waarde is. Een waarde van een array-type stelt eigenlijk een hoeveelheid ruimte in het geheugen voor. Ruimte voor een bepaald aantal strings, voor een bepaald aantal getallen, maakt niet uit. Om technische redenen die we later in meer detail bekijken, moet je deze ruimte reserveren met het keyword new. Je moet ook zeggen hoe veel ruimte je nodig hebt. Bijvoorbeeld, met de declaraties van hierboven:

Zoals je merkt uit het laatste voorbeeld, mag je deze waarde ook berekenen. Ook het Flowgorithm voorbeeld toont dit, want daar wordt aantalItems ingelezen.

Arrays opvullen

Nadat de nodige ruimte voorzien is, kan je deze gebruiken. Dit doe je door te zeggen dat een bepaalde waarde op een bepaalde positie in de reeks terechtkomt. Deze positie noemen we de index van het element. Het eerste element krijgt index 0, niet 1. Het laatste krijgt een index gelijk aan de lengte van de array verminderd met 1.

We geven even een voorbeeld rechtstreeks in C#:

Dit hoeven geen vaste waarden te zijn! Je kan ook dit doen:

Dit zorgt dat je code kan uitsparen. Met 10 individuele variabelen, dus zonder array, zou je bovenstaande code ongeveer zo moeten schrijven:

Maar met een array heb je ook deze optie:

En als je je lijstje wil uitbreiden tot 1000 items, moet je alleen de 10 door 1000 vervangen. We zullen nog vaak gebruik maken van arrays en lussen om herhaalde code te vermijden!

Arrays uitlezen

Je gebruikt de notatie met rechte haken ook om een array uit te lezen:

Ook hier bespaar je vervelend werk met een lus:

Als je een element probeert uit te lezen dat nog geen waarde gekregen heeft, krijg je een defaultwaarde. Wat voor waarde dat is, hangt af van de array. Er zit een systeem achter, maar dat behandelen we pas later in de cursus. Voorlopig mag je dit onthouden: voor getallen krijg je 0. Voor booleans krijg je false. Voor strings krijg je een speciale waarde null, die verschillend is van "". intWat je vooral moet weten over null is dat je er geen eigenschappen van kan opvragen of methodes op kan toepassen. Ik laat even zien wat ik bedoel.

Dus als een variabele null bevat of kan bevatten, moet je syntax vermijden die hier een punt achter plaatst. Je kan dit op een eenvoudige manier doen met if (mijnVariabele is null) { ... } else { ... }.

De lengte van de array te weten komen

Soms kan het nodig zijn dat je in een later stadium van je programma de lengte van je array nodig hebt. De Length eigenschap geeft je deze lengte. Volgend voorbeeld toen dit:

Het voordeel hiervan is je maar één keer moet vastleggen hoe groot de array is en daarna in het algemeen over de grootte kan spreken. Zo kan je bij het aanpassen van je code niet vergeten overal de juiste aanpassing te doen. Let op: de lengte geeft niet aan hoe veel items je al hebt ingevuld! Ze geeft aan hoe veel plaats er maximaal is in de array.

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

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

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.

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:

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: