Visual Basic/Console toepassingen

Waarom console-toepassingen?

Programmeren onder Windows is redelijk ingewikkeld door het systeem van vensters, knoppen, invoervelden enz. Om te leren programmeren, dus om de taalelementen van Visual Basic te leren, is het programmeren van een Windows-programma eigenlijk teveel van het goede. Daarom wordt voor het leren van de taalelementen van Visual Basic gebruikgemaakt van console-toepassingen. Dit soort programma's kent (in principe) geen vensters, labels, tekstvelden e.d., waardoor programma's kleiner zijn en je je beter kunt concentreren op de taalelementen.

Een tweede voordeel is dat voorbeelden op deze manier korter en duidelijker zijn, waardoor de te leren stof gemakkelijker te begrijpen is en de voorbeelden sneller zijn ingetikt.

Wat zijn console toepassingen?

Vóór Windows bestond, werkten de computers met DOS (Disk Operating System). De gebruiker zag dan alleen een zwart scherm met een prompt waar hij een commando kon invoeren. DOS voerde dat commando uit en de uitvoer van dat commando verscheen op het scherm.

Dit werd gerealiseerd doordat DOS een programma uitvoerde dat wachtte op invoer van de gebruiker, analyseerde wat er stond en het uitvoerde. Dat programma heette COMMAND.COM.

Naast een commando kon ook de naam van een programma worden ingevoerd, waarna dat programma werd uitgevoerd. Als COMMAND.COM de invoer niet begreep, nam hij aan dat een programma moest worden uitgevoerd en zocht dan naar een programma met de ingevoerde naam.

Ook onder Windows is dit mogelijk. Klik op de Startknop en tik cmd in en druk Enter. Er wordt nu het programma CMD.EXE gestart dat precies hetzelfde doet als COMMAND.COM onder DOS. Je krijgt nu een scherm te zien zoals de DOS-gebruiker dat vroeger zag. Het is een zwart scherm met witte tekens. Je krijgt steeds de prompt te zien, die laat zien in welke subdirectory je je bevindt (b.v. C:\Users\jouwnaam). Je kunt nu zogenaamde DOS-commando's invoeren, bijvoorbeeld:

dir

Als je dat achter de prompt intikt en Enter drukt, krijg je de inhoud van de subdirectory te zien waar je je op dat moment bevindt (alle subdirectory's en bestanden).

Maar niet alleen commando's kun je op deze manier uitvoeren, maar complete programma's. Voer het volgende commando maar eens uit (eigenlijk zijn het er twee):

dir | sort

Je krijgt nu een gesorteerde lijst van bestanden en directory's te zien (niet op naam, maar op het eerste teken van de regel). Het eerste commando is dir, dat je al gebruikt hebt. Dan volgt het zogenaamde pipe-symbool (|) dat aangeeft dat de uitvoer van het dir-commando moet worden doorgegeven aan het volgende commando (sort).

Je weet het niet, maar dir is een commando dat door CMD.EXE wordt uitgevoerd en sort is echt programma dat door CMD.EXE wordt aangeroepen, en dat speciaal geschreven is om onder CMD.EXE te werken. Het is eigenlijk een console-toepassing.

Je kunt zien dat sort een echt programma is door het volgende commando uit te voeren in Opdrachtprompt:

where sort

Je krijgt dan als antwoord:

C:\Windows\System32\sort.exe

Dat is de plaats waar het programma sort.exe is opgeslagen.

Als je het volgende commando uitvoert

where dir

krijg je als uitvoer

Info: kan geen bestanden voor het opgegeven patroon of patronen vinden.

Dit geeft aan dat dir geen echt programma is. Het is ofwel een typefout ofwel een commando van CMD.EXE. Omdat dit werkt, is het dus een commando van CMD.EXE.

Wat achter de schermen gebeurt is dat in Opdrachtprompt een programma draait dat invoer van de gebruiker accepteert, kijkt of het een bekend commando is en zo ja de uitvoer van dat commando op het scherm toont. Als er geen commando bestaat met die naam, kijkt het programma of op bepaalde plaatsen op de computer een programma bestaat met die naam en voert dat uit. Maar ook programma's die op andere plaatsen zijn opgeslagen, kun je uitvoeren. Stel, je hebt Word 2010 op je computer, dan kun je deze als volgt vanuit de Opdrachtprompt uitvoeren:

"C:\Program Files (x86)\Microsoft Office\Office14\winword.exe"

Word wordt nu gewoon opgestart.

Maar waarom staat deze opdracht tussen aanhalingstekens? Omdat het Opdrachtpromp-programma spaties gebruikt als scheiding tussen programma en parameters. En omdat er spaties in de directorynamen voorkomen, zou het Opdrachtprompt-programma zich hierin verslikken en proberen PROGRAM.EXE in de hoofddirectory van C: uit te voeren en de rest van de regel mee te geven als parameter voor dat programma. En dat is niet de bedoeling, vandaar de aanhalingstekens.

Opbouw van een console-toepassing

Een console-toepassing bestaat uit vier stappen, waarvan de eerste stap niet altijd hoeft voor te komen en de vierde stap alleen nodig is als de toepassing vanuit Visual Studio wordt gestart:

1. invoeren van de gegevens
2. verwerken van de gegevens
3. tonen van het resultaat
4. wachten op de Enter-toets

In sommige situaties (bijvoorbeeld als de console-applicatie vanuit Visual Studio of de Verkenner wordt aangeroepen) verdwijnt het venster van CMD.EXE direct. De gebruiker krijgt dus niet de uitvoer van het programma te zien. Om dat te voorkomen wordt stap 4 gebruikt. Deze bestaat uit het Basic-commando Console.ReadLine zonder dat een waarde aan een variabele wordt toegekend (mag wel, maar is in de laatste stap niet gebruikelijk). Daardoor blijft het programma wachten totdat de gebruiker op Enter drukt en kan de gebruiker dus rustig de uitvoer van het programma bekijken.

Het invoeren van de gegevens gebeurt met het Basic-commando Console.ReadLine (read line). De gebruiker kan dat "iets" intypen en na het drukken van ENTER wordt deze invoer opgeslagen in een variabele. Eventuele volgende in- of uitvoer vindt plaats op een volgende regel. Zo nodig kan dit commando meerdere keren gebruikt worden om verschillende variabelen te voorzien van een waarde. Daarnaast is er het commando Console.Read, dat doet hetzelfde, maar er wordt niet verder gegaan op een volgende regel.

Het verwerken van de gegevens wordt geleerd in het volgende deel van dit handboek.

Het tonen van de gegevens gebeurt met het Basic-commando Console.WriteLine().

De klasse Console

Een klasse is een geheel van variabelen en/of procedures, die in een klasse meestal methode worden genoemd. Een methode is verder gelijk aan een procedure: het voert een bepaalde taak uit, waarbij eventueel gegevens meegegeven kunnen worden en zo nodig na afloop een resultaat teruggegeven wordt.

De klasse Console kent zeer veel methoden, maar we gebruiken er meestal maar vier:

• Console.Read om gegevens van het toetsenbord te lezen
• Console.ReadLine om gegevens van het toetsenbord te lezen en daarna verder te gaan op de volgende regel
• Console.Write om gegevens op het scherm te schrijven
• Console.WriteLine om gegevens op het scherm te schrijven en verder te gaan op de volgende regel

Zoals je ziet moet je een methode vooraf laten gaan door de naam van een klasse gevolgd door een punt. Een klasse moet je normaal in je programma declareren, maar Console is een bijzonder soort klasse (net als Math) die je niet hoeft te declareren maar direct kunt gebruiken.

Het bijzondere is dat de methoden Console.Write en Console.WriteLine er in meerdere versies bestaan. Voor ieder soort parameter die je mee wilt geven (String, Integer, Double, enz.) bestaat er een aparte variant. Daar hoef je gelukkig geen rekening mee te houden. De compiler zorgt er zelf voor dat de juiste versie wordt gebruikt aan de hand van het type van de parameter.

Een paar eenvoudige voorbeelden

Start Visual Studio en kies voor New Project.... Kies in het volgende scherm voor Console Application en vul bij Name: console01 in. Klik op OK. Het project wordt aangemaakt en even later verschijnt een scherm met de volgende tekst:

Module Module1

  Sub Main()

  End Sub

End Module

Dit is de definitie van een module met de naam Module1 die bestaat uit één subroutine met de naam Main(). Een console-toepassing bestaat (in principe) uit één module die uit één of meerdere subroutines bestaat. Als een console-toepassing wordt gestart, wordt altijd begonnen met de subroutine die de naam Main() heeft.

Het is nu de bedoeling dat je je programma schrijft tussen de regels Sub Main() en End Sub.

Breid bovenstaande regels als volgt uit:

Module Module1
  Dim naam As String
  Sub Main()
    Console.WriteLine("Dit is het programma Console01")
    Console.WriteLine()
    Console.Write("Wat is je naam? ")
    naam = Console.ReadLine()
    Console.WriteLine("Hallo, " & naam)
    Console.ReadLine()
  End Sub
End Module

Als je goed oplet, zie je dat Visual Studio al sommige tekens toevoegt zodat je ze zelf niet hoeft te typen. Je kon desondanks gewoon verder typen.

Voer het programma nu uit met F5. He krijgt nu een venster te zien met de tekst

Dit is het programma Console01

Wat is je naam?

Tik je naam en en druk Enter. Er verschijnt nu (bijvoorbeeld) de volgende regel:

Hallo, Johan

Als je nu opnieuw op Enter drukt, wordt het venster gesloten omdat het programma klaar is.

Je kunt het programma ook rechtstreeks uitvoeren. Ga in de verkenner naar de plaats waar het exe-bestand staat, b.v. H:\VBhandboek\Console01\Console01\bin\Debug en dubbelkik op Console01.exe. De opdrachtprompt start en vraagt om je naam, net zoals bij het drukken van F5 in Visual Studio.

Om het programma uit te leggen volgt het hier met regelnummers:

01 Module Module1
02   Dim naam As String
03   Sub Main()
04     Console.WriteLine("Dit is het programma Console01")
05     Console.WriteLine()
06     Console.Write("Wat is je naam? ")
07     naam = Console.ReadLine()
08     Console.WriteLine("Hallo, " & naam)
09     Console.ReadLine()
10   End Sub
11 End Module

Regel 01: Iedere console applicatie bestaat uit een module. Hier geef je de naam van de module op. Dit kan iedere willekeurige naam zijn, behalve sleutelwoorden die Basic zelf gebruikt, zoals b.v. Dim.

Regel 02: Hier definieer je de variabele naam waarin de naam die je invoert wordt bewaard. Deze variabele is van het type String en kan dus een willekeurige reeks tekens bevatten.

Regel 03: Hier definieer je een subroutine (een deel van een programma) met als naam Main(). Deze naam geeft aan dat het programma hier begint. Een programma kan meerdere subroutines bevatten, maar de uitvoering van het programma begint altijd bij Main().

Regel 04: De tekst tussen aanhalingstekens wordt getoond en er wordt verder gegaan op de volgende regel.

Regel 05: Omdat er niets tussen de haakjes staat, wordt er niets op het scherm gezet, maar wel verder gegaan op de volgende regel.

Regel 06: De tekst tussen aanhalingstekens wordt op het scherm gezet en de cursor (het liggende streepje) blijft op dezelfde regel staan.

Regel 07: Er wordt een regel invoer van de gebruiker gelezen en toegekend aan de variabele naam.

Regel 08: Door de ampersand (&) wordt de tekst tussen aanhalingstekens en de inhoud van de variabele aan elkaar geplakt. Het resultaat wordt op het scherm geplaatst.

Regel 09: Het programma wacht totdat de gebruiker op Enter drukt.

Regel 10: Geeft het einde van de subroutine aan.

Regel 11: Geeft het einde van de module aan.

Zoals je ziet, is een console applicatie relatief eenvoudig te schrijven en te begrijpen omdat allerlei visuele toeters en bellen niet nodig zijn. Zo kun je je beter richten op de essentiële delen van het programmeren.

Een opmerking: het initiële stukje programma telt drie blanco regels, die je in bovenstaand voorbeeld niet ziet. Blanco regels wordt vooral gebruikt om een programma in duidelijke blokken te verdelen. Om ruimte te besparen worden ze in voorbeelden vaak weggelaten. Maar je mag zoveel blanco regel gebruiken als je wilt of nodig acht.

En nu een ander voorbeeld. Wijzig het programma totdat het als volgt uitziet:

Module Module1
  Dim naam As String
  Sub Main()
    Console.WriteLine("Dit is het programma Console01")
    Console.WriteLine()
    Console.Write("Wat is je naam? ")
    naam = Console.ReadLine()
    MsgBox("Hallo, " & naam)
    Console.ReadLine()
  End Sub
End Module

Als je dit programma uitvoert, wordt ook gevraagd naar je naam, maar als je Enter drukt, verschijnt de tekst niet op het scherm, maar in een apart venster, een zogenaamde MessageBox, die je moet sluiten door op OK te klikken.

Dit betekent dat je bepaalde visuele elementen van Visual Basic ook in een console applicatie kunt gebruiken.

Hoe nu verder?

Op veel plaatsen in dit handboek (vooral het volgende deel) worden bepaalde taalelementen van Visual Basic verduidelijkt in een console-toepassing. Zoals je ziet, kun je je dan beter concentreren op de taalelementen en word je minder afgeleid door bijvoorbeeld het ontwerpen van formulieren.

Mocht er later in het handboek extra informatie nodig zijn betreffende console-toepassingen, vind je dat daar vermeld, zodat de context duidelijk is.