Mobiele apps programmeren met Xamarin – De anatomie van een C#-programma – statements, commentaar, datatypes, variabelen, berekeningen en conversies

print

Inhoud

Wat vooraf ging

Deze post bouwt verder op Start to Program – De anatomie van een computerprogramma maar legt nu het accent op de specifieke programmeertaal C#.

Ik ga ervan uit dat u reeds vertrouwd bent met de inhoud van Start to Program – De anatomie van een computerprogramma. Ook weet u hoe u een Xamarin project moet opstarten en hebt u enige basiskennis van XAML.

  • Start een nieuw Xamarin-project op en geef het een passende naam (ik kies voor de inspirerende naam App2).
  • Eens het programma opgestart is gaat u naar het bestand MainPage.xaml. Voor meer informatie over de standaard XAML verwijs ik u naar de post Kennismaling met XAML.
  • Merk het Label op. We gaan dit label gebruiken als uitvoer. Het label moet dus aanspreekbaar zijn vanuit de achterliggende programmeercode en dient dus een naam te krijgen. Volgende code kent de naam lblUitvoer toe aan het label.

x:Name="lblUitvoer"

  • Merk de x: voor de Name op! Die staat er omdat het attribuut Name uit de namespace “xmlns:x=”http://schemas.microsoft.com/winfx/2009/xaml” komt die een x als prefix heeft.
  • De aangepaste XAML ziet er als volgt uit.
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:local="clr-namespace:App2" x:Class="App2.MainPage">

	<Label x:Name="lblUitvoer" Text="Welcome to Xamarin Forms!" VerticalOptions="Center" HorizontalOptions="Center" />

</ContentPage>
  • Vervolgens klikt u op MainPage.xaml.cs dit is de code-behind.
  • We hebben deze code reeds eerder besproken maar ik herhaal het hier nog even omdat het deel uitmaakt van de anatomie van een C# programma.
using Xamarin.Forms;

namespace App2
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
    }
}

U maakt gebruik van de bibliotheek/namespace Xamarin.Forms.

using Xamarin.Forms;

Vervolgens komt de namespace van ons eigenlijke project App2.

namespace App2
{
}

Deze bevat de publieke gedeelde class MainPage van het type (meer correct: overgeërfd van de klasse) ContentPage. Deze class is public (beschikbaar voor heel het project) en partial (deze klasse is gedeeltelijk en heeft dus ook nog een ander deel, namelijk de bijhorende XAML-code).

public partial class MainPage : ContentPage
{
}

De constructor van de Mainpage initialiseert de bijhorende XAML-component.

public MainPage()
{
InitializeComponent();
}

De structuur van een klassiek C#-programma (niet Xamarin) vindt u hier.

Nu we dit weer even opgefrist hebben kunnen we ons concentreren op C# programmeercode.

Statements

  • Een computerprogramma is een lijst van instructies die moeten worden uitgevoerd door een computer.
  • In een programmeertaal spreken we niet van een instructie maar van een statement.
  • Statements in C# worden gescheiden door een puntkomma. Dus ieder statement moet eindigen op een puntkomma.
  • C# is hoofdlettergevoelig.

Een voorbeeld van een reeds gebruikt statement is:

InitializeComponent();

Dit statement initialiseert de XAML-code in de code-behind.

De meer algemene vorm van een statement in C# is:

Object.Functie(parameters);

Bijvoorbeeld, onderstaande statement opent een webpagina (URI) op uw toestel:

Device.OpenUri(new Uri("https://ictopleidingen.azurewebsites.net/"));

  • Het object hier is Device. Device is een class die gebruikt wordt voor interactie met de gebruikte device (apparaat).
  • OpenUri is een functie (meer bepaald een methode) die een website (uri) opent.
  • De website wordt als parameter meegegeven van de class Uri. Er wordt dus een nieuwe instantie genomen van de klasse Uri via new Uri("https://ictopleidingen.azurewebsites.net/").
  • Het statement eindigt met een puntkomma.

IntelliSense

Net als bij XAML kunt u ook bij code-behind gebruik maken van IntelliSense om de code correct op te bouwen.

  • Begin met het woordje Device te typen. U hoeft zelfs niet alles in te typen voor u hulp krijgt.

  • Klik vervolgens op het gewenst object (hier Device) of klik op de Tab-toets.
  • Typ vervolgens een punt. U krijgt nu een overzicht van alle eigenschappen (properties) en methoden die bij het object horen. OpenUri staat hier ook tussen. Duidt het aan om meer informatie te krijgen. U ziet hier bv. hoe de methode opgebouwd is, welke paramaters er verwacht worden en u krijgt een korte omschrijvingen van wat de methode doet.

  • Klik op OpenUri en klik het (-open. U krijgt nu gedetailleerde informatie over de parameter(s) die u moet toevoegen. In dit geval een nieuwe instantie van de class Uri.

  • Typ in new Uri( en u krijgt opnieuw hulp voor de mogelijke parameters. Merk op dat u 4 variaties hebt in mogelijke parameters. U staat op 1 of 4 een parameterconfiguratie die een string verwacht als parameter (namelijk het webadres).

  • Vul nu het webadres in tussen “” en merk op dat IntelliSense aanduidt dat er nog een ) en eeen ; ontbreekt.

  • Typ het ) en de ; en de statement is correct ingetypt.

Merk op dat de website automatisch wordt geopend van zodra u de app start. De code is immers geplaatst rechtsreeks in de MainPage en wordt dus meteen uitgevoerd. Beter zou zijn de ze code pas uit te voeren na het klikken op een knop, bij een Click-event.

Error List

Kijk ook onderaan de Error List, hier ziet u wat er momenteel ontbreekt aan het statement (of uw programmeercode in het algemeen). Als voorbeeld heb ik uit de bovenstaande statement het ) en de ; verwijderd.

Weet dat uw programma niet zal opstarten zolang er errors zijn. U moet deze dus eerst allemaal oplossen voor u uw programma kunt laten “lopen”.

IntelliSense en namespaces

Het statement Device.OpenUri() behoort tot de namespace Xamarin.Forms. Uri() behoort dan weer tot de namespace System.

De volledige code zou dus eigenlijk moeten zijn:

using Xamarin.Forms;

namespace App2
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();

            Xamarin.Forms.Device.OpenUri(new System.Uri("https://ictopleidingen.azurewebsites.net/"));           

        }
    }
}

De namespace Xamarin.Forms was reeds opgenomens via:

using Xamarin.Forms;

De namespace System stond reeds klaar (in het grijs) bovenaan en wordt geactiveerd van zodra u een object uit die namespace gebruikt.

Omdat we de namespace Xamarin.Forms reeds in gebruik hebben (en de namespace System automatisch wordt geactiveerd) hoeven we deze duiding niet meer te hernemen in de code (het in gebruik nemen van namespaces bovenaan vereenvoudigt dus de leesbaarheid van de code). IntelliSense helpt u overbodige namespaces te duiden.

  • Klik op het pijltje naast het lampje om hulp op te vragen waar nodig.
  • Klik vervolgens op de actie (hier Simplify member access … ) om de hulp uit te voeren.

  • Op een gelijkaardige manier kunt u bovenaan de namespaces die door de code niet gebruikt worden, maar die wel klaar stonden (in het grijs), opkuisen.
  • Klik op het pijltje naast het lampje en klik op Remove Unnecessary Usings.

Block statements

Een Block statement wordt gebruikt om statements te groeperen. De statements worden gegroepeerd binnen {}.

{
  statement_1;
  statement_2;
  .
  .
  .
  statement_n;
}

Commentaar

Niet iedere regel die u intypt hoeft een statement te zijn.

Meer zelfs, het is belangrijk dat u uw programmeercode documenteert met uitgebreide commentaar, zowel voor uzelf als voor anderen die uw programmeercode eventueel dienen te onderhouden.

Deze commentaar wordt door de compiler/interpreter genegeerd en niet omgezet in machinetaal. Commentaar vormt dus geen extra belasting (vertraging) voor het uiteindelijke programma, het helpt u gewoon uw programmeercode overzichtelijker te houden.

Commentaar op 1 regel

Typ // en al wat volgt tot het einde van de regel wordt als commentaar beschouwd. U kunt // aan het begin van een regel of achter een statement plaatsen.

using System;
using Xamarin.Forms;

namespace App2
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();

            //Open de website ictopleidingen.azurewebsites.net
            Device.OpenUri(new Uri("https://ictopleidingen.azurewebsites.net/"));           

        }
    }
}

Commentaar op meerdere regels

U kunt ook commentaar spreiden over meerdere regels. U begint de commentaar op meerdere regels met /* en beëindigt de commentaar met */.

/* 
Deze commentaar
Staat
Op meerdere
regels.
*/

Datatypes

Het datatype is het specifieke type van de data/waarde. Het datatype bepaalt ook hoeveel bytes een waarde van dat type inneemt in het geheugen.

Onderstaande tabel tonen de datatypes die kunnen gebruikt worden in C#.

C#Bytes in het geheugenWaardenSuffix
BooleanAfhankelijk van het gebruikte platformTrue of False.
Byte1 byte0 tot 255 (unsigned)
Char2 bytes0 tot 65535 (unsigned)
Int16 (short)2 bytes-32.768 tot 32.767
Int32 (int)4 bytes-2.147.483.648 tot 2.147.483.647
Int64 (long)8 bytes -9.223.372.036,854.775,808 tot 9.223.372.036.854.775.807L of l
Single (float)4 bytes-3,4028235E+38 tot -1,401298E-45 voor negatieve waarden
1,401298E-45 tot 3,4028235E+38 voor positieve waarden		F of f
Double8 bytes-1,79769313486231570E+308 tot
-4,94065645841246544E-324 voor negatieve waarden
4,94065645841246544E-324 tot 1,79769313486231570E+308 voor positieve waarden		D of d
Decimal16 bytes 0 tot +/-79.228.162.514.264.337.593.543.950.335 zonder decimaal teken.
0 tot +/-7,9228162514264337593543950335 met 28 cijfers na het decimaal teken. 		M of m
StringAfhankelijk van het gebruikte platform 0 tot ongeveer 2 miljard tekens.
Object4 bytesKan elke willekeurige waarde bevatten
UInt16 (ushort)2 bytes0 tot 65.535
UInt32 (uint)4 bytes0 tot 4.294.967.295U of u
UInt64 (ulong)8 bytes0 tot 18.446.744.073.709.551.615UL of ul

Programmeertalen waar het exacte datatype moet worden geduid worden strongly typed programmeertalen genoemd. Programmeertalen waar deze duiding niet verplicht is maar optioneel worden weakly/loosly typed genoemd.

  • Strongly typed programmeertalen zijn exacter, vragen meer werk/aandacht (bv. door de noodzaak om zelf de conversie van het ene type naar het andere te programmeren) tijdens het typen maar zullen ook rapper fouten ontdekken en weergeven.
  • Weakly/loosly typed programmeertalen zijn losser, minder streng, bij het typen van de programmeertaal. De programmeertaal neemt zelf de conversie voor zijn rekening. Deze lossere aanpak is gemakkelijker voor de beginnende programmeur maar kan ook potentiële fouten langer verbergen.

In C# kunt u strongly typed als weakly typed werken.

Variabelen

Ik herneem even een quote die ik reeds eerder gebruikt heb voor het begrip variabele.

Een variabele is een voorbehouden locatie in het computergeheugen waar u een waarde kunt bijhouden/stokkeren voor later hergebruik. De variabele heeft een naam en is vaak van een specifiek type. Het type bepaalt het aantal bytes dat gereserveerd wordt in het computergeheugen voor deze variabele en de naam van de variabele wordt gebruikt om toegang te krijgen tot deze locatie in het computergeheugen. De waarde die wordt bijhouden in die locatie, en waar de variabele naar verwijst, kan in de loop van het programma variëren/wijzigen. Later komen we specifiek terug op het begrip variabele.

Laten we dit nu even meer in detail bekijken en wat uitbreiden en duiden:

  • Een variabele is een voorbehouden locatie in het computergeheugen waar u een waarde kunt bijhouden/stokkeren voor later hergebruik.
  • De variabele heeft een naam (identifier). De naam van de variabele wordt gebruikt om toegang te krijgen tot deze locatie in het computergeheugen.
  • De variabele is vaak van een specifiek datatype. Het datatype bepaalt het aantal bytes dat gereserveerd wordt in het computergeheugen voor deze variabele en bepaalt ook welk soort/type data de variabele kan bevatten (int16, string, decimal,…).
  • De waarden die opgeslagen worden in variabelen kunnen in de loop van het programma variëren, ze zijn dus variabel.
  • Het bereik van een variabele wordt bepaald (en beperkt door) de {…} waarbinnen de variabele is gedeclareerd. Buiten de {…} waarbinnen de variabele is gedeclareerd is deze variabele niet gekend en dus ook niet toegankelijk.
  • Een variabele moet binnen hetzelfde bereik uniek zijn. Dezelfde naam mag dus binnen hetzelfde bereik geen tweede keer hergebruikt worden voor een tweede variabele.

Declaratie van variabelen

Voor u een variabele kunt gebruiken moet u een variabele declareren, als het ware een plek reserveren voor de variabele in het geheugen van de computer.

Dit gebeurt door het datatype te bepalen en een naam te kiezen voor de variabele. De naam wordt ook wel Identifier genoemd. De declaratie wordt afgesloten met het scheidingsteken puntkomma.

Bij een Strongly typed programmeertaal zal dit datatype moeten gespecifieerd zijn.

Datatype Identifier;

Bij een weakly/loosly typed programmeertaal hoeft het type niet gespecifieerd te worden en kunt u een variabele duiden met het woordje var. We spreken ook van een impliciete declaratie.

var Identifier;

Bijvoorbeeld, onderstaande code toont hoe u een variabele met de naam mijnNaam declareert.

var mijnNaam;

Bij een strongly typed programmeertaal moet het datatype gespecifieerd worden! We spreken van een expliciete declaratie.

datatype Identifier;

Bijvoorbeeld, onderstaande code toont hoe u een variabele met de naam mijnNaam declareert van het type string.

string mijnNaam;

Sinds een paar jaar (vroeger dus niet) laat C# beide methoden toe. Nen “echten” zal immers steeds het datatype duiden.

Merk op dat er op dit ogenblik nog geen waarde is toegekend. Dit wordt in Visual Studio aangeduid met een groen lijntje (geen echte fout maar toch iets dat niet echt correct is).

Waarde toekennen

Nadat een variabele gedeclareerd is kan een waarde toegekend worden. Dit gebeurt door het toekenningsteken (meestal =-teken) gevolgd door de waarde die toegekend wordt en het scheidingsteken puntkomma.

Variabele = Waarde;

Belangrijk, ook al staart er een =-teken, dit is geen wiskundige gelijkheid. U moet dit lezen als de variabele krijgt de waarde “waarde” toegewezen.

string mijnNaam;
mijnNaam = "Geert";

Bijvoorbeeld, onderstaande code declareert 2 variabelen, aan de ene mijnNaam wordt een tekst/string toegewezen en aan de tweede variabele schoenmaat een getal.

string mijnNaam;
Int16 schoenmaat;   //U kunt in plaats van Int16 ook int gebruiken (maar dit is de oudere notatie en staat eigenlijk voor Int32)

mijnNaam = "Geert";
schoenmaat = 42;

Initialisatie

Vaak wordt de declaratie en de toekenning van de waarde in één stap uitgevoerd. Dit wordt initialisatie genoemd.

var Identifier = Waarde;

string mijnNaam = "Geert";

De variabele gebruiken

Eens de variabele een waarde gekregen heeft kan ze nadien gebruikt worden om bv. de waarde van variabele weer te geven op het scherm in het Label lblUitvoer.

string mijnNaam = "Geert";
lblUitvoer.Text = mijnNaam;

Merk op dat de variabele niet tussen “” (quotes) staat!

Constanten

Een constante is als een variabele maar met dit belangrijke verschil dat de waarde na de declaratie niet meer kan worden gewijzigd.

Het declareren van een constante is identiek aan het declareren van een variabele, gebruik gewoon het type const.

const Identifier = Waarde;

Constanten worden praktisch gebruikt om vaste waarden toe te kennen die niet mogen gewijzigd worden. Bijvoorbeeld de waarde van het getal PI of het aantal maanden in een jaar.

const PI = 3.14159;

Identifiers

Alle variabelen moeten een unieke naam (binnen hetzelfde bereik) hebben.

Zo’n unieke naam wordt een Identifier genoemd. Het identificeert de variabele op een unieke manier.

Identifiers, of namen, moeten zich houden aan bepaalde regels:

  • De identifier mag letters, cijfers, de underscore (_-teken) of dollarteken ($-teken) bevatten.
  • De identifier mag dus geen spaties bevatten.
  • Identifiers mogen niet beginnen met een cijfer.
  • Identifiers zijn hoofdlettergevoelig (dus de naam Getal is niet gelijk aan de naam getal).
  • De identifier mag geen gereserveerd woord zijn gebruikt door de programmeertaal.

Kies steeds namen die duidelijk de waarde omschrijven. Zo is de naam BTW duidelijker dan Getal7.

Vaak wilt u dat de identifier bestaat uit meerdere woorden. Door de tijd hebben programmeurs hiervoor een drietal methoden gebruikt:

Gebruik underscores

bedrag_zonder_BTW, mijn_naam

Camel Case (beginhoofdletters)

BedragZonderBTW, MijnNaam

of startend met een kleine letter en vervolgens beginhoofdletters

bedragZonderBTW, mijnNaam

De gekozen methode is niet bindend, u mag dus verschillende methoden door mekaar gebruiken al raad ik dit af om vanzelfsprekende redenen.

Berekeningen

Operatoren

Om berekeningen uit te voeren maakt u gebruik van operatoren. Er zijn wiskundige operatoren, stringoperatoren en toekenningsoperatoren.

Wiskundige operatoren

Onderstaande tabel toont de wiskundige operatoren die gebruikt worden in C#.

BetekenisOperator
Machtsverheffing Math.Pow(x,y)
Positief of negatief+ en -
Vermenigvuldigen en delen * en /
Gehele deling (deling zonder gedeelte na de komma)/
Modulus (rest bij een gehele deling) %
Optellen en aftrekken + en -

Bijvoorbeeld, tel 2 getallen op.

Int16 x = 5; // Ken de waarde 5 toe aan de variabele x 
Int16 y = 2; // Ken de waarde 2 toe aan de variabele y 
Int16 z = x + y; // Ken de som van de waarden van de variabelen x en y toe aan de variabele z

Merk op dat, ook al kan u rechtstreeks de getallen zelf optellen, het is een goede gewoonte de getallen eerst aan een variabele toe te kennen en vervolgens de variabelen te gebruiken voor de optelling.

Deze code zal echter een onverwachte fout opleveren in C#.

De reden is dat de som van 2 getallen van het type Int16 een resultaat kunnen hebben dat groter is dan de maximale waarde die een Int16 kan bevatten. De oplossing ligt hem in het toekennen van het resultaat aan een type die een grotere waarde toelaat zoals het type Int32.

Int16 x = 5; // Ken de waarde 5 toe aan de variabele x 
Int16 y = 2; // Ken de waarde 2 toe aan de variabele y 
Int32 z = x + y; // Ken de som van de waarden van de variabelen x en y toe aan de variabele z

Of werk gewoon met het datatype int (dat eigenlijk staat voor Int32).

int x = 5; // Ken de waarde 5 toe aan de variabele x 
int y = 2; // Ken de waarde 2 toe aan de variabele y 
int z = x + y; // Ken de som van de waarden van de variabelen x en y toe aan de variabele z

U kunt het u ook gemakkelijk maken en alle variabelen impliciet declareren met var.

Test zelf maar even uit in onderstaande console.

Voorrangregels

De bovenstaande tabel toont de berekeningen met de operatoren in de juiste volgorde van uitvoeren (voorrangregels).
zo is:

1 + 2 * 3 = 7

De bovenstaande tabel toont dat * (vermenigvuldigen) voorrang heeft op + (optellen). Dus eerst wordt 2 * 3 uitgevoerd, dit is 6, en daar wordt dan 1 bij opgeteld. Dit levert 7 op als resultaat.

Om de voorrangregels te wijzigen worden haakjes gebruikt.

(1 + 2) * 3 = 9

De haakjes zorgen ervoor dat eerst 1 + 2 wordt uitgevoerd (dit levert 3 op). Deze uitkomst, 3 dus, wordt nadien vermenigvuldigd met 3 en levert zo het resultaat 9 op.

Stringoperatoren

Strings, tekst, kunnen eveneens “berekend”, aan mekaar verbonden, worden.

BetekenisOperator
Strings samenvoegen+

Bijvoorbeeld, voeg 2 strings/teksten samen.

string voornaam = "Geert"; 
string familienaam = "Linthoudt";; 
string naam = voornaam + " " + familienaam

Merk het tussenvoegen van een spatie op. Doet u dit niet dan zouden de voornaam en familienaam direct aan mekaar “gekleefd” worden. Het resultaat zou dan zijn, zonder die extra spatie, “GeertLinthoudt”. Dit wilt u uiteraard niet, vandaar het tussenvoegen van de spatie.

Toekenningsoperatoren

Toekenningsoperatoren zijn operatoren die gebruikt kunnen worden om waarden toe te kennen aan variabelen. Tot nu toe hebben we dit steeds gedaan met het =-teken. Dit is inderdaad de meest gebruikte toekenningsoperator maar er zijn er nog anderen.

De toekenning, het =-teken, moet u lezen als krijgt als waarde.

De toekenningsoperatoren kunnen ook gebruikt worden als een verkorte vorm van een berekening.

ToekenningOperator
Getal krijgt de waardeGetal = Waarde
Getal = Getal + Waarde Getal += Waarde
Getal = Getal - Waarde Getal -= Waarde
Getal = Getal * WaardeGetal *= Waarde
Getal = Getal / Waarde Getal /= Waarde
Getal = Getal % Waarde Getal %= Waarde
Getal = Getal + 1 Getal++
Getal = Getal - 1 Getal--
Tekst = Tekst + Tekst2 Tekst += Tekst2

Bijvoorbeeld:

Int16 x = 5; // Ken de waarde 5 toe aan de variabele x 
x += 5; // Tel bij de waarde van x 5 op. x heeft na de optelling de waarde 10

Wanneer telt het +-teken getallen op, wanneer voegt het tekst samen?

Expliciete declaratie

  • Als beide (alle) waarden van een numeriek type is zal en het resultaat wordt geplaats in een numeriek type dan er worden opgeteld .
  • Als één van de waarden een string (tekst) is en het resultaat wordt geplaatst in het datatype string dan worden ze samen gevoegd.

In alle andere gevallen krijgt u fouten!

Impliciete declaratie (declareren met var)

  • 5 + 5 geeft als resultaat 10.
  • “Klas” + 5 geeft als resultaat “Klas5”.

Met andere woorden:

  • Het +-teken telt op indien de beide waarden numeriek zijn.
  • Het +-teken voegt samen indien minstens één van de beide waarden een string/tekst is.

Willekeurige getallen

Het genereren van willekeurige getallen gebruikt dezelfde logica als diegene die we reeds gezien hebben voor Javascript maar heeft in C# een licht andere syntax.

  • Maak eerst een nieuwe variabele aan van het type Random.

Random Willekeurig = new Random();

  • Een volgend willekeurig geheel getal wordt gegenereerd met de functie next. Een volgend willekeurig decimaal getal wordt gegenereerd met de functie NextDouble.

Willekeurig.Next()
Willekeurig.NextDouble()

  • Door een argument mee te geven beperkt u de willekeurige waarde ( 0 <= willekeurige waarde < argument). Geeft u bijvoorbeeld als argument 6 mee dan worden willekeurige waarden gegenereerd tussen 0 en 5.

Willekeurig.Next(6)

  • Door 2 argumenten mee te geven beperkt u de willekeurige waarde tussen (argument1 <= willekeurige waarde < argument2). Om dus een willekeurige waarde te krijgen tussen 1 en 6 geeft u als argument 1, 7 mee.

Willekeurig.Next(1, 7)

  • Geef onderstaande code in om dit uit te testen.
using System;
using Xamarin.Forms;

namespace App2
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();

            Random Willekeurig = new Random();
            string Resultaat = "";

            Resultaat += "Willekeurige gehele waarde: " + Willekeurig.Next() + Environment.NewLine;
            Resultaat += "Willekeurige decimale waarde: " + Willekeurig.NextDouble() + Environment.NewLine;
            Resultaat += "Willekeurig geheel getal tussen 0 inbegrepen en 6 niet inbegrepen: " + Willekeurig.Next(6) + Environment.NewLine;
            Resultaat += "Willekeurig geheel getal tussen 1 inbegrepen en 6 inbegrepen: " + Willekeurig.Next(1, 7) + Environment.NewLine;

            lblUitvoer.Text = Resultaat;

        }
    }
}

Merk op dat onderstaande code Environment.NewLine gebruikt wordt om een nieuwe regel aan te maken:

Environment.NewLine

De willekeurige getallen worden gegenereerd via een interne berekening gebaseerd op de datum en tijd. Als u wilt kunt u ook zelf een eigen startwaarde (Seed) meegeven. U doet dit door bij de definitie van de variabele een startwaarde als argument aan random mee te geven.Dim Willekeurig As New Random(7)

Merk echter op dat u telkens dezelfde willekeurige waarden krijgt.

Test zelf maar eens uit in onderstaande console.

Conversies

Conversie (of ook wel casting) is het omzetten van het ene datatype naar het andere.

Conversie is enkel nodig wanneer u variabelen expliciet declareert. U kunt het u dus gemakkelijker maken en alle variabelen impliciet (met var declareren). Dit laatste is ok, en gemakkelijk, maar misschien niet echt “professioneel”. Laten we dus toch maar even stil staan bij conversie.

Conversies kunnen ook impliciet zijn of expliciet (casting).

  • Impliciete conversie is het eenvoudigst, deze wordt automatisch doorgevoerd door C#.
  • Expliciete conversie zal de programmeur zelf moeten doen.

Stel de onderstaande code:

U hebt een variabele met als naam Klein en van het type Int16 (short) en een waarde 0.

Int16 Klein = 0;

U hebt een variabele met als naam Groot en van het type Int32 (int) en een waarde 0.

Int32 Groot = 0;

Als u nu de waarde van de variabele Klein toekent aan de variabele Groot. Dus Groot krijgt de waarde van Klein zal dit zonder problemen lukken. De waarde wordt immers impliciet geconverteerd.

Groot = Klein;

Als u nu de waarde van de variabele Groot toekent aan de variabele Klein. Dus Klein krijgt de waarde van Groot dan krijgt u een foutmelding. C# kan immers het datatype Int32 (int) niet converteren naar het type Int16 (short). We zullen dit zelf, expliciet, moeten doen.

Klein= Groot;

Er zijn verschillende methoden om een expliciete conversie (casting) te doen, de tabel verderop toont de verschillende methoden. De meest eenvoudige is echter het type naar waar u wilt/moet converteren in haakjes voor de te converteren variabele/expressie te plaatsen. Dit klinkt moeilijker dan het is, kijk maar:

Klein = (Int16)Groot;

Een ander voorbeeld waar conversie nodig is, is bij berekeningen. C# vereist immers dat alle datatypen binnen een berekening geconverteerd zijn.

Bijvoorbeeld, onderstaande code berekent het aantal graden Fahrenheit op basis van een aantal graden Celsius.

int C = 10;
decimal F = C * 1.8 + 32;

Hoewel dit allemaal ok lijkt krijgt u ook een conversiefout. 1.8 is immers van het type double en double converteert niet impliciet naar decimal.

Een expliciete conversie dringt zich opnieuw op.

decimal F = C * (decimal)1.8 + 32;

Of, een alternatieve oplossing:

decimal F = C * 1.8m + 32;

Merk u de suffix m op? Deze staat voor een conversie naar money (wat hetzelfde is als decimal).

Probeer zelf deze verbetering in onderstaande console.

Conversietabel

Onderstaande tabel toont de verschillende mogelijke conversies (casting). Er wordt gebruik gemaakt van volgende methoden:

Converteren naarC#
BooleanConvert.ToBoolean(expressie)
Boolean.Parse(expressie)
Boolean.TryParse(expressie, out Resultaat)
Byte(Byte)expressie
Convert.ToByte(expressie)
Byte.Parse(expressie)
Byte.TryParse(expressie, out Resultaat)
Char(Char)expressie
Convert.ToChar(expressie)
Char.Parse(expressie)
Char.TryParse(expressie, out Resultaat)
DateConvert.ToDateTime(expressie)
DateTime.Parse(expressie)
DateTime.TryParse(expressie, out Resultaat)
Double(Double)expressie
Convert.ToDouble(expressie)
Double.Parse(expressie)
Double.TryParse(expressie, out Resultaat)
Decimal(Decimal)expressie
Convert.ToDecimal(expressie)
Decimal.Parse(expressie)
Decimal.TryParse(expressie, out Resultaat)
Integer(Int32)expressie
Convert.ToInt32(expressie)
Int32.Parse(expressie)
Int32.TryParse(expressie, out Resultaat)
Long(Int64)expressie
Convert.ToInt64(expressie)
Int64.Parse(expressie)
Int64.TryParse(expressie, out Resultaat)
Object(Object)expressie
Short(Int16)expressie
Convert.ToInt16(expressie)
Int16.Parse(expressie)
Int16.TryParse(expressie, out Resultaat)
Single(Single)expressie
Convert.ToSingle(expressie)
Single.Parse(expressie)
Single.TryParse(expressie, out Resultaat)
StringConvert.ToString(expressie)
expressie.ToString()

Impliciete declaraties

En natuurlijk kon u zich het leven heel eenvoudig maken door gewoon alle variabelen impliciet te declareren met var.

Onderstaande code toont geen foutmeldingen en geen conversies.

Maar ja, waarom het gemakkelijk maken als het moeilijk ook gaat?

Behandelde Basiscompetenties uit de module ICT Programmeren – Specifieke ontwikkelomgeving: eenvoudige functionaliteiten

  • IC BC236 – kan eenvoudige wijzigingen aan een programma aanbrengen
  • IC BC241 – kan een programma in een specifieke ontwikkelomgeving maken
  • IC BC344 – kan oplossingen voor eenvoudige probleemstellingen bedenken

Geef een reactie

Deze website gebruikt Akismet om spam te verminderen. Bekijk hoe je reactie-gegevens worden verwerkt.

  • Abonneer je op deze website d.m.v. e-mail

    Voer je e-mailadres in om je in te schrijven op deze website en e-mailmeldingen te ontvangen van nieuwe berichten.