8min

Tags in dit artikel

, , ,

De eerste stapjes

Nu je een project hebt aangemaakt kom je in de werkomgeving terrecht:



Ik zal bij deze eerste tutorial nog niet ingaan op wat using System, namespace, class, etc. inhoudt. Als eerst de basis.

Compileren

Voor het maken van een programma schrijven we een stuk code. Bij het compileren gaat de compiler van Visual C# Express de code controleren en omzetten naar een uitvoerbaar bestand (executable , oftewel een .exe). Als er fouten in het programma zitten, zoals syntax (schrijf) fouten, verwijzingen die niet kloppen (je roept iets aan wat niet bestaat) enz. zal daar een melding van worden gemaakt, en de actie worden afgebroken.

Commentaar

Als eerst het volgende; programmeurs schrijven commentaar tussen de code om medeprogrammeurs (als die aan het programma meewerken), of je zelf als je later weer terug kijkt, te herinneren wat er bedoelt wordt met de code. Commentaar wordt niet meegenomen in het eindprogramma, de executable file die later wordt gecompileerd.

Commentaar kan je op 2 manieren aangeven in C#:
– Twee maal een ‘forward slash’ te gebruiken (//). De compiler zal dan zien dat de rest van die regel commentaar is. Je zou ook commentaar met // na een commando kunnen zetten (bijvoorbeeld je hebt een variabele gedefineerd), maar dat is ongebruikelijk. Het leest duidelijker om commentaar boven de regels code te zetten. Met // kan je maar 1 regel tegelijk met commentaar voorzien.

– Het commentaar tussen /* en */ te zetten. /* geeft aan dat een stuk commentaar begint. Je kan dan meerdere regels overbruggen. */ geeft aan dat het stukje commentaar geëindigd is.

Voor de scripters onder ons; het is niet mogelijk het hekje (#-teken) te gebruiken voor commentaar. In C# heeft deze een andere betekenis.

Variabelen

Variabelen zijn de plekken waar informatie wordt opgeslagen. Je kan dan een stukje informatie een naam geven; bijvoorbeeld een variabele Kisten welke de informatie bijvoorbeeld 20 bevat. Het is dan mogelijk om via die naam de waarde weer te benaderen en verder te gebruiken (voor een berekening, een vergelijking , enzovoort).

In C# is het belangrijk om op te merken dat er verschillenden soorten informatie zijn:
  • Bool – Staat voor Boolean, wat wil zeggen ‘waar of niet waar’; in engels True of False.
  • Int – Staat voor Integer, wat geheel getal betekent. Een normale integer telt van -2,147,483,648 t/m 2,147,483,647. In C# is een int standaard 32-bits. Je kan ook int16 of int64 gebruiken; waarbij int16 -32,768 t/m 32,767 telt. Int64 gaat tot circa 19 decimalen.
  • Uint – Staat voor Unsigned Integer; weer een geheel getal maar unsigned. Dat wil zeggen dat het niet negatief kan worden. Bij Integer ligt de helft van het getal bereik onder 0; bij uint kan je dus dubbel zo hoog boven nul tellen. Ook uint16 en uin64 bestaan.
  • Char – Staat voor Character, wat 1 karakter moet voorstellen. Dat is dus een teken.
  • String – Staat voor reeks van tekens.
  • Float – Een comma getal. Dit is een ‘single precision’ floating point type; wat wil zeggen dat het vaak een benadering is. Een proccesor kan hier echter wel zeer efficient mee rekenen, en neemt relatief weinig geheugen in beslag (4 bytes).
  • Double – Een comma getal, maar dan met double precision. Deze getallen zijn exacter, en als je echt exact wil rekenen zal je deze eerder gebruiken. Het gebruikt wel dubbel zoveel geheugen (8 bytes); maar in dit geval nog niet van belang.


Een paar voorbeelden:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
/* Een integer KistenMetAppels. Daar wordt waarde 20 ingezet. Het 
enkele gelijkteken  staat voor 'wordt gelijk aan'. Later niet te 
verwarren met dubbele gelijkteken , welke staat voor 'is gelijk aan'.
*/
int KistenMetAppels = 20;
 
// Het is ook mogelijk om gewoon een integer te noemen, maar nog geen 
// waarde te geven. We 'reserveren' dan de naam Aantal.
int Aantal;
 
// Een float fGewicht. Hier wordt 1.76 ingezet. De f er achter is nodig
// omdat dit een float betreft.
float fGewicht = 1.76f;
 
// Een double dGewicht . Hier wordt ook 1.76 ingezet.
double dGewicht = 1.76;
 
// Een string Soort, oftewel letterreeks. De tekst die je wil schrijven
// zet je tussen double quotes:
string Soort = "Goldstar";
 
// Een char Karakter. Deze mag maar 1 karakter bevatten. Een karakter
// zet je tussen single quotes:
char Karakter= 'P';
 
// Een boolean Oud en Jong. Er zijn voor dit type maar twee waarden;
// true of false. 
bool Oud = false;
bool Jong = true;


Het afsluiten van een commando doe je altijd met een semicolon. In dit geval is het commando wat elke keer is geschreven, het aanmaken van een variabele. C# zal dan een stukje geheugen reserveren.

Echter hebben we niks aan een variabele als we die niet kunnen gebruiken. Ik heb net gezegd dat KistenMetAppels gelijk is aan 20. Stel dat er per Kist 50 appels zitten. Het is dan mogelijk om in de variabele Aantal (merk op; die hebben we gedefineerd maar geen waarde gegeven) het totaal aantal appels te zetten:

CSHARP Code
1
2
3
4
5
 
int KistenMetAppels = 20;
int Aantal;
 
Aantal = KistenMetAppels * 50;


Uiteraard kan dit ook:

CSHARP Code
1
2
3
 
int KistenMetAppels = 20;
int Aantal = KistenMetAppels * 50;


Het aantal is nu gelijk aan 50 maal de waarde van KistenMetAppels. Het asterik (het sterretje) geeft aan dat er een vermedigvuldiging plaats vindt. Er zijn nog meer typen:

  • + : Optellen. Als Aantal = KistenMetAppels + 500; wordt genomen, zal Aantal dus 20+500 = 520 zijn.
  • – : Aftrekken. Als Aantal = KistenMetAppels – 5; wordt genomen, zal Aantal dus 20-5= 15 zijn.
  • / : Delen. Als Aantal = KistenMetAppels / 4; wordt genomen zal Aantal dus 20/4 = 5 zijn. Merk op dat in dit geval met integers alles wordt afgerond naar gehele getallen. Dus Aantal = KistenMetAppels / 40; levert niet 0,5 op, maar 0!
  • * : Vermedigvuldigen. Zie het voorbeeld hierboven
  • % : Rest nemen. Als Aantal = KistenMetAppels % 8; wordt genomen, zal 8 zo vaak mogelijk er geheel uitgehaald worden. Wat overblijft wordt dan Aantal. In dit geval past 8 precies 2 maal in 20. 2×8 = 16, dus 20-16 = 4.


Alternatieve schrijfwijzen met variabelen

Naast de ‘standaard’ schrijfwijze om een nieuwe waarde aan een variabele toe te kennen zijn er nog varianten. Deze vloeien voort uit simpele instructies die regelmatig worden gedaan. Ik zal er hier een paar voordoen:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int Getal = 0;
 
// Het getal met 1 ophogen
Getal++;
 
// Het getal met 1 verlagen
Getal--;
 
// Het getal met 10 verhogen
Getal += 10;
 
// Het gethal met 5 verlagen
Getal -= 5;
 
// Het getal met 4 vermedigvuldigen
Getal *= 4;
 
// Het getal delen door 2
Getal /= 2;



Uitvoer naar de gebruiker

We hebben nu het aantal appels uitgerekend , maar dit moet wel aan de gebruiker worden laten zien. Het is mogelijk om Console.Write() of Console.WriteLine() een tekst in het console scherm te laten zien. Het verschil tussen Write en WriteLine is dat WriteLine altijd na je tekst naar de volgende regel springt. Een voorbeeld:

CSHARP Code
1
2
3
4
5
6
7
 
int KistenMetAppels = 20;
int Aantal = KistenMetAppels * 50;
Console.Write("Het aantal kisten met appels is: ");
Console.WriteLine(KistenMetAppels);
Console.Write("Het aantal appels wat in de kisten zich bevindt is: ");
Console.WriteLine(Aantal);


Quote:

Het aantal kisten met appels is: 20
Het aantal appels wat in de kisten zich bevindt is: 1000


Als je dit programma test in je eigen omgeving zal waarschijnlijk heel vlug even een console scherm te voorschijn komen, en meteen weer afsluiten. Dat komt omdat na de laatste regel van schrijven het programma al afgelopen is. Windows sluit dan het programma direct af.

Een manier om het venster te laten staan, totdat de gebruiker bijvoorbeeld op enter drukt of slechts op een toets kan met Console.ReadLine(); of ReadKey():

CSHARP Code
1
2
Console.WriteLine("Druk op een toets om het programma af te sluiten.");
Console.ReadKey();

Of:
CSHARP Code
1
2
Console.WriteLine("Druk op ENTER om het programma af te sluiten.");
Console.ReadLine();


Zodadelijk zullen we de daadwerkelijk bedoelde manier gebruiken maken van ReadLine(). In dit geval maken we misbruik van het feit dat ReadKey() op een toetsdruk wacht, en ReadLine() op een enter aanslag. Wat deze functie als uitvoer geeft doen we niets mee.

Invoer van de gebruiker

Het zou praktisch zijn als een programma ook invoer van de gebruiker kan nemen. In een console applicatie kan dat vrij simpel door:

CSHARP Code
1
string Invoer = Console.ReadLine();


Hier wordt gebruik gemaakt van de functie ReadLine uit Console. Een functie is een stuk code wat bij elkaar gevoegd is en een naam gegeven is. Wat achter ReadLine zit is in dit geval niet van belang. Het gaat er hier om dat wanneer die functie wordt aangeroepen er een regel van het scherm wordt gelezen, wat de gebruiker invoert.

Een functie heeft vaak een uitvoer; in dit geval is dat een string. Deze waarde van deze string is wat de gebruiker in het console scherm heeft getikt. Deze waarde zetten we in Invoer. Het is vaak zo dat invoeren in C# worden ingelezen als een String.

Terug naar het voorbeeld van net; het rekenen met kisten appels. Stel dat we de gebruiker graag willen opvragen hoeveel kisten appels die heeft; dan kan dat als volgt:

CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int KistenMetAppels, Aantal;
string Invoer;
 
Console.WriteLine("Hoeveel kisten appels heeft u?");
Invoer = Console.ReadLine();
 
// Invoer is een String en per definitie hoeft dat geen getal te zijn. Sterker nog, met een string is het niet omgelijk daar getalswijs mee te rekenen. Dit moet worden omgezet naar een Integer:
KistenMetAppels = Convert.ToInt32(Invoer); 
// ook omgelijk is:
// KistenMetAppels = Int32.Parse(Invoer);
 
Aantal = KistenMetAppels * 50;
 
// De gebruiker het resultaat tonen.
Console.Write("Het aantal kisten met appels is: ");
Console.WriteLine(KistenMetAppels);
Console.Write("Het aantal appels wat in de kisten zich bevindt is: ");
Console.WriteLine(Aantal);
 
// Wachten op de enter toets..
Console.WriteLine("Druk op ENTER om het programma af te sluiten.");
Console.ReadLine();


Stel dat we nu ook willen vragen hoeveel appels er per keer in een kist zitten. Ook willen we het gewicht van het geheel aangeven. Een appel weegt 0.1kg.

We hebben dus een variabele nodig voor het aantal appels per kist, en een variabele waar in staat hoe zwaar alles weegt. Ook moeten we nu inlezen hoeveel appels er per kist in zitten:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
// Reserveren deze variabele namen:
int KistenMetAppels, Aantal, AppelsPerKist;
string Invoer;
double Gewicht;
 
Console.WriteLine("Hoeveel kisten appels heeft u?");
Invoer = Console.ReadLine();
 
// Invoer omzetten naar een Integer
KistenMetAppels = Convert.ToInt32(Invoer); 
 
// Lezen nu uit hoeveel appels er per kist in zitten:
Console.WriteLine("Hoeveel appels bevinden er zich in 1 kist?");
 
// We kunnen hergebruik maken van Invoer. Wat voorheen in Invoer stond, wordt verwijderd:
Invoer = Console.ReadLine();
 
// De invoer omzetten, maar nu naar AppelsPerKist
AppelsPerKist = Convert.ToInt32(Invoer);
 
// De berekening is nu volledig afhankelijk van de invoer van de gebruiker;
Aantal = KistenMetAppels * AppelsPerKist;
 
// Het gewicht is 0,1kg per appel. Dus 0,1kg maal het aantal appels is het totale gewicht:
Gewicht = 0.1 * Aantal;
 
// De gebruiker het resultaat tonen.
Console.Write("Het aantal kisten met appels is: ");
Console.WriteLine(KistenMetAppels);
Console.Write("Het aantal appels per kist is: ");
Console.WriteLine(AppelsPerKist);
Console.Write("Het aantal appels wat in de kisten zich bevindt is: ");
Console.WriteLine(Aantal);
Console.Write("De appels los wegen ongeveer: ");
Console.Write(Gewicht);
Console.WriteLine("kg");
 
// Wachten op de enter toets..
Console.WriteLine("Druk op ENTER om het programma af te sluiten.");
Console.ReadLine();


Quote:

Hoeveel kisten appels heeft u?
3
Hoeveel appels bevinden er zich in 1 kist?
9
Het aantal kisten met appels is: 3
Het aantal appels per kist is: 9
Het aantal appels wat er zich in de kisten bevindt is: 27
De appels los wegen ongeveer: 2.7kg
Druk op ENTER om het programma af te sluiten.

Table of contents