Variabelen

Een variabele kan vergeleken worden met een voorraadkast en is essentieel voor de programmeur. In C#, wordt een variabele als volgt gedeclareerd:

<data type> <name>;

Een voorbeeld kan er als volgt uitzien:

string name;

Dit is de meest fundamentele vorm, maar de variabele heeft nu nog geen waarde. Je kunt later een waarde toekennen of meteen bij de declaratie, zoals:

<data type> <name> = <value>;

Als het geen lokale variabele voor de methode is waarin je aan het werk bent (b.v. een class member variabele), zou je zichtbaarheid aan de variabele kunnen toevoegen:

<visibility> <data type> <name> = <value>;

Een compleet voorbeeld:

private string name = "John Doe";

Het visibility gedeelte is gerelateerd aan classes, een meer uitgebreide uitleg hierover is te vinden in het hoofdstuk over classes. Wij richten ons op het variabele gedeelte met een voorbeeld waarin we er een paar gebruiken:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        string firstName = "John";
        string lastName = "Doe";

        Console.WriteLine("Name: " + firstName + " " + lastName);

        Console.WriteLine("Please enter a new first name:");
        firstName = Console.ReadLine();

        Console.WriteLine("New name: " + firstName + " " + lastName);

        Console.ReadLine();
    }
    }
}

Goed, veel dingen die hier staan zijn al uitgelegd, daarom gaan we meteen naar het interessante gedeelte. Ten eerste declareren wij een paar variabelen van het type string. Een string bevat eenvoudigweg tekst, zoals je kunt zien, omdat we ze in het voorbeeld meteen een waarde hebben toegekend. Daarna schrijven we een regel naar de console, waarbij we gebruik maken van twee variabelen. De hele tekst wordt opgebouwd door gebruik te maken van het + teken, waarmee de aparte gedeeltes worden "verzameld".

Vervolgens vragen we aan de gebruiker om een nieuwe voornaam in te voeren. Met de ReadLine() methode lezen wij wat de gebruiker op de console invoert en het resultaat wordt in de firstName variabele gestopt. Zodra de gebruiker de Enter toets indrukt wordt de nieuwe voornaam aan de variabele toegekend en in de volgende regel presenteren wij weer de gehele naam, om de verandering te laten zien. We hebben zojuist onze eerste variabele in gebruik genomen en gebruik gemaakt van de meest belangrijke eigenschap ervan: de mogelijkheid om de waarde ervan tijdens het draaien van het programma aan te passen.

In het volgende voorbeeld maken we een som waarbij we een stuk van de code die we net gebruikten opnieuw gebruiken:

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

Plaats dit in je Main en probeer het. Het enige nieuwe dat we hier gebruiken is de int.Parse() methode. Deze leest een tekstwaarde (string) en zet deze om naar een getal (integer). Zoals je kan zien controleert deze applicatie niet of de data ingegeven door de gebruiker correct is. Als je dus iets anders ingeeft dan een cijfer zal er een fout (exception) worden weergegeven. Maar hierover later meer.

Variabelen & scope

Tot nu hebben we enkel lokale variabelen gebruikt, dit zijn variabelen die binnen dezelfde methode gedefinieerd en gebruikt worden. In C# kan een variabele die binnen een methode gedefinieerd wordt niet buiten deze methode gebruikt worden, daarom noemen we dit een lokale variabele. Als je vertrouwd bent met andere programmeertalen ken je waarschijnlijk ook het concept van globale variabelen. Als je een variabele declareert binnen een klasse kan deze gebruikt worden door alle methoden binnen deze klasse. Laat me dit aantonen met een voorbeeld:

using System;

namespace VariableScope
{
    class Program
    {
    private static string helloClass = "Hello, class!";

    static void Main(string[] args)
    {
        string helloLocal = "Hello, local!";
        Console.WriteLine(helloLocal);
        Console.WriteLine(Program.helloClass);
        DoStuff();
    }

    static void DoStuff()
    {
        Console.WriteLine("A message from DoStuff: " + Program.helloClass);
    }
    }
}

Let op de helloClass variabele, deze wordt in een klasse gedeclareerd in plaats van in een methode. Dit zorgt ervoor dat we deze variabele kunnen gebruiken in zowel onze Main() methode alsook in onze DoStuff() methode. Dit is niet het geval voor de helloLocal variabele, deze is gedeclareerd binnen de Main() methode en kan als gevolg daarvan enkel binnen deze methode gebruikt worden.

Het afwisselen tussen waar een variabele gedeclareerd wordt noemen we scoping en het zorgt ervoor dat onze code geen warboel wordt van variabelen die op teveel plaatsen kunnen aangepast worden. Een andere techniek die ons hierbij helpt is zichtbaarheid (in dit voorbeeld aangetoond door het private keyword), we gaan hier verder op in tijdens het hoofdstukken over klassen.

Samenvatting

Variabelen laten je toe om verschillende soorten data op te slaan, bijvoorbeeld: tekst, nummers of andere objecten. Lokale variabelen zijn toegankelijk binnen de methode waarin deze werd gedefinieerd. Variabelen die binnen een klasse gedefinieerd zijn kunnen door alle methoden binnen deze klasse gebruikt worden en zelfs buiten deze klasse als de zichtbaarheid correct is ingesteld.