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.

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.

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

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

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

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.

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

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

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

Het belang van het maken van afspraken voor het geven namen

1. We kunnen niet genoeg benadrukken hoe belangrijk het is om afspraken te maken en te volgen bij het schrijven van programma's. Goede afspraken zorgen ervoor dat je:

   1. code gemakkelijk kan delen met andere programmeurs; zonder afspraken kan je niet in een team werken;

   2. veel sneller fouten in je programma zal vinden;

   3. code leesbaar blijft, ook als je maanden later opnieuw bekijkt;

   4. sneller en beter gaan leren programmeren;

2. We vinden het warm water niet opnieuw uit en volgen de richtlijnen van Microsoft:
3. De basis voor de naamgevingsafspraken zijn:

   1. PascalNotatie: geen spaties tussen de woorden en alle woorden beginnen met een hoofdletter: EenProgrammaOmJeGoedBijTeVoelen

   2. camelCasenotatie: geen spaties tussen de woorden en alle woorden, behalve het eerste, beginnen met een hoofdletter, bijvoorbeeld: eenProgrammaOmJeGoedBijTeVoelen

Rootmap

Ik raad jullie aan een rootmap te maken voor alle vakken die je op AP volgt. Je geeft die bijvoorbeeld de naam "AP" of "Hogeschool". Daarin maak je een map met de naam Programmeren Intro. In deze map zullen we alle projecten plaatsen die we in dit vak zullen maken.

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.

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:

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

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

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

Een variabele declaratie heeft als syntax:

Bijvoorbeeld: int leeftijd;

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

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.

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:

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:

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.

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:

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:

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

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.

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

Geavanceerd

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

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.

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

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

using System;

namespace Demo1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            Console.WriteLine("Hoi, ik ben het");
            Console.WriteLine("Wie ben jij?!");
        }
    }
}

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:

string result;
result = Console.ReadLine();

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:

namespace Demo1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hoi, ik ben het!");
            Console.WriteLine("Wie ben jij?!");
            string result;
            result = Console.ReadLine();
        }
    }
}

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.

Console.WriteLine("Dag ");
Console.WriteLine(result);
Console.WriteLine(" hoe gaat het met je?");

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:

using System;

namespace Demo1
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine("Hoi, ik ben het!");
            Console.WriteLine("Wie ben jij?!");

            string result;
            result = Console.ReadLine();

            Console.WriteLine("Dag");
            Console.WriteLine(result);
            Console.WriteLine("hoe gaat het met je?");
        }
    }
}

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

Voorbeelduitvoer (lijn 3 is wat de gebruiker heeft ingetypt)

Hoi, ik ben het!
Wie ben jij?!
tim [enter]
Dag
tim
hoe gaat het met je?

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:

Hoi, ik ben het!
Wie ben jij?!
tim [enter]
Dag
result
hoe gaat het met je?

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:

Console.Write("Dag");
Console.Write(result);
Console.Write("hoe gaat het met je?");

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

Hoi, ik ben het!
Wie ben jij?!
tim [enter]
Dagtimhoe gaat het met je?

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:

Console.Write("Dag ");
Console.Write(result);
Console.Write(" hoe gaat het met je?");

Je uitvoer wordt nu:

Hoi, ik ben het!
Wie ben jij?!
tim [enter]
Dag tim hoe gaat het met je?

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

Console.Write("Dag"_);
Console.Write(result_);
Console.Write("hoe gaat het met je?");

Correct:

Console.Write("Dag_");
Console.Write(result);
Console.Write("_hoe gaat het met je?");

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:

Console.WriteLine("Dag " + result + " hoe gaat het met je?");

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:

Console.WriteLine("Dag "+ result + " hoe gaat het met je?");
Console.Write("Dag "+ "result" + " hoe gaat het met je?");

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:

Console.WriteLine("Geef leeftijd");
string leeftijd;  //eerste geheugenplekje aanmaken
leeftijd = Console.ReadLine();
Console.WriteLine("Geef adres");
string adres; //tweede geheugenplekje aanmaken
adres = Console.ReadLine();

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:

string leeftijd;  //eerste geheugenplekje aanmaken
string adres; //tweede geheugenplekje aanmaken
Console.WriteLine("Geef leeftijd");
leeftijd = Console.ReadLine();
Console.WriteLine("Geef adres");
adres = Console.ReadLine();

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)

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

Technische hulp

Programmaverloop

Lees de gebruikersinvoer van de console en 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)

23
280
12
-10

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)

12

Technische hulp

Programmaverloop

Eerst wordt het resultaat berekend, daarna wordt het geprint.

Testscenario's

• Test uit met getallen van het type int.

• Test uit met getallen van het type float.

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)

1 * 411 is 411.

2 * 411 is 822.

(enzovoort)

10 * 411 is 4110.

Technische hulp

Programmaverloop

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

Testscenario's

• Test uit zoals gegeven.

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

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)

Op Mercurius voel je je alsof je 26.22kg weegt.
Op Venus voel je je alsof je 62.79kg weegt.
Op Aarde voel je je alsof je 69kg weegt.
Op Mars voel je je alsof je 26.22kg weegt.
Op Jupiter voel je je alsof je 161.46kg weegt.
Op Saturnus voel je je alsof je 73.14kg weegt.
Op Uranus voel je je alsof je 63.48kg weegt.
Op Neptunus voel je je alsof je 82.11kg weegt.
Op Pluto voel je je alsof je 4.14kg weegt.

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.

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

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)

Wat is je favoriete kleur?
> blauw
Wat is je favoriete eten?
> spaghetti
Wat is je favoriete auto?
> Toyota Aygo
Wat is je favoriete film?
> Robocop 2
Wat is je favoriete boek?
> The Gone-Away World
Je favoriete kleur is spaghetti. Je eet graag Toyota Aygo. Je lievelingsfilm is The Gone-Away World en je favoriete boek is Robocop 2.

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.

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.

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:

int temperatuursVerschil = temperatuurGisteren - temperatuurVandaag;

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

De voorgaande code kan ook langer geschreven worden als:

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

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

temperatuursVerschil = 21 - 25;

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

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

Operators

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

1. Haakjes

2. Vermenigvuldigen, 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:

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

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

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

double  gewichtOpMars = (gewichtOpAarde/zwaartekrachtAarde) * zwaartekrachtMars; //kg
Console.WriteLine("Op Mars voelt het alsof je " + gewichtOpMars + " kg weegt.");

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.

int result = 3+4;

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

int otherResult = 3.1/45.2;

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

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

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

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

double result = 3/5.6;

Volgende niet:

int result = 3/5.6;

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

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

En nu krijgen we wel 4.5.

En complexer?

Het kan subtiel worden in grotere berekeningen.

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

double helft = 10000.0 * (1/2);

Hoeveel krijg je van me? 0.0 euro!

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:

double helft = 10000.0 * (1.0/2); // of 1/2.0 of zonder haakjes

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.

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

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

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.

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:

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

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:

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

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:

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.

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