Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Fijn dat je interesse toont om aan deze cursus te helpen. Dit kan op meerdere manieren:
Je mag me altijd gewoon mailen met tips, opmerkingen of verbeteringen.
Je kan de originele bronbestanden hier downloaden en aanpassen naar believen. Stuur me nadien gerust je aanpassingen door.
Je kan rechtstreeks aanpassingen doen via een fork in github en deze via een merge requests in de cursus integreren. Dit staat hier onder uitgelegd.
Maak een github account
Fork de cursus naar je eigen account : klik linksboven op fork.
En volg de uitleg hier om in sync te blijven en een lokale copy te maken.
Zorg ervoor dat je telkens in de nieuwste versie werkt zoals hier uitgelegd staat.
Aanpassen maar
Telkens je een batch aanpassingen naar mij wilt sturen doe je dat met behulp van een pull request. Letterlijk: je vraag aan mij om jouw aanpassingen "binnen te trekken". Ik moet die dan controleren en (hopelijk) binnentrekken. Hier zie je hoe je naar mij een pull request moet sturen.
Aardig wat mensen, grotendeels studenten 1EA van 2019-2020, hebben me met deze cursus geholpen. Waarvoor dank! Hieronder een zo volledige lijst mogelijk van de vele typo-hunters, inputgevers, reviewers en schouderklopjesgevers.
Eerst wil ik vier studenten apart bedankt voor hun hardcore input in deze cursus, namelijk:
Claeys Ailko
Van Driel Kevin
Van Riel Lennert
Hattas Zeno
Zonder jullie zou deze cursus een pak meer fouten, onduidelijkheden en Pokemons in plaats van Pokémons bevatten. Merci heren!
Deze cursus bevat hier en daar enkele typo's. Die zijn er uiteraard bewust kuch in geplaatst. Zij die er vinden zullen voor eeuwig in deze hall of fame opgenomen worden. Ere aan de volgende typohunters:
Hendrikx Ben, Van Ingelghem Brian, De Vree Bart, Strauven Wannes, Van Breedam Arne, Yoncalik Arafa, Baeten Tom, Baert Jonas, Teka Sala Brian, Schrauwen Stijn, Ahmad Saqib Shan, Sinogba Russel, Brosens Laurens, Kramp Thomas
Keep'm coming!
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#:
C# Programming van Mike McGrath: een uiterst compact, maar zeer helder en kleurrijk boekje dat ik ten stelligste aanbeveel als je wat last hebt met de materie van de eerste weken.
Microsoft Visual C# 2015: An introduction to OOP van Joyce Farrell: Niet het meest sexy boek, maar wel het meest volledige qua overlap met de leerstof van deze cursus. Aanrader voor zij die wat meer in detail willen gaan en op zoek zijn naar oneindig veel potentiele examenvragen ;)
Head First C# van Andrew Stellman & Jennifer Greene: laat de ietwat bizarre, bijna kleuterachtige look and feel van de head first boeken je niet afschrikken. Ieder boek in deze serie is goud waar. De head first boeken zijn d� ideale manier als je zoekt naar een alternatieve manier om complexe materie te begrijpen. Bekijk zeker ook de Head First Design Patterns en Head First Sql boeken in de reeks!
C# Unleashed van Bart De Smet: in mijn opinie dé referentie om C# tot op het bot te begrijpen. Geschreven door een Belg die bij Microsoft in Redmond aan C# werkt.
Code Complete van Steve McConnell: een referentiewerk over 'programmeren in het algemeen'. Het boek is al jaar en dag het te lezen boek als je je als programmeur wilt verdiepen in wat nu 'correct programmeren' behelst. Als je op je CV kunt zetten dat je dit boek door en door kent dan zal elk IT-bedrijf je stante pede aannemen ;)
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.
Volgende document bevat een overzicht van de basis C# syntax zaken van het eerste en (deel van het) tweede semester: download hier
Ideale manier om programmeren meer in de vingers te krijgen op een speelse manier:
SoloLearn: Verplichte app! Simple as that!
Enki Net zoals SoloLearn maar dan anders.
Memrise (aanrader!) Origineel vooral bedoeld om spreektalen te leren, maar bevat ook tal van andere zaken. Hoofdzakelijk nuttig om nieuwe aspecten te 'drillen'. Enkel dus nuttig indien je de basismaterie eerst hebt verwerkt. Bekijk zeker ook de tal van andere cursussen die er staan. Let er op dat je bij de filter Engels instelt, er zijn nog niet veel (goede) Nederlandstalige C# cursussen naar mijn weten. Opgelet: je kan je enkel via de browser inschrijven op niet-spreektaal-cursussen. De app toont enkel spreektaalcursussen.
Mimo Speels en vrij beperkt in gratis versie, maar ideale aanvulling op SoloLearn.
Screeps Een steam spel om te leren programmeren. Weliswaar Javascript (nuttig voor Web Programming) maar het concept is te cool om niet hier te vermelden en zoals je zal ontdekken: leren programmeren kan je in eender welke taal, en het zal ook je andere programmeer-ervaring verbeteren. Give it a go!
Coding game zeer vet
Pex For Fun (specifiek voor C#!)
RPG Game in C# (behandelt leerstof van volledig eerste jaar en meer)
Advent of code Pittige programmeeroefeningen die jaarlijks in december verschijnen.
Free Programming Book Handig vorm gegeven gratis ebooks met tal van onderwerpen waaronder ook C# en het .NET Framework.
Tutorials teacher: De uitgebreidere, Engelstalige variant van deze cursus zeg maar.
Online video c# cursus: Zeer aan te raden indien je een bepaald concept uit de les niet begrijpt.
C-sharp.be : Nederlandstalige cursus met veel toffe oefeningen waarvan je sommige zelfs in deze cursus zal terugvinden.
Microsoft Virtual Academy: Microsoft heeft een virtual academy cursus "C# fundamentals" uitgebracht. Ik kan deze cursus zeer erg aanbevelen.
Rob Miles's The C# Programming Yellow book: Zeer vermakelijk, vlot geschreven C# boek(je)
Open Source Game Clones: "This site tries to gather open-source remakes of great old games in one place." Je vindt er ook tal van C# projecten terug zoals GTA 2.Klik bovenaan op "languages" en filter maar eens op C#.
Een lijst met oude oefenvragen uit 2010: nog steeds relevant.
Ja hoor, ze bestaan. Meer en meer professionele én beginnende programmeurs streamen terwijl te programmeren. Dit is een ideale manier om te zien hoe andere mensen problemen aanpakken. De meeste programming streamers kan je terugvinden op youtube, maar ook op Twitch zijn er steeds meer. Enkele aanraders (bekijk zeker de filmpjes uit de archieven eens):
Handmade Hero: deze programmeur heeft een volledige RPG gemaakt en het hele proces gestreamd.
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.
Om een algoritme te schrijven dat onze computer begrijpt dienen we een programmeertaal te gebruiken. Net zoals er ontelbare spreektalen in de wereld zijn, zijn er ook vele programmeertalen. C# (spreek uit 'siesjarp') is er een van de vele. In tegenstelling tot onze spreektalen moet een computertaal 'exact' zijn en moet het op ondubbelzinnige manier door de computer verstaan worden. C# is een taal die deel uitmaakt van de .NET (spreek uit 'dotnet') omgeving die meer dan 15 jaar geleden door Microsoft werd ontwikkeld (juli 2000).
Deze cursus werd geschreven in Markdown. Helaas ondersteunt deze geen # in titels. Daardoor heet dit hoofdstuk "C-Sharp" en niet "C#". Niets aan te doen.
De geschiedenis en de hele .NET-wereld vertellen zou een cursus op zich betekenen en gaan we hier niet doen. Het is nuttig om weten dat er een gigantische bron aan informatie over .NET en C# online te vinden is, beginnende met docs.microsoft.com.
Bij de geboorte van .NET in 2000 zat dus ook de taal C#. .NET is een zogenaamd framework. Dit framework bestaat uit een grote groep van bibliotheken (class libraries) en een virtual execution system genaamd de Common Language Runtime (CLR). De CLR zal ervoor zorgen dat C#, of andere .NET talen (F#, VB.NET, etc.), kunnen samenwerken met de vele bibliotheken.
Om een uitvoerbaar bestand te maken (executable, vandaar de extensie .exe bij uitvoerbare programma's in windows) zal de broncode die je hebt geschreven in C# worden omgezet naar Intermediate Language (IL) code. Op zich is deze IL code nog niet uitvoerbaar, maar dat is niet ons probleem. Wanneer een gebruiker een in IL geschreven bestand wil uitvoeren dan zal, achter de schermen, de CLR deze code ogenblikkelijk naar machine code omzetten (Just -In-Time of JIT compilatie) en uitvoeren. De gebruiker zal dus nooit dit proces merken (tenzij er geen .NET framework werd geïnstalleerd op het systeem).
Merk op dat we veel details van de compiler achterwege laten hier. De compiler is een uitermate complex element, maar in deze fase van je (prille) programmeursleven hoeven we enkel de kern van de compiler te begrijpen: het omzetten van C# code naar een uitvoerbaar bestand geschreven in IL code.
Deze cursus heeft als doel om je de programmeertaal C# aan te leren. Terwijl we dit doen zullen we ook geregeld andere .NET framework gerelateerde zaken aanraken.
Deze cursus bevat de eerste 2 hoofdstukken van het online handboek dat wordt gebruikt binnen de opleiding professionele bachelor elektronica-ict van de AP Hogeschool.
Het volledige handboek bestaat uit 2 delen (1 per semester) om te 'leren programmeren met C#':
Deel 1: Programming Principles, eerste semester
Deel 2: Object Oriented Programming, tweede semester
Veel leer-en leesplezier,
Tim Dams
PS: Besef dat goed kunnen programmeren enkel kan geleerd worden indien je ook effectief veel programmeert. Je kan ook niet leren fietsen door enkel een handboek "Fietsen met Merckx" te lezen, je zal op de fiets moeten springen! En vallen...véél vallen.
Licensed under CC-BY-NC 4.0 as shown here.
This is a human-readable summary of (and not a substitute for) the license.
Share : copy and redistribute the material in any medium or format
Adapt : remix, transform, and build upon the material
The licensor cannot revoke these freedoms as long as you follow the license terms.
Attribution : You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use. NonCommercial : You may not use the material for commercial purposes.
No additional restrictions : You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
Visual Studio (VS) is een pakket dat een groot deel tools samenvoegt (debugger, code editor, compiler, etc) zodat je niet tientallen paketten moet gebruiken om software te schrijven.
Visual Studio is een zogenaamde IDE("Integrated Development Environment") en is op maat gemaakt om C#.NET applicaties te ontwikkelen. Je bent echter verre van verplicht om enkel C# applicaties in VS te ontwikkelen, je kan gerust VB.NET, TypeScript, Python en andere talen gebruiken.
Jouw taak als programmeur in deze cursus is algoritmes in C# taal uitschrijven. We zouden dit in een eenvoudige tekstverwerker kunnen doen, maar dan maken we het onszelf lastig. Net zoals je tekst in notepad kunt schrijven, is het handiger dit in bijvoorbeeld Word te doen: je krijgt een spellingchecker en allerlei handige extra's. Ook voor het schrijven van computer code is het handiger om een zogenaamde IDE te gebruiken, een omgeving die ons zal helpen foutloze C# code te schrijven.
Het is belangrijk bij de installatie dat je minimaal
Uiteraard ben je vrij om meerdere zaken te installeren.
Na het opstarten van VS krijg je het startvenster te zien van waaruit je verschillende dingen kan doen.
We zullen nu een nieuw project aanmaken, kies hiervoor "Create a new project".
Het "New Project" venster dat nu verschijnt geeft je hopelijk al een glimp van de veelzijdigheid van VS. In het rechterdeel zie je bijvoorbeeld alle Project Types staan. M.a.w. dit zijn alle soorten programma’s die je kan maken in VS. Naargelang de geïnstalleerde opties en bibliotheken zal deze lijst groter of kleiner zijn.
Dit semester kiezen we steeds als Project Type Console App (.NET Core). Kies dit type en klik 'Next'.
Op het volgende scherm kan je een naam geven voor je project alsook de locatie op de harde schijf waar het project dient opgeslagen te worden. Onthoudt waar je je project aanmaakt zodat je dit later terugvindt.
De solution name blijf je af (deze moet momenteel dezelfde naam zijn als je project)
Geef je projectnamen ogenblikkelijk duidelijke namen zodat je niet opgezadeld geraakt met projecten zoals Project201.
Geef je project de naam "MyFirstProject" en kies een goede locatie (ik raad je aan dit steeds in Dropbox of Onedrive te doen)
Klik nu op create.
VS heeft nu reeds een aantal bestanden aangemaakt die je nodig hebt om een ‘Console Applicatie’ te maken. Een console applicatie is een programma dat alle uitvoer naar een zogenaamde ‘console’ stuurt, een shell. M.a.w., je kan enkel tekst (Unicode) als uitvoer genereren en dus geen multimedia elementen zoals afbeeldingen, geluid, etc.
Wanneer je VS opstart zal je mogelijk overweldigd worden door de hoeveelheid menu's, knopjes, schermen, etc. Dit is normaal voor een IDE: deze wil zoveel mogelijk mogelijkheden aanbieden aan de gebruiker. Vergelijk dit met Word: afhankelijk van wat je gaat doen gebruikt iedere gebruiker andere zaken van Word. De makers van Word kunnen dus niet bepaalde zaken weglaten, ze moeten net zoveel mogelijk aanbieden.
Laat je niet afschrikken door VS. Het is een imponerend programma, maar je zal er sneller dan je verwacht, je weg in terugvinden!
We zullen nu eerst eens bekijken wat we allemaal zien in VS na het aanmaken van een nieuw programma.
Je kan meerdere bestanden tegelijkertijd openen in VS. Ieder bestand zal z'n eigen tab krijgen. De actieve tab is het bestand wiens inhoud je in het hoofdgedeelte eronder te zien krijgt. Merk op dat enkel open bestanden een tab krijgen.
De "solution explorer" toont alle bestanden en elementen die tot het huidige project behoren. Als we dus later nieuwe bestanden toevoegen dan kan je die hier zien (en openen).
Het properties venster (eigenschappen) is een belangrijk venster. Hier komen alle eigenschappen van het huidige geselecteerde element. Selecteer bijvoorbeeld maar eens Program.cs in de solution explorer en merk op dat er allerlei eigenschappen getoond worden. Onderaan het Properties venster wordt steeds meer informatie getoond over de huidig geselecteerde eigenschap.
De layout van VS kan je volledig naar je hand zetten. Je kan ieder (deel-)venster en tab verzetten, verankeren en zelfs verplaatsen naar een ander bureaublad. Experimenteer hier gerust mee en besef dat je steeds alles kan herstellen. Het gebeurt namelijk al eens dat je layout een beetje om zeep is:
Om eenvoudig een venster terug te krijgen, bijvoorbeeld het properties window of de solution explorer: klik bovenaan in de menubalk op "View" en kies dan het gewenste venster (soms staat dit in een submenu).
Je kan ook altijd je layout in z'n geheel resetten: ga naar "Window" en kies "Reset window layout".
De code die VS voor je heeft gemaakt is reeds een werkend, maar weinig nuttig, programma. Je kan de code compileren en uitvoeren door op de groene driehoek bovenaan te klikken:
Als alles goed gaat krijg je nu "Hello world" te zien en wat extra informatie omtrent het programma dat net werd uitgevoerd:
Veel doet je programma nog niet natuurlijk, dus sluit dit venster maar terug af door een willekeurige toets in te drukken.
Een console-applicatie is een programma dat zijn in- en uitvoer via een klassiek commando/shell-scherm toont. Een console-applicatie draait in dezelfde omgeving als wanneer we in Windows een command-prompt openen (via Start-> Uitvoeren-> cmd [enter] ). We zullen in deze cursus enkel console-applicaties leren maken. Grafische frontends (bv WPF) komen in deze cursus niet aan bod.
Console-applicaties maken in C# vereist dat je minstens twee belangrijke C# methoden leert gebruiken: Via Console.WriteLine() kunnen we tekst op het scherm tonen en met behulp van Console.ReadLine() kunnen we input van de gebruiker inlezen en in ons programma verwerken.
Maak een nieuw console-project aan (noem het Demo1) en open het Program.cs bestand (indien het nog niet open is). Veeg de code die hier reeds staat niet weg!
Voeg onder de lijn Console.WriteLine("Hello World!"); volgende code toe:
Zodat je dus volgende code krijgt:
Compileer deze code en voer ze uit: **druk hiervoor op het groene driehoekje. Of via het menu Debug en dan Start Debugging.
Let erop dat je iedere 'zin' eindigt met een puntkomma.
We gaan nu iedere lijn code kort bespreken. Sommige lijnen code zullen lange tijd niet belangrijk zijn. Onthoud nu alvast dat: alle belangrijke code staat tussen de accolades onder de lijn static void Main(string[] args)!
using System; : Alle Console-commando's die we verderop gebruiken zitten in de System bibliotheek. Als we deze lijn (een zogenaamde directive) niet zouden schrijven dan moesten we System.Console.WriteLine i.p.v. Console.WriteLine schrijven verderop in de code.
namespace Demo1: Dit is de unieke naam waarbinnen we ons programma zullen steken, en het is niet toevallig de naam van je project. Verander dit nooit tenzij je weet wat je aan het doen bent.
class Program{}: Hier start je echte programma. Alle code binnen deze Program accolades zullen gecompileerd worden naar een uitvoerbaar bestand.
static void Main(string[] args): Het startpunt van iedere console-applicatie. Wat hier gemaakt wordt is een methode genaamd Main. Je programma kan meerdere methoden (of functies) bevatten, maar enkel degene genaamd Main zal door de compiler als het startpunt van het programma gemaakt worden.
Console.WriteLine("Hello world");: Dit is een statement dat de WriteLine-methode aanroept van de Console-klasse. Het zal alle tekst die tussen de aanhalingstekens staat op het scherm tonen.
Console.WriteLine("Hoi ik ben het");: en ook deze lijn komt op het scherm.
Sluitende accolades: vervolgens moet voor iedere openende accolade eerder in de code nu ook een bijhorende sluitende volgen.
Oh boy...Wat was dit allemaal?! We hebben al aardig wat vreemde code zien passeren en het is niet meer dan normaal dat je nu denkt "dit ga ik nooit kunnen". Wees echter niet bevreesd: je zal sneller dan je denkt bovenstaande code als 'kinderspel' gaan bekijken. Een tip nodig? Test en experimenteer met wat je al kunt!
Laat deze info rustig inzinken en onthoudt alvast volgende belangrijke zaken:
Al je code komt binnen de Main accolades.
Eindig iedere lijn code daar met een puntkomma ( ; ).
De WriteLine-methode is een veelgebruikte methode in Console-applicaties. Het zorgt ervoor dat we tekst op het scherm kunnen tonen.
Voeg volgende lijn toe na de vorige WriteLine-lijn in je project:
Console.WriteLine("Wie ben jij?!");
De WriteLine methode zal alle tekst tonen die tussen de " " staan tussen de haakjes van de methode. De aanhalingstekens aan het begin en einde van de tekst zijn uiterst belangrijk! Alsook het puntkomma helemaal achteraan.
Je programma is nu:
Kan je ook deze code uitvoeren?! Make it happen en ga dan gezwind naar het volgende hoofdstuk!
Neen. Telkens je op de groene "build en run" knop duwt worden al je aanpassingen bewaard. Trouwens: Kies nooit voor "save as..."!!!!
Dit zal aardig wat problemen in je project veroorzaken, geloof me maar.
We nemen terug ons eerste programma erbij en gaan hieraan verder werken:
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).
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).
We kunnen nu invoer van de gebruiker, die we hebben bewaard in de variabele result, gebruiken en tonen op het scherm.
In 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)
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:
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:
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:
Een leuke conversatie uit de oude doos:
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 tot 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 wordt wanneer je volgende lijn code vervangt door de lijn er onder:
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:
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 in console gebruiken is nuttig om je gebruikers een minder eentonig en meer informatieve applicatie aan te bieden. Je zou bijvoorbeeld alle foutmeldingen in het rood kunnen laten verschijnen.
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
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:
Het hart van Visual Studio bestaat uit de compiler die we hiervoor besproken. De compiler zal je C# code omzetten naar de IL-code zodat jij (of anderen) je applicatie op een computer (of ander apparaat) kunnen gebruiken. Zolang de C# niet exact voldoet aan de C# syntax (zie verder) zal de compiler het vertikken een uitvoerbaar bestand voor je te genereren.
Opmerking: In deze cursus zullen we steeds werken met Visual Studio. Niet met Visual Studio Code. Visual Studio code is een zogenaamde lightweight versie van VS die echter zeker ook z'n voordelen heeft (gratis, snel, compact, etc). Visual Studio vindt dankzij VS Code eindelijk ook z'n weg op andere platformen dan enkel die van Microsoft. Zoek je een lightweight versie dan moet je zeker eens eens proberen.
In deze cursus zullen de voorbeelden steeds met de Community editie van VS gemaakt zijn. Je kan deze als AP-student gratis downloaden en installeren via .
de .NET desktop development workload selecteert als te installeren tools.
kies verderop ook .NET Core cross-platform development
Nee hoor. Visual Studio is lekker groot. Was bovenstaande uitleg toch niet zo verhelderend als ik hoopte? Bekijk dan volgende korte, maar zeer duidelijke uitleg over Visual Studio en de verschillende onderdelen (klik zeker op de chapters in het linkermenu om verder te lezen): .
Als AP-student heb je ook recht op een Visual Studio Enterprise licentie. Wil je deze gebruiken, download deze dan via en zorg ervoor dat je een key aanvraagt via de tab 'Software' op . Je kan deze sleutel vervolgens via Help->Register in VS invoeren.
fuck0ff: hi, does someone here know the escape sequence for a blank? fuck0ff: hello? a blank ? fuck0ff: escape sequence like 't' for tab, and blank like the things you do between words. ? fuck0ff: it's for a c program fuck0ff: has the channel #programming anything to do with, like to program? MadSciFab: why do u need an escape sequence for a blank space? MakAtak: err.. is that what you call "space"? Bron:
Schrijf een applicatie met behulp van ReadLine en WriteLine()-methoden waarbij de computer aan de gebruiker om zijn favoriete kleur, eten, auto, film en boek vraagt. Het programma zal de antwoorden echter door elkaar halen waardoor de computer vervolgens toont: Je favoriete kleur is [eten]. Je eet graag [auto]. Je lievelingsfilm is [boek] en je favoriete boek is [kleur].
Waarbij tussen de rechte haakjes steeds de invoer komt die de gebruiker eerder opgaf voor de bijhorende vraag.
Maak het programma "grappig" door de antwoorden op de verkeerde plek te gebruiken "Zo, je favoriete kleur is The Lord of the Rings?!".
Kan je je programma van zonet aanpassen zodat iedere zin in een andere kleur is?
Bekijk de werking van Console.Write(). Kan je ieder woord in een andere kleur zetten?
Go nuts!
Het is aanbevolen dat je per hoofdstuk een nieuwe folder aanmaakt op je computer. Per oefening maak je dan best een nieuw project aan dat je in de folder zet. Geef ieder project een duidelijke naam (bv EuroNaarDollar) zodat je later vlot je oefeningen kan terugvinden. Denk er aan dat je je projecten best enkel met cijfers en letters benoemd (dus beter EuroNaarDollar dan Euro-Dollar).
Schrijf een programma dat de uitkomst van volgende resultaten op het scherm toont:
Test wat er gebeurt indien je het resultaat in een int bewaard en wat er gebeurt als je deze in een double bewaard. Toon beide uitkomsten (m.b.v. WriteLine) telkens op het scherm.
Opgelet: de % hier is de modulo-operator!
Maak 3 variabelen aan van het type int genaamd september, oktober en november. Plaats in elke variabele de hoeveelheid uren slaap je die maand verwacht te doen. Bereken nu het gemiddelde van 3 maanden en toon het resultaat op het scherm (kies uiteraard 3 verschillende hoeveelheden slaap).
Ontwerp een toepassing waarmee je een bedrag, inclusief komma-getallen in euro kan omrekenen naar dollar. Gebruik hierbij de huidige wisselkoers. Je hoeft niet af te ronden. Het resultaat op het scherm wordt als volgt weergegeven: [x] EUR is gelijk aan [y] USD.
Met het statement Console.Clear(); kan je de console - je raadt het nooit - leegmaken. Test deze code in het volgende programma:
Schrijf een programma dat de tafels van vermenigvuldigen geeft van 411 (dus 1x411= 411, 2x411= 822 tot en met 10x411= 4110). Toon telkens 1 zin en wacht dan tot de gebruiker op enter duwt om de volgende vermenigvuldiging op een nieuw scherm te tonen. De output ziet er dus als volgt uit:
Plaats 411 in een variabele aan de start van het programma en gebruik deze in je berekeningen verderop. Toon dat je code ook werkt door de inhoud van de variabele in een ander getal te veranderen zodat je van dat nieuwe getal nu de tafels van vermenigvuldiging krijgt.
Je kan wachten tot de gebruiker op enter duwt door gewoon een lege Console.ReadLine te doen, zoals volgende voorbeeld toont:
Merk op dat
Console.Clear()niet werkt zoals verwacht op Mac. (ik zoek nog een oplossing)
Maak twee variabelen double kills en double deaths aan. Wijs er jouw typische scores aan toe die je haalt in een spel naar keuze. Bereken en toon vervolgens je kill/death-ratio.
(opgelet: begrijp je waarom we best een van beide variabelen in double zetten? Lees de warning bij Expressies zeker nog eens na... OF test eens wat er gebeurt indien je met int zou werken).
Je massa is overal dezelfde. Je gewicht daarentegen is afhankelijk van de zwaartekracht van de plek waar je bent. Zo is je gewicht veel groter op Jupiter dan op Mars.
Maak een variabele double gewichtOpAarde aan. Wijs een gewicht toe (bv. het jouwe). Schrijf nu een programma dat onder elkaar jouw gewicht op verschillende planeten toont.
Hier de omzettingstabel (je gewicht op Mercurius is dus je gewicht op aarde x 0.38):
Mercurius: 0.38
Venus: 0.91
Aarde: 1.00
Mars: 0.38
Jupiter: 2.34
Saturnus: 1.06
Uranus: 0.92
Neptunus: 1.19
Pluto: 0.06 (we laten de discussie achterwege of pluto wel of niet een planeet is)
De output zijn verschillende lijnen onder elkaar in de vorm van:
Je weegt op [planeet] [gewichtopdieplaneet] kg.
Plaats de zin met Jupiter in het rood, daar je daar het zwaarst weegt en die van pluto in het groen.
Zonder expressies is programmeren saai: je kan dan enkel variabelen aan elkaar toewijzen. Expressies zijn als het ware eenvoudige tot complexe sequenties van bewerkingen die op 1 resultaat uitkomen. De volgende code is bijvoorbeeld een expressie: 3+2.
Het resultaat van deze expressie is 5. Meer informatie over expressies hier.
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 in C# zijn de welgekende 'wiskundige bewerkingen' zoals optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/). Deze volgen de wiskundige regels van volgorde van berekeningen:
Haakjes
Vermenigvuldigen: * en / (alsook % die we later zien)
Optellen: + en -
(etc.)
Net zoals in de wiskunde kan je in C# met behulp van de haakjes verplichten het deel tussen de haakjes eerst te doen, ongeacht de andere operators en hun volgorde van berekeningen:
Je kan nu complexe berekeningen doen door literals, operators en variabelen samen te voegen. Bijvoorbeeld om te weten hoeveel je op Mars zou wegen:
%De modulo operator die we in C# aanduiden met % verdient wat meer uitleg. Deze operator zal als resultaat de gehele rest teruggeven wanneer we het linkse getal door het rechtse getal delen:
De modulo-operator zal je geregeld gebruiken om bijvoorbeeld te weten of een getal een veelvoud van iets is. Als de rest dan 0 is weet je dat het getal een veelvoud is van het getal waar je het door deelde.
Bijvoorbeeld om te testen of getal even is gebruiken we %2:
Heel vaak wil je de inhoud van een variabele bewerken en dan terug bewaren in de variabele zelf. Bijvoorbeeld een variabele vermenigvuldigen met 10 en het resultaat ervan terug in de variabele plaatsen. Hiervoor zijn enkele verkorte notaties in C#. Stel dat we een variabele int getal hebben:
Je zal deze verkorte notatie vaak tegenkomen. Ze zijn identiek aan elkaar en zullen dus je code niet versnellen. Ze zal enkel compacter zijn om te lezen. Bij twijfel, gebruik gewoon de lange notatie.
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:
Let hier op!
But wait... it gets worse!
Wat als je een int door een int deelt? Het resultaat is terug een int. Je bent gewoon alle informatie na de komma kwijt. Kijk maar:
Er zal 4 op het scherm verschijnen! (niet 4.5 daar dat geen int is).
Wat als je datatypes mengt? Als je een berekening doet met een int en een double dan zal C# het 'grootste' datatype kiezen. In dit geval een double. Volgende code zal dus werken:
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.
Het kan subtiel en ambetant worden in grotere berekeningen.
Stel dat ik afspreek dat je van mij de helft van m'n salaris krijgt. Ik verdien (fictief)(wishfull thinking) 10000 euro per maand. Ik gebruik volgende formule:
Hoeveel krijg je van me? 0.0 euro, MUHAHAHAHA!!!
De volgorde van berekeningen zal eerst het gedeelte tussen de haakjes doen: 1 delen door 2 geeft 0, daar we een int door een int delen en dus terug een int als resultaat krijgen. Vervolgens zullen we deze 0 vermenigvuldigen met 10000.0 waarvan ik zo slim was om deze in double te zetten. Niet dus. We vermenigvuldigen weliswaar een double (het salaris) met een int maar die int is reeds 0 en we krijgen dus 0.0 als resultaat.
Wil je het dus eerlijk spelen dan zal je de formule moeten aanpassen naar:
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.
In het vorige hoofdstuk zagen we dat er verschillende soorten datatypes bestaan. Deze types hebben we nodig om variabelen aan te maken. De data die we in een programma gebruiken bewaren we namelijk in een variabele van een bepaald type. Een variabele is een plekje in het geheugen dat in je programma zal gereserveerd worden om daarin data te bewaren van het type dat je aan de variabele hebt toegekend. Een variabele zal intern een geheugenadres hebben (waar de data in het geheugen staat) maar dat zou lastig programmeren zijn indien je steeds dit adres moet gebruiken. Daarom moeten we ook steeds een naam oftewel identifier aan de variabele geven zodat we makkelijk de geheugenplek kunnen aanduiden.
De naam (identifier) van de variabele moet voldoen aan de identifier regels uit het vorige hoofdstuk.
Om een variabele te maken moeten we deze declareren, door een type en naam te geven. Vanaf dan zal de computer een hoeveelheid geheugen voor je reserveren waar de inhoud van deze variabele in kan bewaard worden. Hiervoor dien je minstens op te geven:
Het datatype (bv int, double).
Een identifier zodat de variabele uniek kan geïdentificeerd worden (volgens de naamgevingsregel van C#).
(optioneel) Een beginwaarde die de variabele krijgt bij het aanmaken ervan.
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:
Vanaf dit punt kunnen we dus ten allen tijde deze variabele gebruiken om een waarde aan toe te kennen, de bestaande waarde te overschrijven, of de waarde te gebruiken, zoals:
Waarde toekennen: mijnGetal= 15;. Toekenning gebeurt steeds van rechts naar links: het deel rechts van het gelijkheidsteken wordt toegewezen aan het deel links er van.
Waarde tonen op scherm: Console.WriteLine(mijnGetal);
Met de toekennings-operator (=) kan je een waarde toekennen aan een variabele. Hierbij kan je zowel een literal toekennen oftewel het resultaat van een expressie.
Je kan natuurlijk ook een waarde uit een variabele uitlezen en toewijzen aan een andere variabele:
Literals zijn expliciet ingevoerde waarden in je code. Als je in je code expliciet de waarde 4 wilt toekennen aan een variabele dan is het getal 4 in je code een zogenaamde literal. Wanneer we echter data bijvoorbeeld eerst uitlezen of berekenen (via bijvoorbeeld invoer van de gebruiker of als resultaat van een berekening) en het resultaat hiervan toekennen aan een variabele dan is dit geen literal.
Voorbeelden van een literal toekennen:
Het is belangrijk dat het type van de literal overeenstemt met dat van de variabele waaraan je deze zal toewijzen. Een string-literal (zie verder) stel je voor door aanhalingstekens. Volgende code zal dan ook een compiler-fout generen, daar je een string-literal aan een int-variabele wil toewijzen, en vice versa.
Als je bovenstaande probeert te compileren dan krijg je volgende error-boodschappen:
De manier waarop je een literal schrijft in je code zal bepalen wat het datatype van de literal is:
Gehele getallen worden standaard als int beschouwd, vb: 125.
Kommagetallen (met punt .) worden standaard als double beschouwd, vb: 12.5.
Via een suffix na het getal kan je aangeven als het om andere types gaat:
U of u voor uint, vb: 125U.
L of l voor long, vb: 125L.
UL of ul voor ulong, vb: 125ul.
F of f voor float, vb: 12.5f.
M of m voor decimal, vb: 12.5M.
Voor bool (zie verder) is dit enkel true of false.
Voor char (zie verder) wordt dit aangeduid met een enkele apostrof voor en na de literal, vb: 'q'.
Voor string (zie verder) wordt dit aangeduid met aanhalingsteken voor en na de literal, vb: "pikachu".
De overige types sbyte, short en ushort hebben geen literal aanduiding. Er wordt vanuit gegaan wanneer je een literal probeert toe te wijzen aan een van deze types dat dit zonder problemen zal gaan (ze worden impliciet geconverteerd).
Hexadecimale en binaire notatie
Je kan ook hexadecimale notatie (starten met 0x of 0X) gebruiken wanneer je bijvoorbeeld met int of byte werkt:
Ook binaire notatie (starten met 0b of 0B) kan:
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.
Een essentieel onderdeel van C# is kennis van datatypes. Binnen C# zijn een aantal types gedefinieerd die je kan gebruiken om data in op te slaan. Wanneer je data wenst te bewaren in je applicatie dan zal je je moeten afvragen wat voor soort data het is. Gaat het om een getal, een geheel getal, een kommagetal, een stuk tekst of misschien een binaire reeks? Ieder datatype in C# kan één welbepaald soort data bewaren en dit zal telkens een bepaalde hoeveelheid computergeheugen vereisen.
Er zijn tal basistypes in C# gedeclareerd (zogenaamde primitieve datatypes). Dit semester leren we werken met datatypes voor:
Gehele getallen: sbyte, byte, short, ushort, int, uint, long
Kommagetallen: double, float, decimal
Tekst: char, string
Booleans: bool
Het datatype
stringheb je al gezien in het vorig hoofdstuk. Je hebt toen al een variabele aangemaakt van het type string door de zinstring result;. Verderop plaatsen we dan iets waar de gebruiker iets kan intypen in die variabele (toekenning in C# gaat van rechts naar links):result = Console.ReadLine();.
Alhoewel een computer digitaal werkt en enkel 0'n en 1'n bewaard zou dat voor ons niet erg handig werken. C# heeft daarom een hoop datatypes gedefinieerd om te werken met getallen zoals wij ze kennen, gehele en kommagetallen. Intern zullen deze getallen nog steeds binair bewaard worden, maar dat is tijdens het programmeren zelden een probleem.
Onthoudt echter dat onderaan je programma steeds hardware zal draaien die binair werkt.
De basistypen van C# om getallen in op te slaan zijn:
Voor gehele getallen: sbyte, byte, short, ushort, int, uint, long
Voor kommagetallen: double, float, decimal
Ieder type hierboven heeft een bepaald bereik en hoeveelheid geheugen nodig. Je zal dus steeds moeten afwegen wat je wenst. Op een high-end pc met ettelijke gigabytes aan werkgeheugen (RAM) is geheugen zelden een probleem waar je rekening mee moet houden...Of toch: zoals met real-time shooters die miljoenen berekeningen (3D) per seconde moeten uitvoeren. Daar zal iedere byte tellen. Op andere apparaten (smartphone, arduino, smart fridges, etc.) is iedere byte geheugen nog kostbaarder. Kortom: kies steeds bewust het datatype dat het beste 'past' voor je probleem qua bereik, precisie en geheugengebruik.
Deze datatypes hebben allemaal een bepaald bereik, wat een rechtstreeks gevolg is van de hoeveelheid geheugen die ze innemen.
Voor de gehele getallen:
We raden aan dat je de 'info' urls bekijkt om te ontdekken hoe je de literals van datatypes moet schrijven in C#.
Enkele opmerkingen bij deze tabel:
De s vooraan sbyte types staat voor signed: m.a.w. 1 bit wordt gebruikt om het + of - teken te bewaren.
De u vooraan ushort, uint en ulong staat voor unsigned. Het omgekeerde van signed dus. Kwestie van het ingewikkeld te maken. Deze twee datatypes hebben dus geen teken en zijn altijd positief.
char bewaard karakters. We zullen verderop dit datatype uitspitten en ontdekken dat karakters (alle tekens op het toetsenbord, inclusief getallen, leesteken, etc.) als gehele, binaire getallen worden bewaard. Daarom staat char in deze lijst.
Het grootste getal bij long is 2 tot de 63ste (
negen triljoen tweehonderddrieëntwintig biljard driehonderd tweeënzeventig biljoen zesendertig miljard achthonderdvierenvijftig miljoen zevenhonderdvijfenzeventigduizend achthonderd en zeven). Dit zijn maar 63 bits?! Inderaad, de laatste bit wordt gebruikt om het teken te bewaren.
Voor de kommagetallen zijn er maar 3 mogelijkeden. Ieder datatype heeft een 'voordeel' tegenover de 2 andere, dit voordeel staat vet in de tabel:
Zoals je ziet moet je bij kommagetallen een afweging maken tussen 3 even belangrijke criteria. Heb je ongelooflijk grote precisie nodig dan ga je voor een decimal. Wil je vooral erg grote of erg kleine getallen kies je voor double. De precisie van een getal is het aantal beduidende of significante cijfers. Het getal 12,45 heeft een precisie van 4. Zoals je merkt zal je dus zelden decimal nodig hebben, deze zal vooral nuttig zijn in wetenschappelijke programma's waar met erg exacte cijfers moet gewerkt worden.
Bij twijfel opteren we meestal voor kommagetallen om het
doubledatatype te gebruiken. Bij gehele getallen kiezen we meestal voorint.
Het bool (boolean) is het eenvoudigste datatype van C#. Het kan maar 2 mogelijke waarden bevatten: true of false. 0 of 1 met andere woorden.
Het gebeurt vaak dat beginnende programmeurs een int variabele gebruiken terwijl ze toch weten dat de variabele maar 2 mogelijke waarden zal hebben. Om dus geen onnodig geheugen te verbruiken is het aan te raden om in die gevallen steeds met een bool variabele te werken.
We zullen het bool datatype erg veel nodig hebben wanneer we met beslissingen zullen werken, specifiek de if statements die afhankelijk van de uitslag van een bool bepaalde code wel of niet zullen doen uitvoeren.
We besteden verderop een heel apart hoofdstuk aan tonen hoe je tekst en enkele karakters kan bewaren in variabelen. Sneak preview:
Tekst kan bewaard worden in het string datatype
Een enkel karakter wordt bewaard in het char datatype dat we ook hierboven al even hebben zien passeren.
Meer info vind je later in dit hoofdstuk.
Je code kan niet gecompileerd en uitgevoerd worden zolang er fouten in je code staan (dit bespraken we reeds in een eerder hoofdstuk).
Indien je op de groene start knop duwt en volgende waarschuwing krijgt KLIK DAN NOOIT OP YES EN DUID NOOIT DE CHECKBOX AAN:
De eerste die dit wél doet trakteert de hele klas als ik dit ontdek.
Lees de boodschap eens: wat denk je dat er gebeurt als je op 'yes' duwt? Inderdaad, VS zal de laatste goed gelukte code uitvoeren en dus niet de code die je nu hebt staan waarin nog fouten staan.
Zolang er dus fouten in je code staan moet je deze eerst oplossen voor je verder kan. Gelukkig helpt VS je daarmee op 2 manieren:
Fouten in code worden met een rode squigly onderlijnt.
Onderaan zie je in de statusbalk of je fouten hebt.
Uiteraard ga je vaak code hebben die meerdere schermen omvat. Je kan via de error-list snel naar al je fouten gaan. Open deze door op het error-icoontje onderaan te klikken:
In deze list kan je nu op iedere error klikken om ogenblikkelijk naar de correcte lijn te gaan.
Wanneer je je cursor op een lijn met een fout zet dan zal je soms vooraan een geel error-lampje zien verschijnen:
Je kan hier op klikken en heel vaak krijg je dan ineens een mogelijke oplossing. Wees steeds kritisch hierover want VS is niet alomwetend en kan niet altijd raden wat je bedoelt. Neem dus het voorstel niet zomaar over zonder goed na te denken of het dat was wat je bedoelde.
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 (je mag enkel binnen de accolades van Main schrijven).
Om een werkend C#-programma te maken moeten we de C#-taal beheersen. Net zoals iedere taal, bestaat ook C# uit enerzijds grammatica, in de vorm van de C# syntax en anderzijds vocabulair in de vorm van de te gebruiken keywords.
Een C#-programma bestaat uit een opeenvolging van instructies ook wel statements genoemd. Deze eindigen steeds met een puntkomma (;) (zoals ook in het Nederlands een zin eindigt met een punt).
De volgorde van de woorden (keywords, variabelen, etc.) zijn niet vrijblijvend en moeten aan (grammaticale) regels voldoen. Enkel indien alle statements correct zijn zal het programma gecompileerd worden naar een werkend en uitvoerbaar programma (zoals in een vorige sectie besproken).
Enkele belangrijke regels van C#:
Hoofdletter-gevoelig: C# is hoofdlettergevoelig. Dat wil zeggen dat hoofdletter T en kleine letter t totaal verschillende zaken zijn voor C#. Reinhardt en reinhardt zijn dus ook niet hetzelfde.
Statements afsluiten met puntkomma: Iedere C# statement wordt afgesloten moet een puntkomma ( ; ). Doe je dat niet dan zal C# denken dat de regel gewoon op de volgende lijn doorloopt en deze als één (fout) geheel proberen te compileren.
Witruimtes: Spaties, tabs en enters worden door de C# compiler genegeerd. Je kan ze dus gebruiken om de layout van je code (bladspiegel zeg maar) te verbeteren. De enige plek waar witruimtes wél een verschil geven is tussen aanhalingstekens " " die we later (bij string) zullen leren gebruiken.
Commentaar toevoegen kan: met behulp van // voor een enkele lijn en /* */ voor meerdere lijnen commentaar. Alles dat in commentaar staat zal door de compiler genegeerd worden.
C# bestaat zoals gezegd niet enkel uit grammaticale regels. Grammatica zonder woordenschat is nutteloos. Er zijn binnen C# dan ook 80 woorden, zogenaamde reserved keywords die de woordenschat voorstellen. In deze cursus zullen we stelselmatig deze keywords leren kennen en gebruiken op een correcte manier om zo werkende code te maken.
Deze keywords zijn:
De keywords in vet zijn keywords die we dit semester zullen kennen. Die in cursief in het tweede semester. De overige zal je zelf moeten leren ;).
(indien je deze tabel in pdf bekijkt zal deze om zeep zijn. Onze gitbook gnomes proberen dit op te lossen maar voorlopig vinden we helaas geen oplossing, waarvoor onze excuses)
We hebben variabelen nodig om (tijdelijke) data in op te slaan. Wanneer we een statement schrijven dat bijvoorbeeld input van de gebruiker moet vragen, dan willen we ook die input bewaren zodat we verderop in het programma (het algoritme) iets met deze data kunnen doen. We doen hetzelfde in ons hoofd wanneer we bijvoorbeeld zegen "tel 3 en 4 op en vermenigvuldig dat resultaat met 5". Eerst zullen we het resultaat van 3+4 in een variabele moeten bewaren. Vervolgens zullen we de inhoud van die variabele vermenigvuldigen met 5 en dat nieuwe resultaat ook in een nieuwe variabele opslaan (om vervolgens bijvoorbeeld naar het scherm te sturen).
Wanneer we een variabele aanmaken zal deze moeten voldoen aan enkele afspraken. Zo moeten we minstens 2 zaken meegeven:
Het type van de variabele: het datatype dat aangeeft wat voor data we wensen op te slaan (tekst, getal, afbeelding, etc.).
De naam van de variabele: de identifier waarmee we snel aan de variabele-waarde kunnen.
De verschillende datatypes bespreken we in een volgend hoofdstuk.
De code die we gaan schrijven moet voldoen aan een hoop regels. Wanneer we in onze code zelf namen (identifiers) moeten geven aan variabelen (en later ook methoden, objecten, etc.) dan moeten we een aantal regels volgen:
Hoofdlettergevoelig: de identifiers tim en Tim zijn verschillend zoals reeds vermeld.
Geen keywords: identifiers mogen geen gereserveerde C# keywords zijn. De keywords van hierboven mogen dus niet. Varianten waarbij de hoofdletters anders zijn mogen wel, bijvoorbeeld: gOTO en stRINg mogen dus wel, maar niet goto of string daar beide een gereserveerd keyword zijn maar dankzij de hoofdlettergevoelig-regel is dit dus toegelaten. INT mag ook ook, maar niet int.
Eerste karakter-regel: het eerste karakter van de identifier mag enkel zijn:
kleine of grote letter
liggend streepje (_)
Alle andere karakters: de overige karakters mogen enkel zijn:
kleine of grote letter
liggend streepje
een cijfer (0 tot en met 9)
Lengte: Een legale identifier mag zo lang zijn als je wenst, maar je houd het best leesbaar.
Enkele voorbeelden van toegelaten en niet toegelaten identifiers:
Er zijn geen vaste afspraken over hoe je je variabelen moet noemen toch hanteren we enkele coding guidelines die doorheen je opleiding moeten gevolgd worden. Naarmate we meer C# leren zullen er extra guidelines bijkomen (zie deze appendix voor alle guidelines van de opleiding).
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.
Soms wil je misschien extra commentaar bij je code zetten. Als je dat gewoon zou doen (bv Dit deel zal alles verwijderen) dan zal je compiler niet begrijpen wat die zin doet. Hij verwacht namelijk C# en niet een Nederlandstalige zin. Om dit op te lossen kan je in je code op twee manieren aangeven dat een stuk tekst gewoon commentaar is en mag genegeerd worden door de compiler:
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).
We kunnen een stuk tekst als commentaar aangeven door voor de tekst /* te plaatsen en */ achteraan. Een voorbeeld:
Verkorte notatie
Lange notatie
Beschrijving
getal++;
getal= getal+1;
variabele met 1 verhogen
getal--;
getal= getal-1;
variabele met 1 verlagen
getal+=3;
getal= getal+3;
variabele verhogen met een getal
getal-=6;
getal= getal-6;
variabele verminderen met een getal
getal*=7;
getal= getal*7;
variabele vermenigvuldigen met een getal
getal/=2;
getal= getal/2;
variabele delen door een getal
Type
Geheugen
Bereik
Meer info
sbyte
8 bits
-128 tot 127
byte
8 bits
0 tot 255
short
16 bits
-32768 tot 32767
ushort
16 bits
0 tot 65535
int
32 bits
-2 147 483 648 tot 2 147 483 647
uint
32 bits
0 tot 4294967295
long
64 bits
-9 223 372 036 854 775 808 tot 9 223 372 036 854 775 807
ulong
64 bits
0 tot 18 446 744 073 709 551 615
char
16 bits
0 tot 65535
Type
Geheugen
Bereik
Precisie
float
32 bits
±1.5 x 10-45 to ±3.4 x 1038
7 digits
double
64 bits
±5.0 x 10-324 to ±1.7 x 10308
15 digits
decimal
128 bits
±1.0 x 10-28 to ±7.9228 x 1028
28-29 digits
abstract
as
base
bool
break
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
do
double
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
goto
if
implicit
in
int
interface
internal
is
lock
long
namespace
new
null
object
operator
out
override
params
private
protected
public
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
using static
virtual
void
volatile
while
identifier
toegelaten?
uitleg indien niet toegelaten
werknemer
ja
kerst2018
ja
pippo de clown
neen
geen spaties toegestaan
4dPlaats
neen
mag niet starten met getal
_ILOVE2019
ja
Tor+Bjorn
neen
enkel cijfers, letters en liggende streepjes toegestaan
ALLCAPSMAN
ja
B_A_L
ja
class
neen
gereserveerd keyword
WriteLine
ja
