Cursus c#: variabelen, operatoren en expressies

Een statement is een opdracht die een actie uitvoert. Meerdere statements kunnen gegroepeerd worden in methoden.
Statements volgen in C# een set strikte regels die hun opbouw beschrijven. Deze regels worden algemeen syntax genoemd. Een fout tegen de syntactische regels van een programmeertaal is dan een 'syntax error'. Eén van deze syntaxregels is het feit dat een statement steeds gevolgd wordt door een ; (puntkomma / semicolon).
Voorbeeld van een statement:

Console.WriteLine("Hello World");

Elementen zoals namespaces, klassen, methoden, variabelen (zie later), controls krijgen in C# een naam.
De naam die je aan een element geeft noemen we de identifier.
Een identifier moet aan volgende regels voldoen

Enkel letters (kleine en hoofdletters), cijfers en het teken _ (underscore) zijn toegelaten
Het eerste teken mag geen cijfer zijn
C# is hoofdlettergevoelig: resultaat is niet gelijk aan Resultaat
C# reserveert een aantal woorden voor intern gebruik, deze kan je niet opnieuw gebruiken als identifier.
Een lijst van dergelijke sleutelwoorden vind je bij MSDN. (Microsoft developers network)

Variabelen gebruiken

Een variabele is een opslagruimte die een waarde kan bevatten. Je kan een variabele zien als een plekje geheugen dat je een naam hebt gegeven. Dit geheugenplekje bevat informatie die gewijzigd kan worden in de loop van het programma.
Tijdens het programmeren zal je veelvuldig gebruik maken van variabelen.

Variabelen benoemen

Een variabele wordt steeds aangesproken met de naam. Het is belangrijk dat je voor jezelf een goede manier ontwikkelt om variabelen een naam te geven. Niets is zo vervelend als programmacode te moeten lezen die krioelt van variabelenamen zoals a, b, c, ... of getal1, getal2, getal3, ... .
Bij het lezen van dergelijke code moet je je als programmeur steeds gaan afvragen wat de variabele bevat. Veel duidelijker zijn variabelenamen zoals aankoopBedrag, verkoopBedrag, winst, btwBedrag, totaal, ...
Vaak wordt bij naamgeving van variabelen volgende regeltjes toegepast (dit is geen verplichting, veeleer een afspraak):

Begin een variabelenaam niet met een hoofdletter
Gebruik camelCase notatie: start bij namen die bestaan uit meerdere woorden elk woord met een hoofdletter (niet het eerste), alle andere letters zijn kleine letters.
Gebruik geen Hongaarse notatie: een (vroeger) veel gebruikt manier om variabelen een naam te geven, waarbij aan de naam een prefix werd geschreven die duidt op het type van de variabele.

Variabelen declareren

Variabelen houden waarden vast. C# heeft vele verschillende types van waarden die het kan opslaan en verwerken: gehele getallen (integers), kommagetallen (floating-point numbers), tekst (strings), tekens (character), ...
Bij het declareren van een variabele geef je aan welk type gegevens de variabele zal gaan opslaan.
Het aangeven van het type en de naam van een variabele doe je in het declaratie-statement:

int age;

Hier declareer je een variable met de naam age van het type integer (geheel getal).

Merk nogmaals op dat elk statement eindigt met een punt-komma.
Het type int is één van de primitieve datatypes binnen C#. (meer hierover verderop)
In C# ben je verplicht elke variabele te declareren vooraleer je deze gebruikt!
Nadat je een variabele hebt gedeclareerd kan je deze een waarde toewijzen:
```
age = 42;
```
Het gelijkheidsteken is in C# de toekenningsoperator: je kent de waarde 42 toe aan de variabele age.
Je kan in C# een variabele declareren en initialiseren (een initiële waarde toekennen) in 1 coderegel:
```
int age = 42;
```

Voorbeeld:

Pas de methode ok_Click in het project WpfHello2 aan:

private void ok_Click(object sender, RoutedEventArgs e)
{
	string name = userName.Text;
	name = name.ToUpper();
	MessageBox.Show("Hallo " + name);
}

We declareren een string met de naam name. We initialiseren deze string met de waarde van de eigenschap Text van de control userName: de TextBox.

string name = userName.Text;

We kennen aan de variabele name de waarde toe van de variabele name waarop de methode ToUpper werd toegepast: alle letters worden hoofdletters:

name = name.ToUpper();

C# heeft een aantal ingebouwde types die we primitieve datatypes noemen:

data type	omschrijving	grootte (bits)	bereik	voorbeeld
int	gehele getallen	32	-2³¹ tot 2³¹	int count; count = 42;
long	gehele getallen	64	-2⁶³ tot 2⁶³	long wait; wait = 42L;
float	kommagetallen (pos / neg)	32	1,5 x 10^-45 tot 3,4 x 10³⁸	float test; test = 0.42F;
double	Preciezere kommagetallen (pos / neg)	64	5 x 10^-324 tot 1,7 x 10³⁰⁸	double trouble; trouble = 0.42;
decimal	Geldbedragen	128	28 betekenisvolle cijfers	decimal coin; coin = 0.42M;
string	tekenreeks	16 bits / teken	nvt	string auto; auto = "Honda";
char	1 teken	16	0 tot 2¹⁶ - 1	char geslacht; geslacht = 'V';
bool	booleaanse waarde: waar / onwaar	8	Waar / onwaar ( 0 / 1)	bool gevonden; gevonden = false;

In C# krijg je een compile-time error wanneer je een niet toegekende variabele wenst te gebruiken:

string myName;
MessageBox.Show("Hallo " + myName);

Levert volgende fout: Use of unassigned local variable 'myName'

C# ondersteunt sinds versie 3 ook het gebruik van het sleutelwoord var voor het declareren van variabelen:

   var mijnIntVar = 5;
   var mijnStringVar = "Hallo";

Nu gaat het .Net Framework na initialisatie zelf het type toekennen.
Een variabele gedeclareerd met var moet onmiddellijk geïnitialiseerd worden.

operator	beschrijving	voorbeeld
+	optellen	int som; som = 5 + 3;
-	aftrekken	int verschil; verschil = 5 - 3;
*	vermenigvuldigen	int product; product = 5 * 3;
/	delen	double quotient; quotient = 5 / 3;
%	rest bij gehele deling (modulo)	int rest; rest = 5 % 3;
++	verhoog met 1	int i; i = 1; i++;
--	verminder met 1	int i; i = 10; i--;

Maak een nieuwe Solution Variabelen aan in Visual Studio: File > New > Project...
Maak een nieuw project WpfWiskOperatoren aan:
Sleep vanuit de ToolBox een ListBox binnen de Grid van het WPF-Window.
Een ListBox kan je in WPF gebruiken om een lijst van waarden weer te geven. Wij willen in onze toepassing een aantal zinnetjes onder elkaar op het scherm tonen.
Verwijder de waarde voor de eigenschap Margin, HorizontalAlignement en VerticalAlignement. De ListBox vult nu het volledige Window.
Geef de ListBox de naam bewerkingen
```
<ListBox Name="bewerkingen" />
```

In de XAML-code zien we dit:

<Window x:Class="WpfWiskOperatoren.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ListBox Name="bewerkingen"   />
    </Grid>
</Window>

Selecteer het Window MainWindow, activeer het venster Properties (F4) en klik het tabblaadje Events.
Druk naast het event Loaded op enter, of dubbelklik:

De methode Window_Loaded zal uitgevoerd worden wanneer het Window volledig geladen is.
De programmacode die we schrijven voor het event Loaded van een Window zal dus meteen uitgevoerd worden als het Window geladen (opgestart) wordt.
In Window1.xaml.cs werd nu volgende code automatisch voorzien:
```
private void Window_Loaded(object sender, RoutedEventArgs e)
{
	
}
```
De methode Window_Loaded.

Voeg volgende code toe, gebruik waar mogelijk intellisense van Visual Studio:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
	bewerkingen.Items.Add("Optelling: 29 + 7 = " + (29 + 7));
}

Voer de toepassing uit:

bewerkingen is de naam van de ListBox die we in het Window hebben geplaatst. Een ListBox kan een lijst van elementen op het scherm tonen. Een ListBox kunnen we in de code aanspreken met zijn naam.
De eigenschap Items van de ListBox bewerkingen bevat de elementen die in de ListBox aanwezig zijn (ItemCollection). Met de methode Add van de ItemCollection kunnen we een element aan de ListBox toevoegen. Dit is hetgeen gebeurt met de opdracht bewerkingen.Items.Add(...).
Uit dit voorbeeld kan je leren dat de operator + voor getallen voorziet in de som, en voor strings leidt tot een samentvoeging van de tekenreeksen (concatinering):
- "Optelling: 29 + 7 = " is een string
- (29 + 7) is de optelling van twee gehele getallen 29 en 7 en levert 36.
- De eerste tekenreeks wordt nu met de operator + samengevoegd met het gehele getal 36: hiervoor wordt het gehele getal achter de schermen omgezet in een string (methode ToString()-zie later), de operator + voor twee tekenreeksen leidt tot een samenvoeging van de twee tekenreeksen.

Voorzie volgende voorbeelden:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
	bewerkingen.Items.Add("Optelling: 29 + 7 = " + (29 + 7));
	bewerkingen.Items.Add("Aftrekking: 29 - 7 = " + (29 - 7));
	bewerkingen.Items.Add("Vermenigvuldiging: 29 * 7 = " + (29 * 7));
	bewerkingen.Items.Add("Deling: 29 / 7 = " + (29F / 7F));
	bewerkingen.Items.Add("Modulo : 29 % 7 = " + (29 % 7));
	int getal = 0;
	bewerkingen.Items.Add("Waarde van getal: " + getal);
	bewerkingen.Items.Add("Ophogen met 1 : ++getal = " + ++getal);
	bewerkingen.Items.Add("Verlagen met 1 : --getal = " + --getal);
}

Bij de deling is het interessant op de merken dat minstens 1 van de leden van de bewerking een kommagetal moet zijn (suffix F), anders wordt de gehele deling uitgevoerd en gaan cijfers achter de komma dus verloren.
Wanneer meerdere bewerkingen in 1 statement worden opgenomen worden deze als volgt uitgevoerd:

Rekening houden met eventuele haakjes
Rekening houden met de volgorde der bewerkingen (vb. eerst vermenigvuldigen / delen, daarna optellen of aftrekken)
Uitvoering van links naar rechts

We weten reeds dat we een toekenning van een waarde aan een variabele uitvoeren met behulp van de toekenningsoperator =

int aantalLeerlingen;
aantalLeerlingen = 10;

We kunnen wiskundige hoofdbewerkingen uitvoeren:

aantalLeerlingen = 10 + 5;

Wanneer je de waarde van een variabele wil aanpassen afhankelijk van de originele waarde kan je hetvolgende schrijven:

aantalLeerlingen = aantalLeerlingen + 8;
aantalLeerlingen = aantalLeerlingen - 2;
aantalLeerlingen = aantalLeerlingen * 3;
aantalLeerlingen = aantalLeerlingen / 3;
aantalLeerlingen = aantalLeerlingen % 4;

Dit kan korter door gebruik te maken van een samengestelde toekenningsoperator:

aantalLeerlingen += 8;
aantalLeerlingen -= 2;
aantalLeerlingen *= 3;
aantalLeerlingen /= 3;
aantalLeerlingen %= 4;

c# : variabelen, operatoren en expressies

Statements

identifiers

variabelen

Variabelen gebruiken

Variabelen benoemen

Variabelen declareren

primitieve datatypes

Impliciet getypeerde lokale variabelen

Wiskundige operatoren

Samengestelde toekenning