Basis concepten leren in C# (deel 1)

Microsoft C# is een rijke programmeertaal die het hele spectrum van object georiënteerd programmeren gebruikt. Het probleem bij het beschrijven van een uitgebreide taal zoals C# is dat alle features zodanig samenhangen dat het bijna onmogelijk is om alles stap voor stap te behandelen. Hoewel we later nog terugkomen op overerving (inheritance) en de details van het object georiënteerd programmeren raken we deze in dit hoofdstuk al even aan om te tonen hoe de basisinfrastructuur in elkaar zit. Indien deze begrippen nog niet bekend zijn is dat geen probleem. Probeer in dit hoofdstuk een overzicht te krijgen van hoe de taal in elkaar zit en wat de mogelijkheden zijn.

Class (klasses) en NameSpaces

Klasses, formulieren en andere codebestanden zijn gedefinieerd in een bestand met de extensie *.cs . Ieder uitvoerbaar project heeft een entry point, oftewel een startpunt. Dit is een stukje code dat als eerste wordt uitgevoerd wanneer je programma start. Een veel voorkomend Entry Point is de “Main“-methode.

using System;

class Mashitup{
    // Main Method
    static public void Main(String[] args)
    {

        Console.WriteLine("Deze functie wordt als eerste opgeroepen");
    }
}

In het bovenstaand stukje code zie je heel wat gebeuren. We hebben hier eerst en vooral een klasse. Hier gaan we het later nog over hebben. Daarbinnen in zie je de bijzonder functie of methode “Main”.

Klasses

In .NET is alles een object, inclusief de basis data types zoals Integers, Strings, Arrays, Datumtypes, … Zelfs Errors (Exceptions), processen, threads enzovoort zijn objecten. In de object georiënteerde wereld is de rol van de ontwikkelaar veranderd van wat het was met structureel programmeren. Terwijl bij het structureel programmeren vooral code geschreven werd die data ging manipuleren, wordt van de huidige ontwikkelaar verwacht dat hij zelf objecten zal creëren, of bestaande objecten zal uitbreiden. Om te bepalen hoe een object er uit ziet en zich gedraagt, maken programmeurs gebruik van een zogenaamde blauwdruk of een klasse (Class). Een basisidee van een klasse kan je samenvatten als een combinatie van data gerelateerd aan een entiteit uit de echte wereld met een lijst van methodes die toelaat omdeze data te manipuleren. Een voorbeeld van een klasse:

public class Persoon
 {
     public string VoorNaam;
     public string AchterNaam;
     public string GetNaam()
     {
         return VoorNaam + " " + AchterNaam;
     }
     public void SetVoorNaam(string Naam)
     {
         VoorNaam = Naam;
     }
 }

NameSpaces

Aangezien .NET een uitgebreide set aan klasses bevat en we deze ook nog kunnen uitbreiden met onze eigen klasses, is er een systeem nodig om al deze klasses onder te brengen in een deftige structuur. Namespaces verzorgen dit systeem. Indien we een klasse “Persoon” zouden maken zoals hierboven beschreven kunnen we deze klasse overal gaan gebruiken. Hiertoe creëren we een object van het type “Persoon “ zoals hieronder beschreven:

Persoon Erdem = new Persoon();

Zoals je je wel kan inbeelden, zullen wij niet de enige ter wereld zijn die een klasse met de naam “Persoon” kan definiëren. We moeten dus duidelijk kunnen maken waar we onze klasse persoon kunnen onderbrengen. We kunnen dit doen door onze klasse in een namespace te plaatsen. Je kan dit bekijken als het categoriseren van klasses. Wanneer we de constructie “Namespace … End Namespace” rond onze klasse plaatsen moeten we daarna eerst de namespace definiëren alvorens we de klasse kunnen gebruiken.

namespace Gebruikers
{
    public class Persoon
    {
    }
}

Met deze declaratie kunnen we de klasse nu als volgt gebruiken:

Gebruikers.Persoon Erdem = new Gebruikers.Persoon();

Variabelen

Een variabele is een manier om data in het tijdelijke geheugen op te slaan. Je reserveert een blok in het geheugen om later data in op te slaan. Je geeft deze plaats ook een naam zodat je later aan de data kan die je hebt opgeslagen in het geheugen. Dit deel noemen we de declaratie van een variabele. Vermits .NET steeds strong typed is moeten we bij de declaratie ook vermelden welk soort data we gaan opslaan in het geheugen. Om een variabele te declareren kunnen moeten we de type uitschrijven en vervolgens een naam geven. Daarbij geven we aan of deze variabele voor iedereen of slechts beperkt toegankelijk is door de sleutelwoorden: Public, Private of Static gebruiken. Wat het verschil tussen deze keywords is komt later aan bod.

Declaratie
Samengevat heeft een declaratie van variabele dus volgende elementen nodig:
– Keywords: Public, Private of Static
– Type: We moeten meedelen welk type data we gaan opslaan in het geheugen
– Naam: We hebben een naam nodig om de data later uit te kunnen lezen
Een typische variabele declaratie ziet er als volgt uit:

int EenGetal = 0;

Hierboven is “int” de type en “Eengetal” de naam. We duiden hiermee dus aan de we een plaats in het geheugen reserveren om getallen in op te slaan. We zorgen er ook voor dat we het geheugen terug kunnen uitlezen door te refereren naar “Eengetal”.

Toewijzen
Nu we de variabele gedeclareerd hebben kunnen we waardes in het geheugen opslaan. Dit doen we door een toewijzing of een assignment. Op volgende wijze kunnen we bijvoorbeeld het getal 10 in het geheugen opslaan:

EenGetal = 10;

Dit zorgt ervoor dat we het getal 10 in het geheugen opslaan. Het is echter niet alleen mogelijk om vaste waardes toe te wijzen aan de variabele. We kunnen ook resultaten van berekeningen, de waardes van andere variabelen of een combinatie daarvan opslaan in het geheugen:

EenGetal = AnderGetal / 100;

In bovenstaand voorbeeld nemen we de waarde van een andere variabele (Andergetal), delen deze door 100 en slaan we het resultaat op in het geheugen. Een toewijzing voert dus het gedeelte aan de rechterkant van het =-teken uit en slaat de waarde op in de variabele aan de linkerkant van het =-teken.

Uitlezen
Zoals eerder vermeld willen we nadat we een variabele gedeclareerd hebben en waardes in opgeslagen hebben, de huidige waarde opnieuw uitlezen. Dit kan door naar de naam van de variabele te refereren in de code. Volgend voorbeeld zal in een consoleapplicatie de waarde die in de variabele Mijngetal zit schrijven naar het consolevenster:

Console.WriteLine(EenGetal);

Data types

Bij het onderdeel over variabelen zagen we dat we bij de declaratie moesten aangeven over welk type gegevens we willen opslaan in het geheugen. We zullen later zien dat we onze eigen data types kunnen maken. Een voorbeeld zagen we reeds toen we een klasse maakten van het type “Persoon”. .NET heeft echter een grote library van ingebouwde datatypes die we zo kunnen gebruiken. Een kort overzicht van de meest gebruikte datatypes:

Object
Het type Object is de basis van alle andere types. Later zullen we zien dat alle datatypes afgeleiden zijn van dit type. In variabelen van het type Object kunnen we alle soorten van data opslaan. We kunnen dit bekijken als een soort van generische container waarin alles past. Voorbeeld:

 object o = null; 
 o = "tekst"; 
 o = 5;

We declareren hier een variabele van het type Object en wijzen er achtereenvolgens een tekst een getal aan toe.

Getallen
Een Integer is een data type om getallen in op te slaan. Meer bepaald 32-bit getallen. Dit betekent dat we 4.294.967.294 mogelijkheden hebben. Vermits we echter ook negatieve getallen moeten kunnen opslaan betekent dit dat we getallen kunnen opslaan van -2,147,483,648 tot 2,147,483,647. Een overzicht van alle andere datatypes voor getallen vind je in onderstaande tabel:

Type	.Net Runtime	ruimte	Waarde bereik
Decimal	System.Decimal	96-bit	+/- 79,228,162,514,264,337,593,543,950,335 zonder decimale punt; +/- 7.9228162514264337593543950335 met 28 plaatsen rechts van het decimale punt; Het kleinste getal dat niet 0 is, is+/- 0.0000000000000000000000000001
Double	System.Double	64-bit	-1.79769313486231E308 tot – 4.94065645841247E-324 voor negatieve waardes; 4.94065645841247E-324 tot 1.79769313486232E308 voor positieve waardes
Integer	System.Int32	32-bit	-2,147,483,648 to 2,147,483,647
Long	System.Int64	64-bit	-9,223,372,036,854,775,808 tot 9,223,372,036,854,775,807
Short	System.Int16	16-bit	-32,768 to 32,767
Single	System.Single	32-bit	-3.402823E38 tot -1.401298E-45 voor negatieve waardes; 1.401298E-45 to 3.402823E38 voor positieve waardes

Enkele voorbeelden van variabele declaraties met deze datatypes:

decimal grootgetal = default(decimal); 
double kommagetal = 0; 
int getal = 0; 
long bit64 = 0; 
short kleingetal = 0; 
float exponent = 0;

Boolean
Het type Boolean dient om slechts twee waardes in op te slaan: true of false. Hoewel een boolean slechts twee waardes kan bevatten en dus opgeslagen zou kunnen worden in één bit (0 of 1) gebruikt .NET 4 bytes om booleans in op te slaan. De extra ruimte wordt gebruikt om andere functies van Booleans te implementeren. Voorbeeld:

bool IsOk = false;

String
Het String-datatype dient om tekstuele waardes in op te slaan. In theorie kan een string-variabele meer dan 2 miljard karakters bevatten. Een dergelijk lange string is natuurlijk fataal voor de performantie van een applicatie. Strings kunnen samengevoegd worden met de &-operator of de +-operator. Dit noemen we concatenatie. Voor een betere leesbaarheid wordt echter de &-operator aangeraden. De +-operator wordt vooral ondersteund voor backward-compatibility. Een voorbeeld van een Stringdeclaratie en een concatenatie:

string naam = null; 
naam = "Erdem"; 
naam = naam + " Y";

In dit voorbeeld declareren we een variabele “naam”. Daarna wijzen we de tekst “Erdem” toe aan deze variabele. In de volgende stap nemen wede huidige waarde van de variabele “Erdem” en voegen we hieraan “ Y” toe. Dit geheel slaan we op in de variabele naam die nu dus de waarde “” zal bevatten.