Programmeren in VBA › vanhelden › Bestanden... · ©Stichting Praktijkleren – Programmeren in...

Programmeren

in C#

Niveau 4

Versie: 1.1 Datum: januari 2017

©Stichting Praktijkleren – Programmeren in C# Versie 1.1 2

0 Inleiding In deze lessen leer je programmeren in C#. Je gebruikt hierbij Visual Studio Professional 2015 of 2013. Deze ontwikkelomgeving is te downloaden via de site van Dreamspark. Het lesmateriaal is opgebouwd uit een aantal delen. Elk deel bestaat uit een aantal hoofdstukken. Bij elk hoofdstuk zitten een of meer oefeningen. Deze oefeningen moet je maken. De uitwerking van deze oefeningen wordt in de les besproken. Deel I Dit deel gaat over het installeren van de ontwikkelomgeving en de inrichting ervan. Deel 2 In dit deel ga je consoleapplicaties programmeren. Hier komen vooral de elementaire programmeerprincipes aan bod en leer je ObjectgeOriënteerd Programmeren (OOP). Deel 3 In deel 3 ga je aan het werk met Windows Forms. Hier wordt ook het werken met een database en het programmeren in drie lagen (3-tier of three-tier) besproken.

Deel 4 Games zijn leuk. Daarom ga je in dit deel kijken hoe je eenvoudig een 2D-game kunt maken in C#.

Deel 5 In het vijfde en laatste deel komt WPF aan de beurt. LET OP In dit lesmateriaal wordt uitgegaan van een basiskennis C# die in de colleges ASP.NET is opgebouwd. In het lesmateriaal staan regelmatig teksten die ingevoerd moeten worden op de computer. Deze teksten zijn in een ander lettertype weergegeven zodat het duidelijker is wat er nu wel of juist niet moet worden getypt. Gewone tekst

Tekst die ingevoerd moet worden. Boxen met tekst erin, zoals hierboven, worden gebruikt om belangrijke punten nog eens extra onder de aandacht te brengen. Deze opmerkingen/commando's moet je beheersen om verder te kunnen gaan met de lesstof. In het lesmateriaal wordt het volgende symbool gebruikt. Dit geeft aan dat er een handeling verricht moet worden.


Deel I

Installatie en inrichting Visual Studio 2015


1 Visual Studio 2013/2015 1.1 Inleiding Afgelopen jaar ben je bezig geweest met het maken van websites in ASP/C#. Vanaf dit moment ga je verder met het maken van zogenoemde standaloneapplicaties. In dit hoofdstuk komt een aantal belangrijke termen die je nodig hebt bij het ontwikkelen van applicaties kort aan bod. Daarnaast ga je in dit hoofdstuk kijken naar de ontwikkelomgeving VS2013. Deze tool heeft verschillende hulpmiddellen die je kunt gebruiken om straks nog beter en sneller applicaties mee te ontwikkelen. Voor degene die Visual Studio 2015 willen gebruiken is dat mogelijk. Het uiterlijk van versie 2013 en 2015 verschilt slechts minimaal van elkaar. Na bestudering van dit hoofdstuk ben je tot het volgende in staat. • Omschrijven wat een applicatie is. • Aangeven wat een programmeertaal is. • Omschrijven wat het nut is van het .NET Framework en welke versies ervan zijn. • Het kunnen configureren van Visual Studio 2013 voor het gebruik van C#. 1.2 Wat is een applicatie? Je kunt de volgende definitie gebruiken. Een applicatie is een verzameling opdrachten die door een computer uitgevoerd kan worden. Wanneer je een applicatie opstart, loopt de computer alle instructies/commando’s af (in volgorde/sequentieel) totdat het einde van de lijst is bereikt. Je applicatie stopt als het einde is bereikt of door interactie met een gebruiker. Een gebruiker kan bijvoorbeeld op een kruisje drukken om het venster/de applicatie af te sluiten. Je gaat in deze lessen applicaties schrijven in de programmeertaal C#. 1.3 Wat is een programmeertaal? Om te communiceren met mensen gebruik je een taal. Dit kan bijvoorbeeld Nederlands, Engels of gebarentaal zijn. Een programmeertaal is in feite niets anders als bijvoorbeeld Nederlands. Je kunt ervan uitgaan dat mensen die in Nederland wonen de taal Nederlands spreken. Als je iets wilt uitleggen kun je dit dan ook doen in deze taal. Ga je echter Nederlands gebruiken om in China iets uit te leggen, dan snappen de meeste mensen daar niet wat je bedoelt. Zij spreken deze taal namelijk niet.


Bij een programmeertaal werkt het eigenlijk hetzelfde. Je schrijft in een bepaalde taal opdrachten die de computer moet uitvoeren. Het probleem is echter dat je een computer alleen direct kunt aansturen met binaire reeksen. Dit noem je machine-instructies. Elke computer (= CPU) beschikt over een vooraf ingebouwde set van machine-instructies. Toen de eerste computers gemaakt werden, moesten programmeurs applicaties maken in binaire reeksen. Het was snel duidelijk dat dit te complex was en dat er hierdoor veel fouten ontstonden. Je moet maar eens proberen om een reeks van nullen en enen te onthouden en foutloos in te typen. De eerste programmeertaal moest hierin uitkomst gaan bieden. De taal Assembler werd ontwikkeld. Deze taal verving de binaire machine-instructies door te begrijpen instructies. Het probleem van deze taal is dat een programma voor een bepaalde CPU werd geschreven. Zat er in de computer een andere CPU, dan werkte het programma niet. Om dit probleem te ondervangen ging men zogenoemde hogere programmeertalen ontwikkelen. C# is een van de hogere programmeertalen. Je kunt in deze taal een applicatie maken die op diverse CPU’s gebruikt kan worden. Daar zorgt de compiler voor. In feite is een compiler niets anders dan een vertaler die de C#-programmacode omzet naar machinecode. In Visual Studio is de compiler een onderdeel van de ontwikkelomgeving. Hierboven staat kort weergegeven wat een programmeertaal is en hoe deze functioneert. Dit verhaal is niet volledig. Wil je hier meer over te weten komen, dan kun je op internet meer dan genoeg informatie vinden. http://nl.wikipedia.org/wiki/Programmeertaal http://www.computerwoorden.nl/programmeertalen-woordenboek.htm 1.4 Het .NET Framework De programmeertaal C# werkt op het .NET Framework. Wat houdt dit nu in? Als je een applicatie gaat maken, dan moet je alles programmeren. Om het programmeurs iets makkelijker te maken, kunnen deze gebruikmaken van verschillende bibliotheken waar het een en ander al is voorgeprogrammeerd. Het .NET Framework is in feite een verzameling van bibliotheken die je als programmeur kunt gebruiken. Een nadeel van een bibliotheek is echter dat het ook op de computer moet

http://nl.wikipedia.org/wiki/Programmeertaal

http://www.computerwoorden.nl/programmeertalen-woordenboek.htm


komen waarop de applicatie dient te draaien. Het .NET Framework wordt standaard al bij Windows meegeleverd zodat dat geen probleem meer is. Het .NET Framework heeft nog een ander voordeel. In tegenstelling tot programmeertalen die geen gebruikmaken van een framework, maakt het in het .NET Framework niet uit in welke taal je programmeert. Alle talen worden omgezet naar een CLR (Common Language Runtime). Een applicatie in Visual Basic levert dus dezelfde gecompileerde code op als een applicatie geschreven in C#. De CLR-code wordt hierna weer omgezet naar machinecode. Dit houdt in dat je een applicatie kunt ontwikkelen in verschillende .NET talen. In deze reader komt dit echter niet aan bod. Als je een compleet overzicht wilt hebben van alle .NET-talen, dan kun je hiervoor de volgende website gebruiken. http://www.dotnetpowered.com/languages.aspx 1.5 Wat is Visual Studio 2015? VS 2015 is de omgeving waarin je applicaties in C# schrijft. In deze omgeving zit een compiler die jouw applicatie omzet naar machinecode. Ook zijn er verschillende hulpmiddelen beschikbaar die het maken van applicaties makkelijker/minder tijdrovend maken. Als je alleen de beschikking hebt over Visual Studio 2013, dan kun je alle opdrachten maken. De verschillende schermafdrukken kunnen dan wel afwijkend zijn.

VS 2015 is een zogenaamde IDE (Integrated Development Environment). Een omgeving waarin alle gereedschappen (tools) voor handen zijn om een applicatie of project te ontwikkelen.

http://www.dotnetpowered.com/languages.aspx


1.6 Het installeren van Visual Studio Zoals je hebt kunnen lezen in de vorige paragrafen heb je minimaal Visual Studio 2013 Professional nodig. Mocht je eventueel nog een Express-versie van Visual Studio gebruiken, dan kun je VS 2015 er gewoon naast installeren. Ook na de installatie van VS 2015 zal de Express-versie nog werken. Tijdens de installatie wordt een uitgeklede versie van SQL Express geïnstalleerd. Daardoor kun je problemen met de versie van SQL krijgen. Dit voorkom je door zelf eerst een juiste en volledige versie van SQL Express te installeren. LET OP

Installeer eerst SQL Server Express 20xx. Je moet hiervoor gebruikmaken van Bijlage A uit de reader van SQL.

Je kunt Visual Studio zelf downloaden bij Dreamspark. Je hebt hiervoor een account gekregen bij de start van leerjaar 1. Ook is er een dvd gemaakt waarop alle benodigde installatiebestanden staan. Je kunt deze dvd vragen aan de docent. 1.7 Systeemvereisten en installatie Door de beperkingen van oudere versies van Microsoft Windows kan Visual Studio 2013 alleen gebruikt worden met de volgende versies. • Windows Server 2008 R2 SP1 (x64) • Windows Server 2012 (x64) • Windows 7 (x86 en x64) • Windows 8 (x86 en x64) • Windows 8.1 (x86 en x64) • Windows 10 (x86 en x64) Hardware specificaties • Minimaal: 1.6 GHz CPU • 1 GB RAM • DirectX 9 compatible videokaart met minimaal 1024 x 768 resolutie • 10 GB beschikbare ruimte op de harddisk Visual Studio 2015 • Vanaf Windows Server 2012 R2 (x64) • Vanaf Windows 8.1 (x86 en x64) • Vanaf Internet Explorer 10


Doorloop de volgende stappen om VS 2015 te installeren. Start de setup op als administrator. Als je de setup opstart als gewone gebruiker wordt niet alles geïnstalleerd en krijg je

problemen met bepaalde functionaliteiten.

Als je de bovenstaande melding krijgt, heb je nog niet internet Explorer 10 of hoger geïnstalleerd. Dit is belangrijk als je bepaalde functies binnen VS wilt gebruiken. Installeer eerst IE 10 of hoger en kies dan de optie Retry.


Kies de optie Typical en druk op Install. VS zal nu worden geïnstalleerd.

Na enige tijd verschijnt het volgende scherm.


VS is nu geïnstalleerd. Je kunt nu VS starten door op LAUNCH te klikken. VS start op en komt met de vraag om een online Microsoft account te koppelen aan VS.

Als je dit doet, dan kun je programmacode online beheren en delen. Dit komt in deze reader verder niet aan bod.

Mocht je nog geen Microsoft account hebben, dan kun je deze direct aanmaken.


Voer het e-mailadres in dat is gekoppeld aan je Microsoft account en druk op Continue.

Je krijgt de bovenstaande melding. Na enige tijd kom je in het startvenster van VS. In de

rechter bovenhoek kun je zien dat je account is verbonden (smiley).


Visual Studio is nu geïnstalleerd en gereed voor gebruik. LET OP

Je moet Visual Studio en SQL Management Studio altijd als administrator opstarten. Dit zal in het vervolg niet meer apart vermeld worden.

Je bekijkt hoe de werkomgeving is opgebouwd en wat je waar kunt terugvinden. Dit kun je echter alleen maar doen tijdens het maken van een applicatie. Je kiest nu voor een zogenaamd Windows Form-applicatie om het een en ander duidelijk te maken. Na dit hoofdstuk begin je echter met het programmeren van niet-grafische applicaties ( consoleapplicaties). Een applicatie heet in VS een project. 1.8 Beginnen met een project Voor je gaat programmeren, moet je niet vergeten dat je straks een hele verzameling applicaties krijgt. Om ervoor te zorgen dat al deze applicaties terug te vinden zijn, maak je een speciale folder aan waarin je je projecten gaat bewaren. Maak de volgende folder aan op jouw dataschijf.

x:\Applicaties C-Sharp Ga in VS2015 naar de menuoptie File, New, Project.


Je moet het soort project aangeven dat je wilt gaan maken. Kies voor de optie Windows Forms Application. Geef dit project de naam Inrichten.

Zorg ervoor dat dit project wordt opgeslagen in de zojuist gemaakte map. Kijk hieronder voor de overige instellingen.

Druk op OK. Je krijgt het hoofdvenster te zien waarbinnen je de applicatie gaat realiseren. In de volgende paragrafen ga je deze omgeving zo instellen dat dit er bij iedereen hetzelfde uit gaat zien. Je hoeft dit slechts eenmaal te doen, omdat de instellingen worden opgeslagen voor de volgende projecten.


1.9 Het configureren van VS2015 Er is een aantal onderdelen op het scherm dat je gaat instellen (configureren) om straks nog makkelijker met de ontwikkelomgeving te kunnen werken.

De Toolbox

Aan de linkerkant van je scherm staat de Toolbox ingeklapt. Als je hier met je muis op gaat staan, dan ‘klapt’ de Toolbox open. Als je dit voor de eerste keer doet, kan dit enige tijd in beslag nemen. Wanneer de muis van de Toolbox wordt afgehaald, zal deze weer verdwijnen.

Omdat de Toolbox bij het ontwikkelen van Windows Form- applicaties veelvuldig gebruikt gaat worden, is het aan te bevelen om deze standaard geopend/uitgeklapt zichtbaar te hebben. Dit kun je doen door op de punaise te klikken. Hiermee zet je de Toolbox als het ware vast.

Toolbox is vastgezet

Klik op de punaise om de Toolbox standaard uitgeklapt weer te geven. Je kunt zelf de breedte van de Toolbox aanpassen door met de muis op de rechterrand te gaan staan en deze te verslepen.

Als je de Toolbox per ongeluk hebt afgesloten, dan kun je deze weer zichtbaar maken door op de knop Toolbox te klikken of door de menuoptie: View, Toolbox.

De Solution Explorer De Solution Explorer kun je aan de rechterkant van je scherm terugvinden. Deze weergave is reeds juist. Mocht je dit venster afsluiten, dan kun je dit venster weer zichtbaar maken door de menuoptie: View, Solution Explorer.


De Properties Window Dit venster is een van de meest gebruikte onderdelen van VS2015. Als het venster niet zichtbaar is, dan kun je dit venster openen door de menuoptie: View, Properties Window. Zorg ervoor dat het Properties Window (eigenschappenvenster) standaard altijd

zichtbaar is. Doe dit door op de punaise te klikken. Het eigenschappenvenster zal standaard altijd aan de rechterkant onder de Solution Explorer zichtbaar worden.

Het Options menu Je gaat nog twee standaardinstelling aanpassen. Hiervoor maak je gebruik van het Options menu. Als eerste zorg je ervoor dat standaard alle applicaties/projecten die je gaat maken in jouw folder komen te staan. Ga naar de menuoptie Tools, Options. Ga naar de optie Projects and Solutions en kies de subcategorie General. Pas de bestandslocatie aan van ‘Visual Studio projects location’. Verander deze in de

folder die jij hebt aangemaakt.

x:\ Applicaties C-Sharp

Properties Window


Je hoeft niet steeds de locatie aan te passen bij het aanmaken van een nieuw project. De tweede instelling die je aanpast is het toevoegen van een regelnummering. Tijdens het coderen is het makkelijk om te verwijzen naar regelnummers in je documentatie. Ook bij het oplossen van fouten zijn regelnummers handig. Ga naar de optie Tekst Editor en kies de subcategorie All Languages. Vink de optie Line numbers aan en druk op OK.

1.10 De Form Designer en de Code Designer In VS2015 werk je vooral met de twee onderdelen: Form en Code Designer. Op dit moment zie je de zogenaamde Form Designer. Hierin kun je grafisch jouw applicatie opmaken. Naast dit grafische scherm heb je ook een codescherm waarin de werkelijke programmacode komt te staan. Dubbelklik op het formulier Form1 om in het codescherm te komen. Je krijgt dan het

volgende scherm te zien.


Boven in het scherm wordt een nieuw tabblad weergegeven. Je kunt eenvoudig wisselen tussen de twee weergaven (form en code) door bovenaan op de verschillende tabbladen te klikken.

Bij wat grotere applicaties kun je tabbladen sluiten door deze te selecteren en op het kruisje rechts te klikken. Als je per ongeluk een tabblad hebt afgesloten dat je toch nog nodig blijkt te hebben, dan kun je dit weer openen door dubbel te klikken op het object in de Solution Explorer. TIP

Sluit de verschillende tabbladen wel af voor je stopt met je project. Vooral bij een wat groter project kan anders het openen van dit project heel lang duren. VS gaat dan namelijk ook meteen alle tabbladen openen die vorige keer geopend waren.

1.11 Wat is er nog meer? Er is nog veel meer mogelijk in VS 2015 dan dat je tot nu toe hebt kunnen zien. Zo kom je nog verschillende mogelijkheden tegen in de loop van deze reader. De hulpmiddelen voor het maken van een formulier komen aan het begin van deel III aan bod.


Deel II

Consoleapplicaties


2 Een consoleapplicatie maken in C# 2.1 Inleiding In de vorige periode heb je geleerd om te gaan met ASP.net. Hiervoor maakte je gebruik van de programmeertaal C#. In dit hoofdstuk ga je een standaloneprogramma maken in C#. Dit doe je door een consoleapplicatie te maken. Een consoleapplicatie is een programma dat wordt uitgevoerd in een DOS-box. Maar waarom zou je een applicatie maken dat in een DOS-box wordt uitgevoerd? Tegenwoordig zijn toch alle applicaties grafisch? Dit heeft twee redenen. 1 Consoleapplicaties komen bijvoorbeeld nog vaak voor op de achtergrond als een

service.

2 In deze reader worden consoleapplicaties gebruikt om je beter te leren programmeren. Je wordt dan minder snel afgeleid door alle ‘toeters en bellen’ van de grafische applicaties. Pas na een aantal hoofdstukken ga je werken met Windows Form applicaties.

Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen uitleggen wat een consoleapplicatie is. • Het kunnen werken met invoer en uitvoer bij de console. • Het kunnen werken met willekeurige getallen. • Het kunnen toepassen van de beslissingsstructuur if. • Het kunnen werken met de lusstructuur while. 2.2 Wat is een consoleapplicatie? Bij dit hoofdstuk staat op je ELO of schoolnetwerk een zipfile Spelletje. In deze applicatie moet je door het oplossen van raadsels verder komen. Dit is een goed voorbeeld van een consoleapplicatie. In de jaren 80 werd dit soort spellen vaak gespeeld op de pc. Een goed voorbeeld hiervan is ‘The hitchhiker’s guide to the galaxy’, uitgebracht in 1984. Het beginscherm is weergegeven op de volgende pagina.


Pak het zipbestand uit op je eigen computer. Dubbelklik op het uitgepakte bestand Setup om de applicatie te

installeren en installeer de applicatie. Speel de applicatie en schrijf de code op die je krijgt aan het einde van het spelletje. In dit hoofdstuk ga jij ook een spelletje maken. Je gaat het spelletje Hoger en Lager maken. In dit spelletje kiest de computer een willekeurig getal tussen de 1 en de 100. Hierna moet de gebruiker het getal proberen te raden. Als het getal niet juist is, krijgt de gebruiker te zien of de poging te hoog of te laag was. Bij het raden van het getal moet de gebruiker aangeven of hij wil stoppen met het programma of juist wil doorgaan.


Hieronder is het activiteitendiagram weergegeven van deze applicatie.

2.3 Het object Console In het verleden was de interactie voor grafische besturingssystemen tussen de gebruikers en de computer gebaseerd op tekst. De combinatie van tekst en toetsenbord is beter bekend als Console. In C# is alles een object. Als je een consoleapplicatie wilt maken, dan gebruik je het object Console. De namen van classes beginnen ALTIJD met een hoofdletter. Als je iets op het scherm wilt laten weergeven in een consoleapplicatie, dan gebruik je het volgende commando. Console.WriteLine(“Hello World”); Je begint met de Namespace Console. Binnen deze Namespace gebruik je de methode WriteLine. Deze methode zorgt ervoor dat de tekst die tussen de aanhalingstekens staat, wordt weergegeven. Je kunt ook de methode Write gebruiken. Console.Write(“Hello ”); Console.Write(“World”);


Je zult zien dat je hetzelfde resultaat als bij de methode WriteLine. Het verschil is dat je bij de methode Write je steeds verder gaat op dezelfde regel. Als je deze code uitvoert, dan zul je zien dat de DOS-box meteen weer verdwijnt. Om de DOS-box zichtbaar te laten blijven, moet je ervoor zorgen dat je programma wacht op een invoer van de gebruiker. Je gebruikt hiervoor de volgende code. Console.ReadKey(); 2.4 Het vraagprogramma Je hebt in het kort kunnen lezen wat een consoleapplicatie is en wat de meest gebruikte commando’s zijn. Je gaat een consoleapplicatie maken waarin je de naam vraagt van een persoon. Als deze persoon zijn naam heeft ingegeven, dan laat je de naam zien met een begroeting. Open Visual Studio 2015 (in het vervolg VS).

Ga naar de menuoptie File, New, Project.

Kies voor de optie Console Application.


Geef deze applicatie de naam HogerLager en druk op OK. Je krijgt het volgende scherm te zien. In dit scherm komt de programmacode te staan

van je spelletje.

Neem de volgende code over (let op het hoofdlettergebruik).

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threadins.Tasks; namespace HogerLager { class Program { static void Main(string[] args) { // Consoleapplicatie voorbeeld tekst // Hoofstuk 2 par 4 // Gemaakt door: R. Meijerink // September 2015

string UserName; Console.WriteLine("Geef je naam: "); UserName = Console.ReadLine(); Console.WriteLine("Hallo, {0}", UserName); Console.WriteLine("Druk op een toets"); Console.ReadLine();


} }

} Voer het programma uit door op de knop Start te klikken. Je kunt

hiervoor ook de <F5> gebruiken.

Je hebt een programma gemaakt dat vraagt om een naam en dat de ingevoerde naam weer laat zien. Alle programmaregels zullen duidelijk zijn, behalve waarschijnlijk de volgende. Console.WriteLine("Hallo, {0}", UserName); Je wilt dat achter de tekst Hallo de naam wordt weergegeven die je hebt ingevoerd. Dit doe je door aan te geven dat er een variabele (parameter) moet worden getoond: {0}. Console.WriteLine("Hallo, {0}{1}{2}", Voornaam, Tussen, Achternaam); Hier worden de variabelen Voornaam, Tussen en Achternaam weergegeven op de plaats van {0}, {1} en {2}.

2.5 Tekstopbouw in een consoleapplicatie Je hebt in de vorige paragraaf gezien hoe je een tekst kunt laten weergeven op het scherm. In deze paragraaf ga je ook wat opmaak toepassen, zoals het werken met tabs of enters.

Pas de huidige code aan naar de volgende code.

using System; using System.Collections.Generic;


using System.Linq; using System.Text; using System.Threadins.Tasks; namespace HogerLager { class Program { static void Main(string[] args) { // Consoleapplicatie tekstopmaak // Hoofstuk 2 par 5 // Gemaakt door: R. Meijerink // September 2015

string Naam; string Leeftijd; double Bedrag; Console.WriteLine("Geef je naam?"); Naam = Console.ReadLine(); Console.WriteLine("Geef je leeftijd?"); Leeftijd = Console.ReadLine(); Console.WriteLine("Geef een geldbedrag?"); Bedrag = Convert.ToDouble(Console.ReadLine()); Console.WriteLine(("").PadRight(25, '-')); Console.WriteLine("De naam is: \n {0}", Naam); Console.WriteLine("De leeftijd is: \t {0}", Leeftijd); Console.WriteLine("Het bedrag is: {0,8:c}", Bedrag); Console.ReadKey(); } } }

Start het programma en kijk wat er gebeurt.


Je ziet dat er verschillende codes in staan die ervoor zorgen dat de tekst er iets anders uit komt te zien. \n Geeft een enter. \t Plaatst een tab. ("").PadRight(25, '-') Plaatst een lijn bestaande uit 25 ‘-‘. {0,8:c} Laat het ingevoerde getal zien als een bedrag.

Omdat de voorbeelden zijn gemaakt op een Engelstalige versie van Windows 7 Professional en de landinstellingen niet zijn aangepast, verschijnt het bedrag in dollars op de Amerikaanse schrijfwijze. Dit kun je aanpassen door de landinstellingen in Windows te veranderen. 2.6 Uitleg Hoger en Lager In deze paragraaf wordt besproken hoe je het spel Hoger en Lager moet maken. Voordat je begint met het spelletje moet je eerst weten welke variabelen je allemaal nodig hebt. Getal = willekeurig getal dat de computer bepaalt. Raden = invoer gebruiker Als je begint met programmeren start je vaak met het aanmaken van de variabelen. Wis alle code die staat tussen de accolades van:

static void Main(string[] args) { } Neem de volgende code over.


static void Main(string[] args) {

// Consoleapplicatie Hoger en Lager // Hoofdstuk 2 par 6 // Gemaakt door: R. Meijerink // September 2016

int Getal = 0;

int Raden = 0; }

Je maakt de variabelen Getal en Raden aan die je vult met de waarde 0.

Nu moet je ervoor zorgen dat de computer een willekeurig getal kiest. Neem de

volgende code over en plaats deze onder de code voor het aanmaken van de variabelen.

Random Willekeur = new Random(); Raden = Willekeur.Next(100);

Je maakt een instantie van de klasse Random. Deze instantie geef je de naam Willekeur. Hierna laat je Raden vullen met een random getal tussen de 1 en 100.

Nu moet er een lus komen in je spel. Zolang de gebruiker niet het juiste getal heeft

geraden moet het spelletje doorgaan. Plaats onder de zojuist toegevoegde code de volgende regels. while (Getal != Raden) { } Tussen de accolades komt de code waarin de gebruiker wordt gevraagd om een getal in

te geven. Hierna moet de computer controleren of het getal te hoog, te laag of juist is. Neem de volgende code over en plaats deze tussen de accolades van de while-loop. Console.WriteLine("Geef een getal"); Getal = Convert.ToInt32(Console.ReadLine()); if (Getal > Raden) { Console.WriteLine("Het getal is te hoog"); } else if (Getal < Raden) { Console.WriteLine("Het getal is te laag");


} else { Console.WriteLine("Proficiat!! het is goed"); Console.WriteLine("\nDruk op een toets"); Console.ReadKey();

} Voer het programma uit en kijk of het spelletje goed werkt. Je hebt nu het spel Hoger en Lager gemaakt. Hieronder is de volledige code weergegeven van het programma. Werkt het niet of krijg je een foutmelding? Kijk dan nog eens goed naar de code. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace HogerLager { class Program { static void Main(string[] args) { // Consoleapplicatie Hoger en Lager // Hoofdstuk 2 par 6 // Gemaakt door: R. Meijerink // September 2016 int Getal = 0; int Raden = 0; Random Willekeur = new Random(); Raden = Willekeur.Next(100); while (Getal != Raden) { Console.WriteLine("Geef een getal"); Getal = Convert.ToInt32(Console.ReadLine()); if (Getal > Raden) { Console.WriteLine("Het getal is te hoog"); } else if (Getal < Raden)


{ Console.WriteLine("Het getal is te laag"); } else { Console.WriteLine("Proficiat!! het is goed"); Console.WriteLine("\nDruk op een toets"); Console.ReadKey(); } } } } } 2.7 Oefening 1 Je hebt het spelletje Hoger en Lager gemaakt. Het is alleen erg jammer dat je het maar een keer kan spelen. Het zou natuurlijk veel gebruikersvriendelijker zijn als het programma zelf zou vragen of je nog een keer zou willen spelen. Deze functionaliteit is al meegenomen in het activiteitendiagram op bladzijde 25. Breid het spelletje zo uit dat de gebruiker de vraag krijgt of hij/zij nog een keer wil spelen als het getal geraden is. 2.8 Samenvatting In dit hoofdstuk heb je voor het eerst gewerkt met de ontwikkelomgeving van C#. Je hebt consoleapplicaties gemaakt door gebruik te maken van de klasse Console. Daarnaast heb je ook gemerkt dat je al heel snel een programma kunt schrijven, omdat je al gewerkt hebt met ASP.NET. Je moet nu opdracht C1 kunnen maken. Als je het scherm in een consoleapplicatie weer leeg wilt maken, kun je het volgende commando gebruiken. Console.Clear();


3 String manipulatie en arrays 3.1 Inleiding In dit hoofdstuk ga je werken met strings en arrays. Alle teksten die je verwerkt in je programma zijn strings. Je komt dus al snel in aanraking met strings. In dit hoofdstuk pas je aan de hand van een spelletje allerlei veranderingen toe op strings. Daarnaast komt het onderdeel Arrays aan bod. Arrays worden veel toegepast in het programmeren. Toch vinden veel mensen het een lastig onderwerp. Aan de hand van wat voorbeeldjes wordt geprobeerd dit onderwerp wat te verduidelijken. 3.2 Hoofdletters en kleine letters C# is case sensitive (hoofdlettergevoelig). Als je bijvoorbeeld vraagt of een gebruiker nogmaals een spelletje wilt spelen en de gebruiker antwoordt ja, dan kan dat op de volgende manieren worden ingegeven. JA Ja jA ja Alle antwoorden zijn goed. Voor C# zijn het echter 4 verschillende antwoorden. Je zou nu een if … else of switch … case kunnen gebruiken. Dit wordt echter een stuk lastiger als de gebruiker nee zou antwoorden. Dan zijn er namelijk 8 verschillende schrijfwijzen. Je kunt dan beter het antwoord van de gebruiker zo gaan bewerken dat bijvoorbeeld alles in hoofd- of kleine letters komt te staan. Hiervoor kun je de methodes ToLower en ToUpper gebruiken. Maak een nieuwe consoleapplicatie met als naam WerkenMetTekst. Neem de volgende code over. static void Main(string[] args) { string Voorbeeld = "Dit Is De String"; Console.WriteLine("Klein: \t{0}", Voorbeeld.ToLower()); Console.WriteLine("Hoofd: \t{0}", Voorbeeld.ToUpper()); Console.ReadKey(); { Voer het programma uit.


Je ziet dat het programma de string laat zien in allemaal kleine letters en erna in allemaal hoofdletters. Zo is er nog een aantal stringbewerkingen die je kunt toepassen. Voorbeeld.Replace("e", "*")

De methode Replace vervangt het aangegeven teken door een ander teken. Is het voorbeeld wordt de letter e vervangen door een *. Je kunt ook meer tekens tegelijk laten vervangen door een of meer tekens.

Voorbeeld.Length

De methode Length geeft het aantal tekens waaruit de string bestaat. Voorbeeld.Trim()

De methode Trim haalt alle spaties die aan het begin en einde van de string staan weg.

Voorbeeld.Remove(3)

De methode Remove wist alle tekens vanaf de positie die is aangegeven. Voorbeeld.Contains("is")

De methode Contains zoekt in de string of de aangegeven tekens aanwezig zijn. De waarde die je terugkrijgt is een boolean (true/false).

Je kunt zelf alle verschillende combinaties testen. Pas de code zo aan zoals als volgt is weergegeven.


static void Main(string[] args) { string Voorbeeld = "Dit Is De String"; Console.WriteLine("Klein: \t{0}", Voorbeeld.ToLower()); Console.WriteLine("Hoofd: \t{0}", Voorbeeld.ToUpper()); Voorbeeld=Voorbeeld.Replace("Is", "Was"); Console.WriteLine("Replace gebruikt: \t{0}", Voorbeeld); Console.WriteLine("Het aantal tekens: \t{0}",Voorbeeld.Length); Console.BackgroundColor = ConsoleColor.White; Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("En dan wat kleur."); Console.ReadKey(); }

Voer de applicatie uit en kijk goed naar de code en het resultaat.

Je ziet dat er ook met kleur gewerkt kan worden. Meer informatie over het gebruik van kleur in de console kun je vinden door de volgende link te gebruiken. https://msdn.microsoft.com/en-us/library/system.console.foregroundcolor(v=vs.110).aspx 3.3 Arrays In de vorige paragraaf zag je allerlei bewerkingen die op een string zijn toe te passen. In dit hoofdstuk maak je kennis met een speciaal object, de array. Een array is een datastructuur dat een serie waarden met hetzelfde datatype bevat. Elke waarde in een array is benaderbaar door gebruik te maken van indexnummers. Je kunt een array dan ook voorstellen als een Excelblad.

https://msdn.microsoft.com/en-us/library/system.console.foregroundcolor(v=vs.110).aspx


Omdat een array een object is moet het ook als een object worden aangeroepen. string[] weekdagen = new string[7]; weekdagen[0] = "Zondag"; weekdagen[1] = "Maandag"; weekdagen[2] = "Dinsdag"; weekdagen[3] = "Woensdag"; weekdagen[4] = "Donderdag"; weekdagen[5] = "Vrijdag"; weekdagen[6] = "Zaterdag"; In de eerste regel wordt de array weekdagen gemaakt. Er kunnen maximaal 7 waarden in deze array worden opgeslagen. Daarna worden alle rijen gevuld met de dagen van de week. Een array-index start altijd bij 0. LET OP Het is niet mogelijk om in C# een array uit te breiden met extra gegevens (indexnummers). Hiervoor moet je gebruikmaken van andere objecten zoals een List. Je hebt hierboven gezien hoe je een array kunt aanmaken en kunt vullen met gegevens. Hieronder worden nog eens kort alle onderdelen herhaald en uitgelegd. De volgende instructie declareert een array van cijfers. int[] rapportcijfers; Het aantal variabelen, in dit geval getallen, dat je in de array kunt plaatsen is nog niet bekend. Je kunt dus nog niets in de array plaatsen. Met de instructie op de volgende pagina los je dat probleem op. rapportcijfers = new int[3]; Nu kun je drie cijfers in de array plaatsen. Je moet er rekening mee houden dat de index van een array altijd met 0 start. Je voegt nu als volgt drie cijfers toe. rapportcijfers[0] = 5; rapportcijfers[1] = 7; rapportcijfers[2] = 6; Als je probeert een vierde cijfer in de array te plaatsen gaat het mis. Je krijgt hierover echter pas een foutmelding tijdens het debuggen. Maak een nieuw consoleproject aan met als naam: WerkenMetArray.


Neem de volgende code over.

static void Main(string[] args) { string Woordje; Console.WriteLine("Type een woord in"); Woordje = Console.ReadLine(); Console.WriteLine("Het woord is: {0}", Woordje); Console.WriteLine("Nu onder elkaar."); for (int i=0;i<Woordje.Length;i++) { Console.WriteLine(Woordje[i]); } Console.WriteLine("Nu andersom"); for (int i=Woordje.Length-1;i>=0;i--) { Console.Write(Woordje[i]); } Console.ReadKey(); }

Voer de applicatie uit.

In deze code vraagt de applicatie aan de gebruiker om een woord. Dit woord zal dan op twee verschillende manieren worden weergegeven. Hierbij wordt gebruikgemaakt van de mogelijkheid om een string uit te lezen als een array.


Stel je hebt de variabele Vak. In deze variabele zit de tekst: C-Sharp. Dan kun je de eerste letter als volgt opvragen.

Console.WriteLine(Vak[0]); Daarnaast is er gebruikgemaakt van een for-lus die ervoor zorgt dat de letters een voor een weergegeven kunnen worden. LET OP Je kunt een string alleen uitlezen als een array. Het vullen van de string kan niet als array. 3.4 Samenvatting In dit hoofdstuk heb je geleerd om te werken met stringmanipulaties en arrays. Voor je arrays goed kunt gebruiken moet je er veel mee oefenen. Daarnaast kun je met arrays nog zoveel meer dat er in deel II een volledig hoofdstuk over dit onderwerp is opgenomen. In opdracht C2 moet er een woordraadspelletje gemaakt worden. Hiervoor zul je alle kennis van dit hoofdstuk nodig hebben.


4 Het wat en waarom van OOP 4.1 Inleiding Objectgeoriënteerd programmeren (OOP) is in de jaren ‘90 van de vorige eeuw erg in opkomst gekomen. Voor die tijd was het lineair- of proceduregericht programmeren. Omdat er echter steeds meer applicaties nodig waren, was er grote behoefte aan programmeertalen die makkelijker en goedkoper te onderhouden waren. Ook het hergebruik van stukken code was belangrijker geworden. Hieruit is in feite het objectgeoriënteerd programmeren ontstaan. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen aangeven wat OOP is. • Het kunnen maken van een klasse. • Het kunnen maken van een object en deze kunnen benaderen in C#. 4.2 Wat is OOP? In de inleiding heb je al kunnen lezen waarom OOP is ontstaan. Maar wat is OOP nu precies? OOP is niets anders dan een manier van programmeren. Bij programmeren geef je door middel van code opdrachten aan een computer die uitgevoerd dienen te worden. Bij het programmeren in OOP wordt een applicatie opgebouwd als een verzameling van objecten die allemaal behoren tot een soort of klasse. De methodes in zo’n klasse horen logisch bij elkaar en zijn daarom makkelijker terug te vinden. Waarschijnlijk is nu nog steeds niet helemaal duidelijk wat OOP is. Aan het eind van dit hoofdstuk zal het een stuk duidelijker zijn. Je hebt dan een eenvoudig voorbeeld gemaakt waardoor je in praktijk hebt kunnen zien wat OOP inhoudt. In de komende hoofdstukken ga je dieper in op de diverse principes van OOP. Begrippen die hierbij onder andere aan bod komen zijn de volgende. • Object • Klasse (Class) • Eigenschappen (properties) • Overerving (inheritance) • Inkapseling (encapsulation) • Overloading • Overriding Tegenwoordig zijn alle belangrijke programmeertalen objectgeoriënteerd.


Voorbeelden van deze talen • C# • C++ • Java • PHP (vanaf versie 5) • Delphi (Pascal) • Visual Basic Voorbeeld van niet-objectgeoriënteerde talen • Assembler • C • Basic • (ANSI) Pascal • (ANSI) Cobol 4.3 Objecten of klassen Objectgeoriënteerd programmeren wordt ook wel het programmeren van klassen genoemd. Dit komt doordat alle functionaliteit die je aan een object wilt geven eerst in een klasse moet programmeren. De termen object en klasse worden vaak door elkaar en voor hetzelfde gebruikt. Dit is echter niet juist. Er is wel degelijk een verschil tussen een object en een klasse. Je gaat eerst eens kijken wat objecten en klassen eigenlijk zijn.

Object Een object is een instantie van een klasse. Bijvoorbeeld je eigen auto is een object van de klasse auto. Maar de auto van je vriend(in) is dat ook. En toch zijn ze beide verschillend.

Klasse Een klasse is een sjabloon waarvan objecten gemaakt kunnen worden. De klasse definieert hoe de objecten er uit gaan zien aan de hand van eigenschappen (properties). Het gedrag van de objecten wordt vastgelegd in methoden (functies in klassieke programmeertalen). Je kunt dus zeggen dat de klasse een bouwtekening is en een object het gebouwde huis. Een derde begrip dat hierbij meteen aan de orde komt, is inkapseling (encapsulation). Dit begrip heeft betrekking op de attributen en methoden. Het wil namelijk zeggen dat bij OOP de attributen van een object niet rechtstreeks opgevraagd of gewijzigd kunnen worden, maar dat dit altijd via de methodes gebeurt. Dit wordt gedaan om ervoor te zorgen dat het object zelf de controle houdt over de waarde die in een eigenschap wordt weg geschreven. Stel, het object auto heeft een eigenschap snelheid.


Als je dan rechtstreeks het attribuut zou kunnen wijzigen zou je deze auto elke snelheid kunnen geven. Bijvoorbeeld ook een negatieve waarde. Door het via een methode te laten verlopen, kun je controleren of de waarde wel aan voorwaarden voldoet (bijvoorbeeld groter dan 0 en kleiner dan 190km). 4.4 Objecten maken Om in een programma iets te doen met een klasse moet er eerst een object van gemaakt worden. In de taal C# ziet het commando om een object te maken van een klasse er als volgt uit. <klasse> <object> = new <constructor>; Bij <klasse> wordt de naam van de klasse genoemd waar je een object van wilt maken. Vervolgens is <object> de naam van het object zoals je dat in je programmacode wilt gebruiken. Bij <constructor> vul je de naam in de van de constructor die uitgevoerd moet worden om het object aan te maken. Deze naam van de constructor is altijd gelijk aan de naam van de klasse, gevolgd door een open haak (en een sluit haak). Eventueel kunnen tussen de haakjes een of meer parameters staan. Een constructor is een bijzondere methode van een klasse. Deze methode wordt uitgevoerd op het moment dat je van een klasse een object maakt. Je kunt een constructor op twee manieren herkennen. 1 De constructor heeft dezelfde naam als de klasse. 2 Een constructor is de enige methode die geen waarden teruggeeft.

Bij het beschrijven van methodes komen we hier nog op terug. Een klasse kan meer constructors hebben. Ze moeten dan wel verschillen in het aantal of het datatype van de parameters. Dit principe noemen we overloading. Ook daar komen we in hoofdstuk 5 op terug. 4.5 De voorbeeldapplicatie Je hebt nu behoorlijk wat theorie gekregen die je waarschijnlijk nog niet helemaal duidelijk is. OOP is helaas een lastig begrip om uit te leggen. In deze paragraaf maak je een voorbeeldapplicatie waarin je de verschillende termen weer voorbij ziet komen. Maak een nieuwe consoleapplicatie met als naam: VoorbeeldOOP. Aan dit project voeg je de klasse auto toe. Zoals je weet is een klasse niets anders dan

een bouwtekening waarmee je straks een object kunt maken. Ga met je muis op de projectnaam (VoorbeeldOOP) staan in de Solution Explorer.


Druk dan op de rechtermuisknop en kies de optie: Add, Class.

Je krijgt het volgende venster te zien.

Geef de klasse als naam Auto.cs en druk op Add. De zojuist aangemaakte klasse wordt weergegeven.


Neem de volgende code over in de klasse.

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace VoorbeeldOOP { class Auto { private int snelheid = 0; private int maxSnelheid; public Auto() // de constructor { maxSnelheid = 180; } public int gasGeven() // methode die snelheid verhoogt { if (snelheid < maxSnelheid) { snelheid += 10; } else { Console.WriteLine("De max snelheid is bereikt"); } return snelheid;


} public int remmen()// methode die snelheid verlaagt { if (snelheid > 0) { snelheid -= 20; } else { Console.WriteLine("De auto staat al stil"); } return snelheid; } public void setMaxSnelheid(int snelh) { maxSnelheid = snelh; } } }

Je hebt nu een klasse gemaakt. Om deze klasse te gebruiken, moet je nog wat code toevoegen aan Program.cs.

Open Program.cs door op het tabblad te klikken.

Plaats de volgende code in Program.cs: static void Main(string[] args) { Auto audi = new Auto(); Auto bmw = new Auto(); bmw.setMaxSnelheid(220); for (int i = 0; i < 30; i++) { int snelheid = audi.gasGeven(); Console.WriteLine("De audi rijdt: " + snelheid + "km/uur"); snelheid = bmw.gasGeven(); Console.WriteLine("De bmw rijdt: " + snelheid + "km/uur"); Console.WriteLine(); } Console.ReadKey(); }


Start de applicatie en kijk wat er gebeurt.

In de volgende paragraaf staat de uitleg van de code. Zoals je kunt zien in het resultaat rijden er twee auto’s met verschillende maximumsnelheden. 4.6 De klasse auto De klasse auto is bedoeld om verschillende auto objecten te maken. Je hebt in de klasse vastlegd wat de eigenschappen van auto’s zijn en je gebruikt methodes voor het gedrag. Voor dit eerste voorbeeld ga je alleen iets doen met de snelheid van de auto. De twee eigenschappen die voorlopig hiervoor voldoende zijn, zijn de huidige snelheid en de maximumsnelheid. Daarvoor maak je twee variabelen aan van het type integer. Stel ze allebei in op een standaard (start) waarde. De huidige snelheid is uiteraard nul. Dit doe je gelijk bij de definitie van de variabele. De maximumsnelheid stel je in op 180 en dat doe je in de constructor. In dit geval maakt het geen verschil. De gemaakte constructor krijgt geen parameters mee en hierin wordt alleen de maximumsnelheid ingesteld. Het gedrag van de auto hebben we in twee methodes vastgelegd. De eerste gasGeven zorgt ervoor dat de snelheid verhoogd wordt tot de maximumsnelheid. Je ziet hierbij meteen het voordeel dat het aanpassen van de snelheid gebeurt via de methode gasGeven en niet rechtstreeks door de variabele snelheid op te hogen. Je kunt namelijk afvangen dat de snelheid niet hoger wordt dan de maximumsnelheid. De methode remmen verlaagt de snelheid. Uiteraard mag de snelheid niet lager dan 0 worden. Deze klasse zelf kun je niet uitvoeren. Hiervoor zul je eerste in het programma Program.cs objecten van de auto moeten maken.


4.7 Het programma Program.cs Het programma Program.cs is het feitelijke programma dat uitgevoerd wordt als je jouw applicatie opstart. Als dit programma uitgevoerd wordt, wordt er eerst gezocht naar een methode met de naam Main. Als deze methode gevonden wordt, wordt deze uitgevoerd. Het eerste dat gebeurt, is dat er van de klasse auto twee afzonderlijke objecten gemaakt worden. Een met de naam audi en een met de naam bmw. Vervolgens wordt via de methode setMaximuSnelheid de maximumsnelheid voor de BMW veranderd in 220. Die van de Audi blijft 180, de defaultwaarde zoals je die in de klasse gedefinieerd hebt. Vervolgens wordt in een for-lus de methode gasGeven voor beide auto’s aangeroepen en de actuele snelheid die deze methode teruggeeft wordt op het scherm getoond. 4.8 Samenvatting In dit hoofdstuk heb je een korte introductie gehad in objectgeoriënteerd programmeren. Je bent in staat om zelf een eenvoudige klasse te maken en deze te gebruiken als object. Als je het hoofdstuk goed bestudeerd hebt, moet je opdracht C3 maken uit het opdrachtenboek. Deze opdracht moet je laten aftekenen door de docent.


5 Overloading 5.1 Inleiding In hoofdstuk 4 heb je een begin gemaakt met OOP. In dit hoofdstuk ga je weer een stukje verder in de materie. Je hebt kunnen lezen dat een klasse bestaat uit eigenschappen en methodes. In dit hoofdstuk ga je verder met het onderdeel methodes. Hier komt de term overloading terug. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen aangeven wat overloading is. • Het kunnen toepassen van overloading in o.a de constructor. 5.2 Wat is overloading? Overloading kom je niet alleen bij OOP tegen, maar ook als je alleen werkt met methodes. Overloading is eigenlijk niets anders dan meer methodes met dezelfde naam. Dit levert natuurlijk wel een probleem op. Een methode roep je op door de naam. Hoe weet de compiler nu welke hij moet pakken als er meer met dezelfde naam zijn? De namen zijn wel hetzelfde, maar de parameters die je meegeeft aan de methode zijn anders. Deze moeten verschillen in aantal en/of datatype. Het eerste wil zeggen dat het aantal parameters dat wordt meegegeven aan een methode verschillend zijn voor de diverse methodes die worden aangeroepen. Misschien dat een voorbeeld dit duidelijker maakt. Stel, je hebt een klasse auto en die heeft een methode schakelen waarmee je naar een volgende versnelling schakelt. Je kunt je voorstellen dat je ook een methode schakelen wilt hebben waarmee je meteen naar een bepaalde versnelling schakelt. Deze versnelling geef je dan mee als parameter. De code ziet er dan als volgt uit.

…… class auto { …… private int versnelling = 0; …… public void schakelen() { versnelling++; }


public void schakelen(int versn) { versnelling = versn; } }

In bovenstaande code zie je dat er twee methodes zijn met de naam schakelen. Alleen de eerste krijgt geen parameters mee en de tweede wel. Doordat in dit geval het aantal parameters verschilt, is er geen twijfel mogelijk over welke methode gekozen moet worden als de methode aangeroepen wordt. Dit gebeurt namelijk op een van de beide volgende manieren. class Program { static void Main(string[] args) { auto audi = new auto();

audi.schakelen(); // een versnelling omhoog audi.schakelen(3); // schakel naar de derde versnelling

} } In het tweede geval verschilt niet het aantal parameters maar zit er verschil in het datatype van de parameters. Om verder te gaan met het vorige voorbeeld van het schakelen kun je ook voorstellen dat je een methode maakt voor zowel omhoog als terugschakelen. Dat kan bijvoorbeeld door een methode schakelen te maken waarbij met een plusteken wordt aangegeven dat er omhoog geschakeld moet worden en met een minteken omlaag. Deze methode ziet er dan als volgt uit.

public void schakelen(String upDown) { if (upDown == “+”)

versnelling++; else versnelling--;

} Ook nu zal er voor de compiler geen enkel probleem zijn om er de juiste methode bij te zoeken als deze op de volgende manier wordt aangeroepen.

audi.schakelen(“+”); // omhoog schakelen Natuurlijk kan overloading niet alleen toegepast worden op methodes, maar ook op constructors. Je kunt dus verschillende constructors maken voor de zelfde klasse, waarbij objecten dus op een andere manier gemaakt worden. In het geval van het voorbeeld auto zou je bijvoorbeeld een constructor kunnen maken waarbij meteen de maximumsnelheid ingesteld wordt. Dit kan door de volgende code aan de klasse toe te voegen.


public auto(int mSnelh) { maxSnelheid = mSnelh; } Er zijn nu twee constructors voor de klasse auto. Je kunt deze op de volgende manier gebruiken in Program.cs. auto bmw = new auto(); // constructor zonder parameter auto porche = new auto(250); // constructor met max. snelheid 5.3 Samenvatting In dit hoofdstuk heb je geleerd wat overloading is. Je bent in staat om zelf een klasse uit te breiden. Als je het hoofdstuk goed bestudeerd hebt, moet je opdracht C4 maken uit het opdrachtenboek. Deze opdracht moet je laten aftekenen door de docent.


6 Het maken van een Tamagotchi LET OP Voordat je aan dit hoofdstuk kunt beginnen moet je eerst opdracht C3 en C4 hebben gemaakt en laten goedkeuren. 6.1 Inleiding In hoofdstuk 2 t/m 5 heb je een begin gemaakt met OOP en programmeren in de console. In dit hoofdstuk maak je een applicatie waarbij je alle onderdelen uit de betreffende hoofdstukken weer tegenkomt. Daarnaast kijk je ook naar wat elementaire onderwerpen in het programmeren zoals een naming convention en het gebruik van commentaar. In de uitleg merk je dat soms het Nederlandstalige begrip is toegepast en soms het Engelstalige begrip. Dit is met opzet gedaan zodat je beide leert kennen. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen werken met klassen. • Het kunnen maken van een naming convention. • Het kunnen werken met een comment header. • Het kunnen toepassen van foutafhandeling. • Het verschil weten tussen Public en Private. • Het kunnen toepassen van encapsulation. 6.2 De Tamagotchi De Tamagotchi werd in november 1996 voor het eerst op de markt gebracht en dat zorgde wereldwijd voor een rage. Er werden meer dan 40 miljoen exemplaren van verkocht. Ook in België en Nederland stond de Tamagotchi al snel bovenaan de lijstjes van favoriet speelgoed. Op veel scholen werd het verboden om Tamagotchi's mee te nemen, omdat ze de kinderen teveel afleidden. Je kunt ze voeden, verzorgen, zelfs verbinden met anderen en je kunt ze laten opgroeien tot ze ouders zijn. Maar, zoals gebruikelijk met een rage, de belangstelling ebde langzaam weer weg en de plastic eieren verdwenen in rommellaadjes en vuilnisbakken. In dit hoofdstuk ga je een Tamagotchi consoleapplicatie maken. Dit is tevens het laatste hoofdstuk dat gaat over consoleapplicaties. Hierna ga je verder met Windows Form applicaties.


6.3 Het menu Je gaat het menu maken waarmee je de Tamagotchi kunt verzorgen. In consoleapplicaties zijn menu’s vaak terugkomende onderdelen. Omdat je niet steeds opnieuw deze code wilt toevoegen in je programma, wil je dezelfde code graag hergebruiken. Het hergebruiken van code is de voorwaarde om er een methode van te maken. Je gaat dus een methode maken dat het menu weergeeft en die aangeroepen wordt vanuit de Main-methode. Als eerste maak je een nieuw project aan in VS. Je geeft het project de naam: Tamagotchi. Een programma begin je met het bekendmaken van de variabelen. In jouw programma

ga je twee variabelen gebruiken.

doorGaan Dit is een boolean. keuze Dit is een integer.

De variabele doorGaan geef je bij het aanmaken de waarde True. In deze variabele houd

je bij of de speler door wil gaan met het programma. Je ziet dat er een bepaalde schrijfwijze is toegepast bij de variabele namen. Dit is een onderdeel van een naming convention.

In een naming convention schrijf je op hoe je alle onderdelen (variabelen, klassen,

methodes en dergelijke) van jouw applicatie gaat benoemen. Bij de variabele namen is gekozen om te starten met een kleine letter en ieder volgend

woord te beginnen met een hoofdletter. Dit noemen we CamelCase. Voor uitleg hierover kun je terugkijken in het lesmateriaal van ASP.



Zodra je een enter geeft na de laatste regel zul je zien dat VS de methode Menu() niet kent. Dit is juist, want die moet je nog maken. Je kunt zelf de methode aanmaken of je kunt dit automatisch laten gebeuren. Je kiest natuurlijk voor het automatisch laten genereren van de methode Menu.

Ga met je muis op het woord Menu() staan. Kies de optie Show potential fixes. Je kunt

natuurlijk ook gewoon op <ctrl> + <.> drukken.

Je krijgt het volgende te zien.


Klik op de optie Generate method ‘Program.Menu’. De methode Menu wordt

aangemaakt en kan gevuld worden.

Boven de methode zie je de tekst 1 reference. Dit betekent dat deze methode op dit moment een keer wordt aangeroepen vanuit je programmacode. Als hier het getal nul staat, moet je goed kijken of deze methode wel nodig is. Voeg de volgende code toe aan de reeds bestaande code. De vet weergegeven code heb

je al.

while (doorGaan) { keuze = Menu(); switch (keuze) { case 0: doorGaan = false; break; case 1: Console.WriteLine("Je praat met je huisdier"); break; case 2: Console.WriteLine("Je geeft eten aan je huisdier"); break; case 3: Console.WriteLine("Je speelt met je huisdier"); break; case 4: Console.WriteLine("Je geeft je huisdier een andere

naam"); break; default:


Console.WriteLine("Kies een optie 1 t/m 4"); break; } }

In de bovenstaande code wordt aangegeven wat er moet gebeuren als de gebruiker een bepaalde keuze heeft gemaakt. Er is alleen nog geen keuze te maken, omdat er nog geen menu is. De methode voor het menu is al gemaakt. Nu moet je alleen nog ingeven wat er in de methode moet komen. De methode wordt aangeroepen met het commando

keuze = Menu();

Neem de volgende code over en plaats deze in de methode die automatisch is aangemaakt. De regel die er al staat (throw new … Exception()) moet je verwijderen.

private static int Menu()

{ int invoer = 1; Console.WriteLine("\n \n \n"); Console.WriteLine("0) Stop het programma"); Console.WriteLine("1) Luister naar je huisdier"); Console.WriteLine("2) Eten geven"); Console.WriteLine("3) Spelen"); Console.WriteLine("4) Andere naam geven"); try { invoer = Convert.ToInt32(Console.ReadLine()); } catch (FormatException) { Console.WriteLine("Je moet een menuoptie kiezen"); invoer = 1; } return invoer; }

In deze code kom je iets tegen wat nog niet eerder is gebruikt.

try { ... } catch


{ ... }

Met deze code kun je voorkomen dat je programma stopt omdat er een foute invoer is gegeven. In de volgende paragraaf komt dit onderdeel uitgebreid aan bod.

Start het programma op en kijk of het menu werkt en of je de verschillende opties kunt

kiezen. 6.4 Foutafhandeling Als je een programma maakt, wil je niet dat het continue vastloopt door bijvoorbeeld verkeerde invoer van gebruikers of bijvoorbeeld door het niet kunnen vinden van bestanden. Je moet dan gebruik gaan maken van foutafhandeling. Hier zijn de commando’s die je moet gebruiken bij foutafhandeling. try { // instructies waarin een fout optreedt } catch { // instructies om de fout af te handelen } finally { // instructies die uitgevoerd worden ongeacht // het wel of niet optreden van een fout. } Met het commando try geef je het begin aan van het foutafhandelingsblok. Je vertelt als het ware aan je programma dat de instructies die volgen uitgeprobeerd moeten worden. Zodra een functie fout gaat, wordt er een Exception gegenereerd. Het commando catch vangt deze exception af. De instructies in dit blok zijn bedoeld om de foutsituatie netjes af te handelen. Meestal staan hier de instructies in die aan de gebruiker melden dat er een fout is opgetreden en wat er moet gebeuren. De instructies in het blok van finally worden altijd uitgevoerd, of iets nu fout gaat of niet. Wanneer je een record toevoegt aan je database, heb je hiervoor een verbinding nodig. Of het nu wel of niet lukt om het record toe te voegen, de databaseconnectie moet achteraf wel worden afgesloten. Dit kan dan in het finally-blok worden opgenomen.


Als je in de code kijkt van je Tamagotchi-spel dan zie je dat er achter het commando catch de term FormatException staat. Dit zorgt ervoor dat er een invoerfout wordt afgevangen. Er kunnen zich echter meer andersoortige fouten voordoen. Daarom is er ook een groot aantal exceptions. Later zul je in de reader nog een aantal andere exceptions tegenkomen. 6.5 Een nieuw object maken Je kunt het Tamagotchi-spel maken zonder gebruik te maken van klasses. Je gaat echter juist gebruikmaken van klassen om zo langzaam naar objectgeoriënteerd programmeren te gaan. Een Tamagotchi is een object. Objecten hebben Properties (eigenschappen), Methods en Events. Een object heeft een class , zoals een recept. Dat omschrijft hoe een taart eruit ziet, maar is zelf geen taart. En instances. De taarten die met het recept zijn gemaakt. Om een Tamagotchi-object te maken moet je dus een class maken en van die class maak je een instance. Je begint met een eenvoudige class die je later gaat uitbreiden. Als eerste ga je ervoor zorgen dat je Tamagotchi een naam krijgt. Daarna ga je hem laten praten. Als eerste maak je de class Tama. Ga met je muis op het project staan en druk op de rechtermuisknop. Kies de optie Add, Class. Geef de gemaakte class de naam Tama.


Druk op Add om de class aan te maken. Geef de volgende code in.

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Tamagotchi { class Tama { public string naam; } }

Je hebt de scope van de variabele naam gezet op public. Dit houdt in dat de variabele Naam zowel binnen als buiten de class Tama zichtbaar is. Als je hier als scope private zou hebben gebruikt, dan zou de variabele Naam alleen in de class bekend zijn en niet er buiten. De class is gemaakt. Nu hoef je alleen nog maar een instantie van deze class te maken om hem te kunnen gebruiken.

Pas de code in Program.cs aan zoals hieronder is aangegeven. Je hoeft alleen de vet

afgedrukte code in te voeren. static void Main(string[] args) { bool doorGaan = true; int keuze; Tama MijnTama = new Tama(); MijnTama.naam = "Ronald"; while (doorGaan) { keuze = Menu(); switch (keuze) Je moet de code van eerste case-statement ook aanpassen om ervoor te zorgen dat de

Tamagotchi zijn/haar eigen naam zegt.


case 1: Console.WriteLine("Je Tamagotchi zegt: Mijn naam is {0}",MijnTama.naam); break; Test de applicatie uit.


6.6 Een methode toevoegen Objecten worden interessanter als ze ook iets doen. Zoals je weet zijn methoden acties die objecten kunnen uitvoeren. Je gaat dus een methode toevoegen aan de class Tama. Je gaat een methode toevoegen die ervoor zorgt dat de Tamagotchi terugpraat. In feite heb je de code al voor deze methode (zie de code achter case 1:). Dezelfde code die de Tamagotchi zijn naam laat geven, moet in de class geplaatst worden. Pas de code van de class Tama aan zoals hieronder vet is aangegeven. class Tama { public string naam; public void praat() { Console.WriteLine("Je Tamagotchi zegt: Mijn naam is

{0}", naam); } } Omdat de class is aangepast, moet ook de code worden aangepast bij case 1. Pas de volgende vette code aan. case 1: MijnTama.praat(); break; Start het programma op om te kijken of alles goed functioneert. Omdat je de naam van de Tamagotchi wilt kunnen veranderen, moet je de code nog iets uitbreiden. Pas de code achter case 4 aan met de vette code die hieronder staat weergegeven. case 4: Console.WriteLine("De huidige naam: {0}", MijnTama.naam); Console.WriteLine("Verander de naam naar:"); MijnTama.naam = Console.ReadLine(); break; Probeer het programma uit.


6.7 Werken met properties Je hebt de naam van de Tamagotchi public gedeclareerd. Dit kan problemen gaan opleveren. Omdat naam public is gedeclareerd, is er geen manier om er zeker van te zijn dat de variabele ook de juiste waarde krijgt. Om dit tegen te gaan, pas je in deze paragraaf de code zo aan dat je gaat werken met properties. Je gaat de class Tama aanpassen zodat je de naam alleen nog maar kunt veranderen via properties. Je zult zien dat de code in de class flink is toegenomen. De naam van de Tamagotchi ga je nu Private maken. Pas de code van de class Tama uit zoals hieronder vet is weergegeven.

namespace Tamagotchi { class Tama { private string tNaam; public string naam { get { return tNaam; } set { if (value.Length > 8) { Console.WriteLine("De naam mag slechts 8 tekens zijn"); tNaam = value; tNaam = tNaam.Substring(0, 8); Console.WriteLine("De naam is nu: {0}", tNaam); } else { tNaam = value; } } } public void praat() { Console.WriteLine("Je Tamagotchi zegt: Mijn naam is {0}",


naam); } } } Met de code tNaam = tNaam.Substring(0, 8); zorg je ervoor dat alleen de eerste acht tekens van de string in tNaam worden geplaatst. De andere tekens die teveel waren, gaan verloren. Probeer het programma uit. Een propertie bestaat uit twee speciale methodes, get() en set(). Deze methodes zorgen voor ‘toegangscontrole’ voor de private variabelen. Dit noemen we ook wel encapsulation. 6.8 De Tamagotchi ‘echter’ maken Je gaat een aantal private variabelen toevoegen aan de class Tama, zodat je Tamagotchi steeds echter lijkt. Pas de code van de class Tama aan, zodat deze gelijk is aan de volgende code. class Tama { private string tNaam; private int tEten=10; private int tVrolijk = 10; private int tJaar = 0; public string naam

tEten Deze variabele geeft aan of de Tamagotchi honger (=0) heeft

of niet. tVrolijk Deze variabele geeft aan of je Tamagotchi Vrolijk is of niet.

tJaar Geeft de leeftijd van je Tamagotchi

Je gaat de methode Jaar() maken.

Voeg de volgende methode toe in de class Tama.


public void Jaar() { tJaar++; tEten--; tVrolijk--; if (tEten < 3) // Bij honger minder vrolijk { tVrolijk--; } } Maak de methode Eten(). Voeg de volgende methode toe in de class Tama. public void Eten() { tEten += 4; } Je gaat de methode Spelen() maken. Voeg de volgende methode toe in de class Tama. public void Spelen() { tVrolijk += 3; } In de class Tama staat al een methode praat(). Deze methode pas je aan zoals hieronder

is weergegeven. public string praat() { string boodschap; boodschap = "De Tamagotchi zegt:\n"; if (tVrolijk>5) { boodschap+= " Hallo! Mijn naam is " + naam + "\n"; boodschap += " Ik ben vrolijk vandaag! \n"; } else if (tHappy > 2) { boodschap += " " + naam + " voelt zich niet lekker"; } else if (tHappy > 0) { boodschap += " " + naam + " is GEK..."; }


else { boodschap += "...niets aan de hand, verveel me."; } return boodschap; } Nu moet alleen je hoofdprogramma nog aanpassen zodat je gebruik kunt maken van alle nieuwe methodes. Pas de code aan zoals hieronder is weergegeven. while (DoorGaan) { MijnTama.Jaar(); keuze = Menu(); switch (keuze) { case 0: doorGaan = false; break; case 1: Console.WriteLine(MijnTama.praat()); break; case 2: MijnTama.Eten(); Console.WriteLine("Je hebt je huisdier eten gegeven"); break; case 3: MijnTama.Spelen(); Console.WriteLine("Je hebt gespeeld met je huisdier"); break; case 4: Console.WriteLine("De huidige naam: {0}", MijnTama.naam); Console.WriteLine("Verander de naam naar:"); MijnTama.naam = Console.ReadLine(); break; default: Console.WriteLine("Kies een optie 1 t/m 4"); break; } } Test het programma uit.


6.9 Oefening 2 Je hebt nu een werkende applicatie waarvan jij weet hoe die werkt. Als je alle code letterlijk hebt overgenomen is er minimaal commentaar geplaatst in de code. Dit is nu niet erg voor jou. Als echter iemand anders jouw code zou bekijken, dan moet deze snel kunnen zien welk stukje code wat doet. Hiervoor is commentaar bedoeld. Maar commentaar is er ook voor jezelf. Je kunt in de applicatie duidelijk maken waarom jij bepaalde code gebruikt. En als jij een applicatie van jezelf pas weer na een jaar ziet, weet je meestal niet meer precies waarom je wat precies hebt gedaan. Zorg ervoor dat je voldoende commentaar in je code plaatst. 6.10 Het werken met commentaar Dat commentaar is een code belangrijk is voor de overdraagbaarheid van de code en voor jezelf, is al in de voorgaande oefening naar voren gekomen. Toch is er nog een onderdeel van commentaar dat niet is aangestipt. In hoofdstuk 2 t/m 6 ben je regelmatig applicaties tegengekomen waar bovenaan een stuk code een commentaarblok staat. Dit heet een comment header. De officiële benaming is echter Module Header. Hierin staat standaardinformatie over de code die daaronder volgt. Een voorbeeld

In het vervolg van de reader zal bij alle code steeds een Module Header gebruikt worden. 6.11 Oefening 3 Plaats een juiste Module Header in de bestanden van je Tamagotchi-project. 6.12 Oefening 4 Tijdens het coderen van de applicatie is al verteld waarom je een naming convention moet gebruiken. In deze applicatie is gebruikgemaakt van Camelcasing en Pascalcasing. Zoek op


wat de beide schrijfmethodieken inhouden en maak een complete naming convention voor de Tamagotchi-applicatie. Gebruik hierbij de volgende voorbeelden. https://en.wikipedia.org/wiki/Naming_convention_(programming) https://en.wikipedia.org/wiki/Hungarian_notation https://msdn.microsoft.com/en-us/library/ms229045(v=vs.110).aspx 6.13 Samenvatting Je hebt een programma gemaakt door gebruik te maken van methodes en een klasse. Je Tamagotchi-programma is natuurlijk nog lang niet af. Daarom krijg je in opdracht C6 de opdracht om je Tamagotchi uit te breiden met een aantal zaken. Voor je echter begint aan opdracht C6, moet je C5 maken. In deze opdracht maak je een dobbelspelletje. Hiervoor heb je kennis nodig over random getallen en methodes.

https://en.wikipedia.org/wiki/Naming_convention_(programming)

https://en.wikipedia.org/wiki/Hungarian_notation

https://msdn.microsoft.com/en-us/library/ms229045(v=vs.110).aspx


Deel III

Windows Form + 3-tier programmeren


7 Het maken van een Windows Form-applicatie 7.1 Inleiding Tot nu toe heb je alleen maar consoleapplicaties gemaakt. Bij een consoleapplicatie verloopt de invoer bijna altijd via het toetsenbord en gaat de uitvoer naar de console en verschijnt dan op het scherm. Consoleapplicaties zijn over het algemeen niet echt gebruikersvriendelijk. Een consoleapplicatie heeft een zogenoemde CUI-interface (Character User Interface). Vanaf nu ga je naast consoleapplicaties ook zogenaamde Forms-applicaties maken. Dit zijn Windowsapplicaties. Een Windowsapplicatie is een programma met een grafische interface dat uitgevoerd wordt op je eigen computer. Zo’n grafische weergave heet een GUI (Graphical User Interface). Een GUI heeft de volgende functies, in willekeurige volgorde. • Een grafisch overzicht geven van de beschikbare programmafuncties. • Het bestuurbaar/bedienbaar maken van een applicatie. • Gebruikersinput vereenvoudigen. • Output weergeven op een grafische wijze. In principe zou elke GUI deze functies moeten hebben. Als een GUI goed is gemaakt, dan zorgt deze ervoor dat de applicatie gebruikersvriendelijker wordt. Bij alle applicaties die je voor deze opleiding dient te maken, is gebruikersvriendelijkheid zeer belangrijk. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het verschil kunnen aangeven tussen GUI en CUI. • Het kunnen benoemen van de 9 ontwerpprincipes voor gebruikersvriendelijkheid. 7.2 Gebruikersvriendelijkheid Je weet nu dat je rekening moet gaan houden met gebruikersvriendelijkheid. Maar wanneer is iets gebruikersvriendelijk? Gebruikers willen snel en makkelijk met een programma kunnen werken. Hoe doe je dit dan? Het eerste wat een gebruiker ziet is de interface van het programma. In jouw geval is dit een Grafische User Interface (GUI). De eerste indruk is belangrijk, maar niet bepalend. Als de gebruiker een mooi menu ziet maar er gebeurt niets als hij/zij op een menuoptie klikt, dan is het programma niet gebruikersvriendelijk. Om je te helpen een programma gebruikersvriendelijk te maken, krijg je een aantal ontwerpprincipes. De negen ontwerpprincipes zijn kort weergegeven met wat voorbeelden. Probeer hier bij het ontwerpen van de GUI goed rekening mee te houden.


1 Taakgeschiktheid De gebruikersinterface moet aansluiten op de werkzaamheden van de gebruiker. Een gebruikersinterface is er voor de gebruiker en niet andersom. Als een timmerman een spijker in de muur slaat met een hamer, denkt hij niet na over de bediening van de hamer. Hij concentreert zich op de spijker. Een goede gebruikersinterface laat zich vergelijken met de hamer. De gebruiker kan de interface intuïtief bedienen waardoor hij zich volledig kan concentreren op zijn werk. 2 Consistentie In onze samenleving is praktisch iedereen in staat om een doosje lucifers op de juiste wijze te bedienen. Een Indiaan uit het Amazonegebied die nog nooit met onze cultuur in aanraking is geweest, zal echter grote moeite hebben om met het doosje vuur te maken. Zo is het ook met gebruikersinterfaces. Een gebruiker die nog nooit met een grafische gebruikersinterface heeft gewerkt, zal meer moeite hebben om zich een nieuwe applicatie eigen te maken dan een gebruiker die vertrouwd is met de concepten van grafische gebruikersinterfaces. Consistentie is niet alleen tussen verschillende interfaces belangrijk maar ook binnen een interface. 3 Bestuurbaarheid De gebruiker moet het idee hebben dat hij de gebruikersinterface bestuurt en niet dat de gebruikersinterface hem bestuurt. De gebruiker hoort een actieve rol te spelen in de bediening, niet een reactieve. 4 Herkenbaarheid De gebruikersinterface moet herkenbaar zijn voor de gebruiker. De gebruiker moet de structuur en werking als het ware zelf kunnen afleiden. Dit is mogelijk door een goed conceptueel model te hanteren. Een conceptueel model biedt de gebruikers een zodanige abstractie van de onderliggende techniek dat de gebruikers begrijpen hoe ze de gebruikersinterface moeten bedienen. Neem de bestuurder van een auto. Deze hoeft niet te weten wat een bobine is, wat bougies zijn en waar de koppakking toe dient. Al deze technische zaken zijn in de moderne auto verstopt achter een gaspedaal, koppeling, versnelling, rem en stuur. 5 Terugkoppeling Vergelijk een elektrisch fornuis met een gasfornuis. Bij het koken op een elektrisch fornuis is er altijd sprake van een zekere vertraging tussen het moment waarop de gebruiker de temperatuur van een kookplaat instelt en het moment waarop de kookplaat de ingestelde temperatuur bereikt. Bij een gasfornuis daarentegen krijgt de gebruiker vrijwel direct terugkoppeling wanneer hij het gas hoger of lager draait. Over het algemeen wordt dit als prettiger ervaren.


Een ander goed voorbeeld is een printfunctie. Vaak duurt het enige tijd voordat er iets uit de printer komt. Ongeduldige gebruikers hebben dan al meermaals op de printknop gedrukt. Zorg je voor een melding dat het document wordt afgedrukt, dan zal er minder ergernis ontstaan over de ‘extra’ afdrukken. 6 Eenvoud Kijk naar de ontwikkeling van de afstandsbediening van televisies. De eerste afstandsbedieningen waren apparaten met veel knoppen die bovendien allemaal dezelfde grootte hadden. De huidige generatie afstandsbedieningen kenmerkt zich door weinig knoppen. De belangrijkste knoppen (kanaal vooruit/achteruit, volume harder/zachter) zijn groter uitgevoerd dan de andere. Daarnaast zijn specialistische knoppen (om bijvoorbeeld de kanalen te programmeren en de helderheid en het contrast in te stellen) vaak verborgen achter een menu. 7 Aantrekkelijkheid Vergelijk de vormgeving van de website van de ene krant eens met die van een andere. De manier van presenteren komt overeen met die van de papieren versie. Of vergelijk het uiterlijk van de ene auto met dat van een andere. Beide auto's hebben een specifieke doelgroep voor ogen. Een goede interface roept positieve gevoelens op bij de doelgroep. 8 Tolerantie Een gebruiker moet het resultaat van een commando eenvoudig ongedaan kunnen maken. Als de gebruiker per ongeluk een verkeerd gegeven invoert, moet hij dit zonder veel moeite kunnen herstellen. De gebruikersinterface dient de gebruiker zodanig te sturen dat deze geen of weinig fouten kan maken. 9 Flexibiliteit Iedereen heeft zijn eigen favoriete werkwijze. Voor het knippen en plakken in een tekstverwerker gebruikt de een de knoppen in het lint, de ander de toetscombinaties Ctrl+X gevolgd door Ctrl+V en weer een ander sleept de tekst met de muis naar de gewenste positie. Een goede interface ondersteunt verschillende werkwijzen. Daarnaast biedt een goede interface de gebruiker de mogelijkheid de interface aan te passen aan zijn persoonlijke wensen. 7.3 Kleurenblindheid Wist je dat ongeveer 10% van de mannen en 0,25% van de vrouwen last heeft van kleurenblindheid? Toch komt het regelmatig voor dat er bij het ontwerpen van een GUI geen rekening is gehouden met deze groep gebruikers. Er zijn drie verschillende soorten kleurenblindheid. Hieronder staan foto’s zodat je kunt zien wat iemand ziet met een bepaalde vorm van kleurenblindheid. De eerste foto is normaal.


Deuteranopia

Protonopia

Tritanopia

Het verschil tussen Deuteranopia en Protonopia is klein. In de volksmond wordt dit ook wel rood/groen-kleurenblindheid genoemd. Bij alle opdrachten uit deze reader houd je rekening met kleurenblindheid. Hiervoor kun je verschillende hulpmiddelen vinden op internet. Een van die hulpmiddelen is de site http://www.color-blindness.com/coblis-color-blindness-simulator.

http://www.color-blindness.com/coblis-color-blindness-simulator/


Je kunt hier een screenshot van je GUI uploaden, zodat je kunt zien wat mensen zien die kleurenblindheid zijn. Voor meer informatie over kleurenblindheid kun je de volgende link gebruiken. http://www.kleurenblindheid.nl 7.4 De 10 rechten van een gebruiker Je hebt al het een en ander kunnen lezen over klantvriendelijkheid en kleurenblindheid. Bij IBM hebben ze een manifest gemaakt voor computergebruikers. Hierin staan de 10 rechten die elke gebruiker moet hebben. Hieronder staan de originele Engelstalige rechten. 1 The user is always right. If there is a problem with the use of the system, the system is

the problem, not the user.

2 The user has the right to easily install software and hardware systems.

3 The user has the right to a system that performs exactly as promised.

4 The user has the right to easy-to-use instructions for understanding and utilizing a system to achieve desired goals.

5 The user has the right to be in control of the system and to be able to get the system to

respond to a request for attention.

6 The user has the right to a system that provides clear, understandable, and accurate information regarding the task it is performing and the progress toward completion.

7 The user has the right to be clearly informed about all system requirements for

successfully using software or hardware.

8 The user has the right to know the limits of the system’s capabilities.

9 The user has the right to communicate with the technology provider and receive a thoughtful and helpful response when raising concerns.

10 The user should be the master of software and hardware technology, not vice-versa.

Products should be natural and intuitive to use.

7.5 Oefening 5 Je hebt de 10 rechten van een gebruiker gelezen. Omschrijf wat voor gevolgen deze hebben als je ervoor wilt zorgen dat jouw applicatie hieraan voldoet.

http://www.kleurenblindheid.nl/


7.6 Samenvatting Je hebt in dit hoofdstuk veel kunnen lezen over gebruikersvriendelijkheid in jouw applicatie. Nu is het nog een kwestie van toepassen. Je bent in staat om opdracht W1 te maken.


8 Werken met menustructuren 8.1 Inleiding In dit hoofdstuk maak je een begin met een Windows Forms-applicatie. Je gaat een storingsbeheerapplicatie bouwen. Deze applicatie maakt gebruik van een database die later uitgelegd zal worden. In de komende hoofdstukken ga je deze applicatie stukje voor stukje maken. In dit hoofdstuk zal er worden gekeken naar de verschillende schermen en de menustructuur. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het maken van een menustructuur. • Het werken met menusneltoetsen. • Het kunnen toepassen van een contextgevoelig menu. 8.2 Richtlijnen voor een menu Het maken van een applicatie begint bij de schermen en het menu. Je gaat een menu maken waarmee je straks eenvoudig en snel kunt navigeren door je programma. Het zal je waarschijnlijk wel zijn opgevallen dat veel Windowsapplicaties op elkaar lijken met betrekking tot de vormgeving. Als je dan ook nog kijkt naar de menuopbouw, dan kom je er achter dat deze nog meer op elkaar lijken. Bij het maken van menu’s zijn er dan ook richtlijnen waaraan je je kunt houden. In dit lesmateriaal worden die richtlijnen gevolgd. Vrijwel altijd is het eerste menu File of Bestand. In dit menu vind je de opdrachten om bijvoorbeeld een nieuw document te Openen, Bewaren, Sluiten, Af te drukken. Daarnaast is de laatste optie altijd Afsluiten. Veel programma’s hebben ook een menuoptie met Edit of Bewerken. Hier staan dan de volgende opties in: Ongedaan maken, Knippen, Plakken, Kopiëren, Zoeken. De overige menuopties zijn per applicatie verschillend. De laatste menuoptie is standaard Help. Hierin vind je de opties: Help, Info. Door je te houden aan deze richtlijnen is het voor gebruikers makkelijker om met je applicatie te werken. De menu’s zijn standaard en dus hetzelfde als in andere gebruikte applicaties. 8.3 Menu’s maken Met het object MenuStrip uit de Toolbar kun je een menu maken in je Windows


Forms-applicatie. Het maken van het menu is nog maar de helft van het verhaal. Klikt de gebruiker op een menuregel, dan verwacht hij dat er iets gebeurt. Je activeert de menuopdrachten door menuevents af te vangen en code uit te voeren. Voor je echter iets kunt uitvoeren, moet je natuurlijk wel een applicatie hebben. Maak een nieuw Windows Forms-project aan met de naam

Servicedesk.

Sleep uit de toolbox de MenuStrip naar je scherm toe. De MenuStrip

kun je vinden onder het kopje Menus & Toolbars. Je krijgt het volgende te zien.


Onder je formulier (het componentvak) krijg je het menuobject te zien. Boven in je formulier staat de tekst Type Here. Je ziet dat de naam van het object menuStrip1 is. Deze naam pas je aan. Ga naar de eigenschappen van je menu en pas de naam aan naar

menuHoofd Klik boven in je formulier op de tekst Type Here.

Type de menuoptie &Bestand. Je ziet dat er naast Bestand weer een nieuw vakje komt. Hier kun je straks de volgende hoofdmenuopties ingeven. Onder Bestand komt ook een vakje te staan. In dit vakje komt een menuoptie te staan die alleen zichtbaar wordt als de optie Bestand is geselecteerd.


Type onder de optie Bestand de volgende optie Nieuw

Type onder de optie Nieuw de volgende optie:

- Type onder de optie – de volgende optie: Afsluiten Je hebt een menu gemaakt met daarin een submenu. Als je nu je programma zou starten, dan zul je zien dat het menu al meteen functioneert. Start het programma op om het menu te testen. LET OP Het teken & duidt op een sneltoets. Je kunt daardoor het menu bereiken door op Alt te drukken en op de letter die na het & teken staat. Dit kun je ook zien omdat bijvoorbeeld de letter B van Bestand wordt onderstreept als het menu actief is. Als je bij een submenu-optie een – ingeeft zal hier een scheidingslijn komen. 8.4 Acties in een menu Je hebt een menu gemaakt met maar een aantal opties. In deze paragraaf stel je de optie Afsluiten zo in dat inderdaad je programma wordt afgesloten als je deze menuoptie selecteert. Ga naar de menuoptie Afsluiten en dubbelklik op deze optie. Je komt in het event

terecht dat wordt uitgevoerd zodra je deze menuoptie selecteert. Geef de volgende code in.

private void afsluitenToolStripMenuItem_Click(object sender, EventArgs e)

{ Application.Exit(); } Start het programma op en kijk of de menuoptie Afsluiten werkt. Je kunt dus door dubbel te klikken op de menuoptie in de programmacode komen.


8.5 Sneltoetsen Om je programma nog gebruikersvriendelijker te maken, is het mogelijk om bepaalde menuopties te voorzien van een sneltoets. In de vorige paragraaf heb je de menuoptie Afsluiten geconfigureerd. In deze paragraaf ga je aan de optie Afsluiten de sneltoets Ctrl+A koppelen. Klik een keer op de menuoptie Afsluiten om deze te selecteren. Bij de Eigenschappen ga je naar de eigenschap ShortcutKeys. Klik op het pijltje achter deze optie. Er verschijnt een invulvenster.

Selecteer de optie Ctrl en kies als Key voor de letter A. Start je applicatie nogmaals op en ga naar de menuoptie Afsluiten. Je ziet dat naast de menuoptie ook de sneltoets wordt vermeld. Verlaat het menu en druk nu op de sneltoets Ctrl+A om

te testen of alles werkt. Je hebt een menu met daarin alle mogelijkheden die je tegen kunt komen in een standaardmenu. Iets wat ook regelmatig wordt gebruikt in applicaties zijn de contextgevoelige menu’s (snelmenu). 8.6 Het maken van een contextgevoelig menu Tot nu toe heb je een menu gemaakt dat altijd aanwezig is op je scherm. Vaak wil je toch dat er extra menuopties zijn binnen bepaalde schermen. Je kunt dan gebruikmaken van een contextgevoelig menu (snelmenu). Een snelmenu roep je op door op de rechtermuisknop te drukken. Een goed voorbeeld van een snelmenu vind je in Word. Je selecteert een tekst en je drukt op de rechtermuisknop. Je krijgt dan een menu zoals hiernaast is weergegeven.


In deze paragraaf maak je een snelmenu voor het hoofdmenu. In dit snelmenu kun je de locatie gaan bepalen van je hoofdmenu.

Sleep het object ContextMenuStrip uit de toolbox in je formulier.

Pas de naam aan door de eigenschap Name

te vullen met

cmMenuHoofd Voer de menuopties in voor het snelmenu

zoals hieronder is weergegeven.

Het snelmenu is gemaakt. Je hebt er nog geen functionaliteit in gezet maar het werkt al wel. Nu moet je er alleen nog voor zorgen dat het wordt gekoppeld aan het menu.

Klik op het menu onder in je formulier.

Ga naar de eigenschappen van het menu en selecteer bij de eigenschap

ContextMenuStrip het snelmenu cmMenuHoofd. Start je programma op en ga op je menu staan. Druk dan op de rechtermuisknop en je

snelmenu zal verschijnen. Nu moet je er alleen nog voor zorgen dat er inderdaad iets gebeurt als je een optie uit het snelmenu selecteert. Dubbelklik op de snelmenuoptie Boven.


Typ de volgende code in.

private void bovenToolStripMenuItem_Click(object sender, EventArgs e)

{ menuHoofd.Dock = DockStyle.Top; } Doe hetzelfde voor de opties Links, Rechts en Onder. Je moet dan de volgende code

gebruiken.

Boven menuHoofd.Dock = DockStyle.Top; Links menuHoofd.Dock = DockStyle.Left; Rechts menuHoofd.Dock = DockStyle.Right; Onder menuHoofd.Dock = DockStyle.Bottom;

Test je programma uit. Als je op het menu gaat staan met je muis kun je op de

rechtermuisknop drukken en dan moet het snelmenu verschijnen. Je hebt in dit hoofdstuk een menu en een snelmenu gemaakt. In het volgende hoofdstuk ga je werken met meer formulieren (vensters) en dialoogvensters. 8.7 Oefening 6 Maak nog een menu met als naam oefening6. Zorg ervoor dat het menu aan de linkerkant wordt weergegeven zoals hieronder is afgebeeld met de menuopties zoals deze zijn weergegeven.

• Optie 1

o Sub 1.1 o Sub 1.2 o Sub 1.3

• Optie 2 o Sub 2.1 o Sub 2.2

• Optie 3


9 Vensters en MDI 9.1 Inleiding In dit hoofdstuk ga je het programma uit hoofdstuk 8 uitbreiden. De meeste programma’s bestaan uit meer dan één scherm. Een venster voor het invoeren van bijvoorbeeld storingen en een ander voor het weergeven van de hardware. Om er dan toch voor te zorgen dat het programma een geheel blijft, wordt er vaak gekozen voor MDI. Je gaat in dit hoofdstuk eerst twee nieuwe vensters maken en deze aanroepen door middel van het menu. Hierna ga je van je applicatie een MDI-variant maken. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen maken van een MDI-parentscherm. • Het openen van forms. • Ervoor kunnen zorgen dat elk scherm slechts eenmaal actief is. 9.2 Werken met vensters Je hebt een programma met een hoofdscherm. In deze paragraaf ga je twee nieuwe formulieren (vensters) aanmaken waarop in een later hoofdstuk gegevens uit de database komen te staan. Voor je echter nieuwe vensters gaat aanmaken, is het verstandig om de naam van het bestaande hoofdvenster aan te passen. Standaard krijgen alle vensters die je maakt in C# de naam Formxx (waarbij xx staat voor het volgnummer). Open het project dat je bij hoofdstuk 8

hebt gemaakt. Ga met je muis op het venster Form1.cs

staan in de Solution Explorer. Druk op de rechtermuisknop en kies de

optie Rename. Verander de naam van het venster in

frmHoofdVenster.cs


Je krijgt de volgende melding.

De naam van een venster wordt in verschillende stukken code gebruikt. Deze melding geeft je de keuze om automatisch de naam aan te passen in alle stukken code waar de naam van het venster in voorkomt. Dit noemen we Refactoring. Druk op Yes/Ja om de naam van het venster overal aan te laten passen. Je hebt je venster een andere naam gegeven. Nu kun je de twee nieuwe vensters gaan toevoegen. Je gaat een venster toevoegen voor het weergeven van hardware en je gaat een venster weergeven voor het toevoegen van een persoon. Ga in de Solution Explorer staan

op de projectnaam. Druk op de rechtermuisknop en

kies de optie Add, Windows Form.

Je krijgt het volgende venster te zien.


Vul bij de naam in frmHardware.cs en druk op de knop Add. Voeg op dezelfde wijze nogmaals een venster toe en geef deze de naam frmPersoon.cs. In de Solution Explorer zijn de aangemaakte vensters te zien. De vensters zijn aangemaakt. Nu wil je er natuurlijk ook voor zorgen dat je van het ene formulier naar het andere formulier kunt gaan. Dit doe je door middel van het menu. Je zult nieuwe menuopties moeten gaan aanmaken. Pas het menu zo aan dat de volgende opties aanwezig zijn.

Nu de menuopties zijn aangemaakt moet je er nog voor zorgen dat de vensters opgeroepen (zichtbaar) kunnen worden. Omdat een venster een klasse is, moet je er een instantie van maken voor je het formulier kunt gebruiken.


Dubbelklik op de gemaakte menuoptie Toevoegen, Persoon. Neem de volgende code over.

private void persoonToolStripMenuItem_Click(object sender, EventArgs e)

{ frmPersoon f = new frmPersoon(); f.Show(); }

In de regel frmPersoon f = new frmPersoon(); maak je een nieuwe instantie aan van het venster frmPersoon.cs. Deze instantie noem je f. Je kunt het venster zichtbaar maken door gebruik te maken van het commando f.Show();

Zorg ervoor dat het venster frmHardware.cs zichtbaar wordt als je op de menuoptie

Overzichten, Hardware klikt. Test het programma uit. Je kunt de vensters sluiten door op het kruisje te klikken. Het is ook mogelijk om de vensters meermaals zichtbaar te maken. Je zult merken dat het werken met deze applicatie niet gebruikersvriendelijk is. Het menu staat alleen op het hoofdvenster en is niet meer zichtbaar als je andere vensters er overheen komen te staan. Dit kun je oplossen door gebruik te gaan maken van MDI. 9.3 Wat is de Multiple Document Interface? De naam zegt al dat je met MDI meer documenten tegelijk kunt weergeven. De basis van een MDI-applicatie is de ‘parent’. Binnen dit ‘parent’-scherm kun je meer subschermen plaatsen. Het maken van een ‘parent’-scherm is eenvoudig. Door middel van het aanpassen van een eigenschap kun je aangeven dat dit een MDI-scherm (parent) is. Ga naar de eigenschappen van het venster

frmHoofdvenster.cs. Verander de eigenschap IsMdiContainer

naar True. Je ziet dat de achtergrond van het formulier verandert. De achtergrond wordt donkergrijs, wat een aanwijzing is dat dit venster kan dienen als schil voor andere vensters. Dubbelklik op de menuoptie Toevoegen, Persoon.


Pas de code zo aan zoals hieronder is weergegeven.

private void persoonToolStripMenuItem_Click(object sender, EventArgs e)

{ frmPersoon f = new frmPersoon(); f.MdiParent = this; f.Show(); } Je ziet dat er maar één regel is aangepast in de code. Met de regel f.MdiParent = this; geef je aan dat het huidige venster (frmHoofdVenster.cs) de MdiParent is.

Start de applicatie op en kijk naar het verschil van de twee verschillende vensters.

Verplaats de vensters ook even. Je ziet een verschil tussen de beide schermen. Er is echter nog wel een probleem. Het is nog steeds mogelijk om meer schermen van elk te openen. In de volgende paragraaf kun je lezen wat je hieraan kunt doen. 9.4 Een form slechts eenmaal openen Het formulier frmPersoon opent in het hoofdvenster. Je moet er alleen nog voor zorgen dat je elk formulier slechts één keer kunt openen. Pas de code onder de menuoptie Toevoegen, Persoon aan zoals hieronder is

weergegeven.


Start de applicatie opnieuw op en probeer of je het venster frmPersoon diverse keren kunt openen.

Je zult zien dat dit niet meer mogelijk is. Hieronder staat kort uitgelegd wat de

bovenstaande code doet. 48 De foreach-lus is een speciale lus. Later in het lesmateriaal zal deze nog

uitgebreid aan bod komen. Deze vorm gebruik je om door alle forms te ‘bladeren’ die in de MDI-parent zitten. Alle informatie van een form wordt dan opgeslagen in de variabele x.

50 Als de form als tekst (= titel van de form) gelijk is aan frmPersoon, dan wordt in regel 52 de form actief gemaakt. Als je een form actief maakt, dan zal deze normaal bovenop de andere forms zichtbaar worden.

54 Als de form gevonden is, dan hoef je niet verder te kijken. Daarom wordt hier een break gebruikt om de lus te verlaten. Als je dit niet zou doen, dan zal je applicatie verder zoeken tot alle forms doorzocht zijn. Hierdoor zou je applicatie traag kunnen worden.

57 Als het form niet is gevonden, dan wordt deze aangemaakt en weergegeven. 9.5 Samenvatting Je hebt het verschil gezien tussen ‘gewone’ vensters en MDI-vensters. In de meeste form-applicaties wordt gebruikgemaakt van MDI. Als je hoofdstuk 1 t/m 9 goed hebt doorgenomen moet je opdracht W2 kunnen maken.


10 Overerving 10.1 Inleiding In dit hoofdstuk breid je het onderwerp OOP weer verder uit. Je hebt gezien wat je kunt doen met klassen. Een onderdeel hiervan in het overerven. Bij overerven gebruik je een bestaande klasse die je gebruikt in je nieuwe klasse. Hierdoor krijg je een van de pluspunten van het werken met OOP: het hergebruiken van code. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen overerven van een klasse. • Het kunnen aangeven wat access modifiers zijn. 10.2 Wat is overerving? Een van de redenen waarom OOP zo’n succes is geworden, is het feit dat code op een eenvoudige manier herbruikbaar is. Je hebt in de vorige hoofdstukken gezien hoe je zelf klassen kunt maken om daar weer objecten van te maken. Je kunt je voorstellen dat als je nog een keer iets met een auto object moet doen dat je dan de reeds gemaakt klasse erbij pakt en deze weer gebruikt. Maar wat als je nu een keer een iets afwijkende klasse wilt gebruiken bijvoorbeeld een vrachtauto? Je kunt in zo’n geval een nieuwe klasse maken op basis van een bestaande klasse. Dit gaat erg eenvoudig. De volgende code laat zien hoe je een nieuwe klasse vrachtauto maakt op basis van de reeds gemaakt klasse auto. class vrachtauto : auto { public vrachtauto() { maxSnelheid = 120; } } Je hebt nu een klasse vrachtauto waarvan je in je code nu objecten kan maken. Deze klasse heeft verder alle eigenschappen en het gedrag van de klasse auto gekregen. Dit noem je overerving (inheritance) . Je noemt in dit geval de klasse auto de base- (of super)klasse en de klasse vrachtauto de subklasse. In principe erft de subklasse alle eigenschappen en het gedrag van de baseklasse.


Deze eigenschappen moeten wel een bepaald ‘beveiligingsniveau’ hebben. Hier wordt mee bedoeld dat het keyword, dat gebruikt wordt bij de declaratie van een variabele, aangeeft op welk niveau de variabele benaderbaar is. In het voorbeeld moet de variabele maxSnelheid in de klasse auto gedefinieerd worden met het keyword protected in plaats van private. Het statement voor de declaratie ziet er dan als volgt uit. protected int maxSnelheid; In de volgende tabel wordt aangegeven wat de invloed van de verschillende keywords is op de benaderbaarheid van de variabelen.

Keyword Benaderbaar In klasse zelf? Via object? In subklasse?

Private Ja Nee Nee Protected Ja Nee Ja Public Internal Protected internal

Ja Ja Ja

Ja Ja

Ja (eigen assembly)

Ja Ja Ja

10.3 Constructors erven Om goed te kunnen profiteren van overerving is het nodig om constructors van baseklassen te erven. Dit zorgt ervoor dat een object eerst gemaakt wordt volgens de baseklasse en dat je vervolgens in de subklasse extra zaken aan het object toevoegt. Dit voordeel merk je vooral als je met Windowsklassen gaat werken. Als je bijvoorbeeld een eigen buttonklasse maakt op basis van een standaard-Windowsbutton. Het is dan wel erg handig als je je niet druk hoeft te maken over het feit hoe zo’n button gemaakt wordt. Dat gebeurt namelijk in de constructor van de standaardbutton. Vervolgens wil je alleen maar je eigen zaken hier aan toevoegen. Je zorgt ervoor dat de constructor van de baseklasse de basis is van je nieuwe constructor door een dubbele punt en het woord base met de parameterlijst achter de naam van de constructor te plaatsen. Om ervoor te zorgen dat eerst de constructor van de baseklasse uitgevoerd wordt, definieer je dat als volgt in het voorbeeld van de vrachtauto. public vrachtauto() : base() { maxSnelheid = 120; } In dit geval heeft dit niet zo heel veel zin, omdat in de constructor van de auto niets anders gebeurt dan de maximumsnelheid op 180 te stellen. Vervolgens zal de constructor van de vrachtauto de maximumsnelheid op 120 instellen.


Als er een constructor met parameters aangeroepen moet worden, dan gaat dat als volgt. public vrachtauto(int mSnelh): base(mSnelh) { maxSnelheid = mSnelh; } Je ziet dat de parameter mSnelh die aan de constructor van de vrachtwagen wordt meegegeven, meteen doorgegeven wordt aan de constructor van de auto. Op deze manier kun je voor elke constructor in auto een constructor in vrachtauto maken. Ook kun je meer constructors in vrachtauto maken die gebaseerd zijn op dezelfde constructor in auto. 10.4 Methode overriding In het begin van dit hoofdstuk heb je gezien dat bij overerving alle methodes (voor zover public of protected gedefinieerd) die in de baseklasse gedefinieerd zijn, ook beschikbaar zijn in de subklasse. Soms is het nodig om deze methodes op een andere manier te programmeren. Je wilt dus een methode met dezelfde naam, maar met een iets andere invulling. Dat principe van het herprogrammeren van een reeds bestaande methode noemen we overriding. Om dit te kunnen doen moet je twee dingen doen. Ten eerste moet je bij de baseklasse (auto) aangeven dat een methode wel overschreven mag worden. Dat doe je door in de definitie van de methode het keyword virtual op de te nemen. Met het woord virtual geef je aan dat het de subklasse is toegestaan om de methode te overschrijven. Dat doe je als volgt.

public virtual int gasGeven() {

if (snelheid < maxSnelheid) { snelheid += 10; } else { Console.WriteLine("De maximumsnelheid is bereikt"); } return snelheid; } Vervolgens moet je in de subklasse (vrachtauto) aangeven dat je een methode, die geërfd is, wil overschrijven. Dit doe je door het keyword override op te nemen in de definitie van de methode. Dit ziet er als volgt uit.

public override int gasGeven() { if (snelheid < maxSnelheid)


{ snelheid += 5; } else { Console.WriteLine("De maximumsnelheid is bereikt"); } return snelheid;

} Het gevolg hiervan is dat objecten die gemaakt zijn van de klasse auto bij gas geven met stappen van 10 km/u harder gaan rijden en objecten die afgeleid zijn van vrachtauto met 5 km/u. Soms is het nodig dat je in je programma de originele methode aanroept in plaats van de overschreven methode. Dit kun je doen door de naam van de methode te gebruiken met het woord base er voor. Dit ziet er dan als volgt uit.

base.gasGeven(); Nu wordt de methode gasGeven() aangeroepen zoals die in de klasse auto is gedefinieerd en niet zoals die in klasse vrachtauto is gedefinieerd. 10.5 Samenvatting In dit hoofdstuk heb je geleerd hoe je bestaande klassen kunt gebruiken om nieuwe klassen te maken. Je bent in staat om zelf een klasse te maken op basis van een andere. Als je het hoofdstuk goed bestudeerd hebt, moet je opdracht A3 maken uit het opdrachtenboek. Deze opdracht moet je laten aftekenen op de aftekenlijst door de docent.


11 Windows Forms controls (de webbrowser) 11.1 Inleiding In hoofdstuk 8 en 9 heb je een start gemaakt met je servicedeskapplicatie. In dit hoofdstuk ga je een aantal controls toepassen binnen deze applicatie. Deze controls komen in de meeste applicaties voor. Met een aantal controls heb je al kennis gemaakt bij ASP.NET. De Textbox, Label, Button, Dropdownlist en Checkbox heb je al gebruikt. Deze controls komen wel aan bod in dit hoofdstuk maar in mindere mate. Je gaat nu een eigen webbrowser maken die je in de applicatie moet kunnen gebruiken. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen werken met het webbrowser-object. • Het kunnen werken met de standaard form-controls. • Het kunnen toepassen van errorproviders. • Het kunnen maken van een databasekoppeling. • Het kunnen opvragen van gegevens uit een database. 11.2 Het maken van een webbrowser Je gaat een nieuw venster maken in je applicatie. Van dit venster ga je een webbrowser maken. Voeg in je applicatie een venster toe met als naam: frmWeb.cs. Maak de nieuwe volgende menuopties aan.

Zorg ervoor dat het venster frmWeb.cs zichtbaar wordt als MDI-child als er op de

menuoptie Extra, Webbrowser wordt geklikt. Natuurlijk mag dit venster slechts eenmaal worden geopend.

Open het venster frmWeb.cs in de ontwerpweergave.

Sleep het object TabControl op het venster. En geef het de naam tabWeb.


Pas de eigenschap Dock aan naar Bottom. Sleep de het object tabWeb zover omhoog, dat er nog ruimte overblijft om buttons te kunnen plaatsen.

Sleep het object Webbrowser op het eerste tabblad. Je ziet dat het object meteen heel het tabblad vult. Geef het object als naam

webBrowser. Plaats een textbox boven het webbrowser object en geef de textbox de naam

txtURL. Plaats nu een button achter de textbox. Geef deze button de naam

btnNavigeer. Zorg ervoor dat op de button de tekst Ga naar komt te staan. Verander ook gelijk de

naam van het eerste tabblad naar ???. Je kunt dit doen door de eigenschap Tabpages aan te passen.

Je krijgt dan het volgende resultaat.


Dubbelklik op de button en voer de volgende code in. private void btnNavigeer_Click(object sender, EventArgs e) { webBrowser.Navigate(txtURL.Text); } Start de applicatie op en kijk of de webbrowser functioneert.


Je gaat er nu voor zorgen dat de URL van de webpagina zichtbaar wordt gemaakt op het tabblad.

Pas de code onder btnNavigeer aan zoals hieronder is weergegeven.

private void btnNavigeer_Click(object sender, EventArgs e) { webBrowser.Navigate(txtURL.Text); tabWeb.TabPages[0].Text = txtURL.Text; } Bij een echte browser staan ook altijd de knoppen Terug en Volgende. Deze knoppen ga je nu toevoegen aan je webbrowser. Voeg twee buttons toe aan het venster frmWeb.cs. Geef deze buttons de volgende

namen en zorg ervoor dat het eindresultaat hetzelfde is als hieronder is weergegeven.

btnTerug btnVooruit

Dubbelklik op de button btnTerug en neem de volgende code over.

private void btnTerug_Click(object sender, EventArgs e) { webBrowser.GoBack(); }

Dubbelklik op de button btnVooruit en neem de volgende code over.

private void btnVooruit_Click(object sender, EventArgs e) { webBrowser.GoForward(); }

Test de applicatie. Je hebt nu een webbrowser waarmee je een webpagina kunt oproepen en terug en vooruit kunt gaan. Een andere functie die vaak gebruikt wordt bij browsers is de geschiedenis. Je gaat een dropdownlist toevoegen aan je venster. Zodra je een pagina hebt bezocht, komt deze pagina in de dropdownlist te staan. Als je hierna een bepaalde pagina uit de dropdownlist selecteert, zal deze pagina zichtbaar worden.


Plaats een ComboBox uit de Toolbox op je venster Web.cs. Geef deze Combobox de naam cbGeschiedenis.

Je gaat er voor zorgen dat de ComboBox automatisch gevuld wordt als er op de button

Navigeer (Ga naar) wordt geklikt. Dubbelklik op de button btnNavigeer en neem de volgende code over. private void btnNavigeer_Click(object sender, EventArgs e) { webBrowser.Navigate(txtURL.Text); cbGeschiedenis.Items.Add(txtURL.Text);

tabWeb.TabPages[0].Text = txtURL.Text; }

De ComboBox wordt nu gevuld. Je moet er nu alleen nog voor zorgen dat als je een website selecteert in de ComboBox, deze ook zichtbaar wordt.

Dubbelklik op de ComboBox cbGeschiedenis en neem de volgende code over. private void cbGeschiedenis_SelectedIndexChanged(object

sender, EventArgs e) { txtURL.Text = Convert.ToString(cbGeschiedenis.SelectedItem);

webBrowser.Navigate(txtURL.Text); tabWeb.TabPages[0].Text = txtURL.Text;

} Test de applicatie uit. Je hebt nu al een redelijk complete browser gemaakt. Toch zijn er nog wat uitbreidingen die je moet doen. Als er geen webpagina wordt ingegeven in de TextBox en je toch op de button Navigeer klik, dan krijg je niets te zien. Je wilt eigenlijk dat er dan een melding komt. Dit kun je bereiken met het control

ErrorProvider . Door gebruik te maken van deze control kun je een uitroepteken laten verschijnen achter de textbox als er iets niet goed is.


Sleep de control ErrorProvider uit de Toolbox (components) naar je venster frmWeb.cs.

Pas de naam aan naar

ErrorMelding Dubbelklik nu op de button btnNavigeer.

De controle of de TextBox leeg is, kan namelijk pas plaatsvinden als je op deze knop drukt.

Neem de volgende code over. private void btnNavigeer_Click(object sender, EventArgs e) { if (txtURL.Text == "") { ErrorMelding.SetError(txtURL, "Je hebt geen url ingegeven"); } else { webBrowser.Navigate(txtURL.Text); cbGeschiedenis.Items.Add(txtURL.Text);

tabWeb.TabPages[0].Text = txtURL.Text; } } Voer het programma uit en voer niets in bij de TextBox. Druk hierna op de button

btnNavigeer. Je krijgt het volgende scherm te zien.

Ga met je muis op het uitroepteken staan en je krijgt de foutmelding te zien zoals

hierboven is weergegeven. Het probleem met de ErrorProvider is dat deze blijft staan, ook als je wel een URL hebt ingegeven. Er dient nog een kleine aanpassing gedaan te worden om ervoor te zorgen dat het rode uitroepteken verdwijnt als er wel iets in txtUrl staat.


Ga naar de code onder de knop btnNavigeer. Voeg de volgende regel toe aan het begin van de else-instructie.

ErrorMelding.Clear();

Deze instructie zorgt ervoor dat de ErrorProvider wordt leeggemaakt en dus niet meer verschijnt.

Test de applicatie. Als laatste onderdeel is het altijd handig als je de geschiedenislijst weer leeg kunt maken zonder de applicatie opnieuw te moeten opstarten. Je plaatst een button op je form waarmee je de dropdownlijst kunt leegmaken. Plaats een nieuwe button op je venster frmWeb.cs met als naam

btnLeegCb.

Het is mogelijk dat je de grootte van je venster wat moet aanpassen. Zet op de button de naam Wissen. Dubbelklik op de button Leegcb en neem de volgende code over.

private void btnLeegCb_Click(object sender, EventArgs e) { cbGeschiedenis.Items.Clear(); } Test het programma nu uit. De browser begint steeds meer te lijken op een volwaardige browser. Toch moet er nog het een en ander aan worden aangepast. In de volgende paragraaf ga je werken met een favorietenlijst.


11.3 Oefening 7 Je hebt nu een webbrowser gemaakt. Toch moet er nog wat extra’s worden toegevoegd. Er moet een beveiliging komen zodat bepaalde websites niet ingegeven kunnen worden. Je hebt nu een errorprovider gebruikt die ervoor zorgt dat er een melding verschijnt als er geen URL is ingegeven. Je moet er nu voor zorgen dat er ook een melding verschijnt als een van de volgende URL’s worden ingevoerd. • www.nu.nl • www.weeronline.nl • www.buienradar.nl

De melding die dan moet verschijnen is: U moet zich bezighouden met het werk en niet met PRIVE!! Pas je applicatie zo aan dat het bovenstaande functioneert. Je mag geen nieuwe ErrorProvider op je venster plaatsen. Daarnaast is het op dit moment zo dat als je achterelkaar op de knop btnNavigeer drukt, dezelfde URL meermalen in de dropdownlist wordt gezet. Pas de code zo aan dat er geen dubbele items meer in de dropdownlist kunnen voorkomen. 11.4 Een connectie met een database In de vorige paragraaf heb je een kleine browser gemaakt. In deze paragraaf ga je een toevoeging doen aan deze browser. Je gaat een favorietenlijst maken. Op het werk of je ELO staat een script dat de database Favo maakt met daarin al je favorieten. In deze paragraaf wordt niet te diep ingegaan op de koppeling met de database. In het komende hoofdstuk ga je hier wel dieper op in. Voer het script Maak Favo.sql uit.

De database Favo is nu gemaakt met daarin het volgende tabel met favorieten.

Je gaat een listbox vullen met de inhoud van deze tabel.

http://www.nu.nl/

http://www.weeronline.nl/

http://www.buienradar.nl/


Sleep een ListBox uit de Toolbox op het venster frmweb.cs.

Geef de ListBox de naam lbFavo.

Je zult het scherm iets aan moeten passen om ervoor te zorgen dat alles erop kan.

De ListBox lbFavo moet gevuld worden zodra je het venster opent. Hiervoor moet je gebruik gaan maken van een event. Een event is niets anders dan een stukje code dat wordt uitgevoerd bij een bepaalde actie.

Ga naar de Designweergave van frmWeb.cs. Kies in het eigenschapsvenster voor Events. Dubbelklik nu achter het event Load. Neem de volgende code over.

Bovenaan moet je wel aangeven dat je de bibliotheek voor databasegebruik wilt gebruiken. using System.Data.SqlClient; Let er wel op dat de databaseservername (vet en extra groot weergegeven) voor iedere computer anders is. private void Web_Load(object sender, EventArgs e)

{ SqlConnection Conn = new SqlConnection(); Conn.ConnectionString=@"Integrated Security=true;Initial

Catalog=Favo;Data Source=IXP-044457\SQLEXPRESS”; Conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = “select * from tblfavo”; SqlDataReader dr = cmd.ExecuteReader();


while (dr.Read()) { int favonr = dr.GetInt32(0); string favoomschr = dr.GetString(1); string favourl = dr.GetString(2); lbFavo.Items.Add(favourl); } dr.Close(); Conn.Close();

}

Nu moet je er alleen nog voor zorgen dat de webpagina van de gekozen URL zichtbaar wordt.

Test het programma. Je ziet dat je in een browser werkt. De code die hierboven staat weergegeven zal in hoofdstuk 12 uitgebreid worden toegelicht. In dit hoofdstuk ga je ook een begin maken met het oproepen, veranderen en wissen van gegevens.


12 ADO.Net gebruiken 12.1 inleiding In hoofdstuk 11 heb je een databasekoppeling gemaakt om je favorieten op te kunnen vragen. In dit hoofdstuk ga je verder met dit onderwerp. Met de komst van .Net, besloot Microsoft om ActiveX Data Objects (ADO) uit te breiden en ADO.Net te maken. In paragraaf 11.4 heb je een koppeling met de database Favo gemaakt. In de volgende paragraaf wordt besproken hoe deze code in elkaar zit. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen uitleggen hoe ADO.NET werkt. • Het kunnen benaderen van een database en hier query’s op uit laten voeren. • Het kunnen toepassen van parameters ter voorkoming van SQL-injectie. 12.2 Uitleg paragraaf 11.4 Hieronder staat de code die je hebt gebruikt in paragraaf 11.4 nogmaals weergegeven maar dan met uitleg erbij. Als eerste moet je er natuurlijk voor zorgen dat bovenin je code de volgende regel komt te staan. Using System.Data.SqlClient; De namespace System.Data.SqlClient bevat gespecialiseerde klassen van ADO.Net waarmee je toegang krijgt tot SQL-Server. SqlConnection Conn = new SqlConnection(); Conn.ConnectionString=@"Integrated Security=true;Initial Catalog=Favo;Data Source=IXP-044457\SQLEXPRESS”; SqlConnection is een subklasse van de klasse Connection van ADO.Net. Deze klasse dient alleen voor het verbinden met de SQL-Serverdatabase. De eigenschappen van de verbinding geef je aan door gebruik te maken van een ConnectionString. De inhoud van de ConnectionString is belangrijk. In de code is gekozen voor Integrated Security = true. Dit is de meest gebruikte methode. De gebruiker hoeft nu geen gebruikersnaam en wachtwoord in te geven. Met Initial Catalog geef je aan welke database je wilt gebruiken. Met Data Source geef je aan op welke server de database draait. Als je een SQL-server gebruikt die op je eigen pc staat, dan kun je ook gebruikmaken van Localhost.


De parameters van de ConnectionString worden gescheiden door puntkomma’s. Om problemen te krijgen met bepaalde tekens binnen de string wordt gebruikgemaakt van het escape-teken (@) voor de string. Conn.Open(); Met dit statement open je de connectie met de database. SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "select * from tblfavo"; Het eerste statement maakt een object van SqlCommand. Een object van SqlCommand wordt gebruikt om een opdracht uit te voeren op een database. In dit geval (relationele MS-SQL database) is de tekst een SQL-statement. De tweede regel zeg je dat het SQL-statement uitgevoerd moet worden op de Connectie Conn. In de derde regel vul je het SqlCommand met het juiste SQL-statement. SqlDataReader dr = cmd.ExecuteReader(); De snelste manier om gegevens uit een database te krijgen is de klasse SqlDataReader. Deze klasse haalt de rijen zo snel uit de database als de databaseserver en het netwerk toelaten. while (dr.Read()) { int favonr = dr.GetInt32(0); string favoomschr = dr.GetString(1); string favourl = dr.GetString(2); lbFavo.Items.Add(favourl); } De methode Read van de klasse SqlDataReader haalt de volgende rij uit de database. Hij geeft true terug als dat lukt. Lukt het niet, dan geeft hij false terug, en meestal komt dit doordat er geen rijen meer zijn. De while-lus leest steeds rijen uit de variabele dr totdat het einde is bereikt. Bij regel 3 t/m 5 lees je gegevens uit een object van SqlDataReader (dr). Een object van SqlDataReader bevat de laatste rij die uit de database is opgehaald. Je gebruikt de methode Getxx om de gegevens van iedere kolom op te halen. Er is een Getxx voor ieder gegevenstype. Dus om een int te lezen, gebruik je de methode GetInt32. Deze methoden krijgen een parameter die aangeeft welke kolom er gelezen moet worden: 0 is de eerste kolom, 1 de tweede kolom, enz.


De records worden zo een voor een uitgelezen en de variabele favourl wordt toegevoegd aan de ListBox lbFavo. dr.Close(); Conn.Close(); Deze statements sluiten het object SqlDataReader en de verbinding met de database. Je moet altijd de databaseverbindingen sluiten als je ermee klaar bent. Je hebt de praktische uitleg gekregen van een ADO.Net koppeling met een onlinedatabase. In de volgende paragraaf wordt in het kort de theoretische uitleg gegeven over hoe ADO.Net werkt en uit welke klassen het bestaat. 12.3 ADO.Net in theorie In ADO.Net maak je vooral gebruik van de volgende klassen. Klasse Doel Connection Zorgt voor de verbinding met een database. Aan de hand van

parameters kun je opgeven welke database en hoe je tot deze database toegang kunt krijgen.

Command Hierin komt het SQL-commando dat je wilt uitvoeren op de betreffende database.

Dataset Hierin wordt tijdelijk (totdat het programma wordt afgesloten) de opgevraagde gegevens opgeslagen.

Datareader Leest de gevraagde gegevens uit de database.

Dataadapter Zorgt ervoor dat de klasse Command wordt uitgevoerd op de Connection.

De relatie tussen de bovenstaande klassen is in het volgende schema weergegeven.


Het ADO.Net objectenmodel gebruikt datasets om gegevens te bewaren die uit een database zijn opgehaald. Een programma dat een datasetobject gebruikt, kan SQL-instructies uitvoeren om deze met waarden te vullen en weer te geven. In een dataset kunnen zich een of meer datatable-objecten bevinden. Een datatable-object is gekoppeld aan een tabel in de database. In de volgende paragraaf ga niet alleen lezen uit een database maar ook toevoegen, veranderen en wissen. 12.4 Werken met het SQLCommand-object Met het SQLCommand-object kun je rechtstreeks SQL-statements uitvoeren op een database. Dit heb je al kunnen zien in het vorige hoofdstuk. Je hebt echter op dit moment alleen nog maar gelezen (= Select) uit een database. Er zijn echter nog wat andere taken die ook uitgevoerd dienen te worden zoals toevoegen (= Insert Into), veranderen (= Update) en wissen (= Delete). Nu zou je denken dat je dit kunt bereiken door de SQL-query aan te passen. Helaas werkt dit niet. Stel, je hebt de volgende code. 1 SqlCommand cmd = new SqlCommand(); 2 cmd.Connection = Conn; 3 cmd.CommandText = “select * from tblfavo”; 4 SqlDataReader dr = cmd.ExecuteReader();

In regel 3 staat het select-statement en in regel 4 wordt dit uitgevoerd door de methode ExecuteReader().

Zorgt voor de verbinding met de database

Executes een query commando op de database

Zorgt voor de uitwisseling tussen Dataset en database

Zorgt voor toegang van read-only data

Database

Connection

Command

DataReader

DataAdapter


Hieronder staan de methodes die je moet gebruiken bij de andere SQL-statements. SQL Methode SELECT ExecuteReader() INSERT INTO ExecuteNonQuery() UPDATE ExecuteNonQuery() DELETE ExecuteNonQuery() LET OP Als je slechts een waarde uit één veld wilt halen moet je de methode ExecuteScalar() gebruiken. Aan de hand van een voorbeeld zal het duidelijker worden hoe het een en ander werkt. De programmacode is zo opgebouwd, dat duidelijk is wat welk stukje code doet. Start een nieuw Windows Formproject met als naam Wachtwoord. Gebruik voor dit project het volgende script om de database Wachtwoord te maken.

create database Wachtwoord go use wachtwoord

create table gebruik( loginnaam varchar(10), loginww varchar(10), primary key (loginnaam));

insert into gebruik values ('Hallo', 'Welkom');

Plaats de volgende objecten op je venster zoals in het voorbeeld te zien is. Object Naam Opdruk Label lblDrop Selecteer de gebruiker Label lblLogin Loginnaam Label lblWacht Wachtwoord Textbox txtLogin Textbox txtWacht Combobox cbKeuze Button btnSelecteer Kies de gebruiker Button btnVoegToe Voeg een gebruiker toe Button btnUpdate Wijzig een gebruiker Button btnDelete Wis een gebruiker


De ComboBox wordt gevuld met de gegevens uit de database. Als je een van de loginnamen selecteert kun je op een van de vier knoppen drukken. Zorg ervoor dat de DropDownlist cdKeuze gevuld wordt met alle loginnamen uit de

database. Zie eventueel hoofdstuk 11. Als er op de knop btnSelecteer wordt gedrukt, moeten de gegevens van de

geselecteerde gebruiker worden ingevuld in de textboxen txtLogin en txtWacht. Je doet dit met de volgende code.

string Keuze = Convert.ToString(cdKeuze.SelectedItem); SqlConnection Conn = new SqlConnection(); Conn.ConnectionString = @"Integrated Security=true ;Initial

Catalog=Wachtwoord; Data Source=IXP-044457\SQLEXPRESS"; Conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "select * from gebruik where loginnaam='"+

Keuze +"'"; SqlDataReader dr = cmd.ExecuteReader(); while (dr.Read()) {


txtLogin.Text = dr.GetString(0); txtWacht.Text = dr.GetString(1); } dr.Close(); Conn.Close(); Probeer de applicatie uit en kijk of alles goed werkt. Het zal je wel opvallen dat de code in grote lijnen hetzelfde is als de code die je hebt gebruikt om de dropdownlist te vullen. Als je op de knop btnVoegToe drukt, wordt een gebruiker toegevoegd met de gegevens

die in de twee textboxen staan. Dubbelklik op de button en voeg de volgende code in.

string Wacht = txtWacht.Text; string Login = txtLogin.Text;

SqlConnection Conn = new SqlConnection(); Conn.ConnectionString = @"Integrated Security=true ;Initial

Catalog=Wachtwoord; Data Source=IXP-044457\SQLEXPRESS"; Conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "insert into gebruik

values ('"+Login+"', '"+Wacht+"')"; int gelukt = cmd.ExecuteNonQuery(); Conn.Close(); Test de applicatie. Je kunt nu zelf een login invoeren met een wachtwoord erbij. Als je echter op de knop btnVoegToe drukt, worden de gegevens wel toegevoegd. Je krijgt echter geen melding dat het is gebeurd. Daarnaast moet je er ook nog voor zorgen dat de nieuwe login ook in de dropdownlist komt te staan. Plaats een label achter de knop btnVoegToe met als naam lblOKToe. Door de code onder de knop aan te passen met de volgende code krijg je een melding in

de label. int gelukt = cmd.ExecuteNonQuery(); if (gelukt == 1) {


lblOKToe.Text = "De gebruiker " + Login + " is toegevoegd"; cdKeuze.Items.Add(Login); } Conn.Close(); Zorg ervoor dat het label lblOKToe niet zichtbaar is als er nog geen nieuwe gebruikers

zijn toegevoegd. Dit doe je door bij de eigenschappen de eigenschap Visible op False te zetten.

Je zult nu de volgende regel wel moeten toevoegen in de bovenstaande code. lblOKToe.Visible = true; Nu ga je de code maken voor het updaten van de gegevens. Als je op deze knop drukt

moeten er twee nieuwe textboxen tevoorschijn komen waarin de wijzigingen kunnen worden aangebracht. Als er dan weer op de knop btnUpdate wordt gedrukt moeten de wijzigingen worden doorgevoerd.

Plaats twee textboxen op je venster met de namen.

txtNwLogin txtNwWacht

Zorg ervoor dat deze boxen niet zichtbaar zijn.

Plaats nu de volgende code onder de button btnUpdate. if (txtNwLogin.Visible == false) { txtNwLogin.Visible = true; txtNwLogin.Text = txtLogin.Text; txtNwWacht.Visible = true; txtNwWacht.Text = txtWacht.Text; } else { SqlConnection Conn = new SqlConnection(); Conn.ConnectionString = @"Integrated Security=true ;Initial

Catalog=Wachtwoord; Data Source=IXP-044457\SQLEXPRESS"; Conn.Open();


SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "Update gebruik set loginnaam='" +

txtNwLogin.Text + "', loginww='" + txtNwNacht.Text + "' Where loginnaam='"+ txtLogin.Text+"'";

int gelukt = cmd.ExecuteNonQuery(); Conn.Close(); } Test de applicatie. Je hebt nu een venster waarmee je gegevens kunt uitlezen, toevoegen en aanpassen. Het wissen van gegevens en het beter maken van de applicatie moet je zelf kunnen. 12.5 Oefening 8 In deze oefening moet je het programma uitbreiden met de optie om gegevens te wissen. 12.6 Het gebruik van parameters In paragraaf 12.4 heb je een groot aantal query’s uitgevoerd op de database Wachtwoord. Je hebt bijvoorbeeld de volgende query gebruikt. cmd.CommandText =

"insert into gebruik values ('"+Login+"', '"+Wacht+"')"; Het laten uitvoeren van een query met variabelen is niet toegestaan. Alles wat in de textbox staat die de variabele vult, komt zo in het SQL-statement te staan. Dit geeft een hacker de gelegenheid om iets uit te laten voeren dat je niet wilt. Om dat te voorkomen moet je gebruik gaan maken van parameters in je query. Alles wat je in een parameter zet, wordt gezien als veldgegevens en niet als SQL-code. Dit zorgt ervoor dat je applicatie een stuk veiliger is. Om met parameters te kunnen werken moet je de volgende drie stappen volgen. 1 Maak een SqlCommand string met parameters.

2 Declareer een SqlParameter object en zorg ervoor dat deze de juiste waarde krijgt.

3 Verbind de SqlParameter met het SqlCommand. Je gaat de volgende code zo aanpassen dat deze werkt met parameters.

string Wacht = txtWacht.Text;


string Login = txtLogin.Text; SqlConnection Conn = new SqlConnection(); Conn.ConnectionString = @"Integrated Security=true ;Initial

Catalog=Wachtwoord; Data Source=IXP-044457\SQLEXPRESS"; Conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "insert into gebruik

values ('"+Login+"', '"+Wacht+"')"; int gelukt = cmd.ExecuteNonQuery(); Conn.Close(); In de code wordt gebruikgemaakt van twee variabelen (Wacht en Login). Deze variabelen ga je vervangen door parameters. Stap 1 - SqlCommand aanpassen Origineel

cmd.CommandText = "insert into gebruik values ('"+Login+"', '"+Wacht+"')";

Moet worden:

cmd.CommandText = "insert into gebruik values (@Log, @WW)";

Stap 2 - Declareren parameters

SqlParameter Para1 = new SqlParameter(); SqlParameter Para2 = new SqlParameter(); Para1.ParameterName = "@Log"; Para2.ParameterName = "@WW"; Para1.Value = Login; Para2.Value = Wacht; Stap 3 - Koppelen van SqlParameter met SqlCommand cmd.Parameters.Add(Para1); cmd.Parameters.Add(Para2); Hierna staat de volledige code nogmaals maar nu met Parameters. string Wacht = txtWacht.Text;


string Login = txtLogin.Text; SqlParameter Para1 = new SqlParameter(); SqlParameter Para2 = new SqlParameter(); Para1.ParameterName = "@Log"; Para2.ParameterName = "@WW"; Para1.Value = Login; Para2.Value = Wacht; SqlConnection Conn = new SqlConnection(); Conn.ConnectionString = @"Integrated Security=true ;

Initial Catalog=Wachtwoord; Data Source=IXP-044457\SQLEXPRESS"; Conn.Open(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandText = "insert into gebruik values (@Log, @WW)"; cmd.Parameters.Add(Para1); cmd.Parameters.Add(Para2); int gelukt = cmd.ExecuteNonQuery(); Conn.Close(); 12.7 Oefening 9 In oefening 8 heb je een applicatie gemaakt. In deze oefening moet je alle query’s van deze applicatie zo aanpassen dat er alleen maar gebruik kan worden gemaakt van parameters. 12.8 Samenvatting In dit hoofdstuk heb je geleerd hoe je verschillende bewerkingen kunt uitvoeren op een database. Daarnaast heb je geleerd dat parameters gebruikt moeten worden in plaats van variabelen om je applicatie veiliger te maken. In de meeste applicaties zit wel een database die gebruikt moet worden met de applicatie. Dit hoofdstuk is de basis. In het volgende hoofdstuk ga je weer een stapje verder. Je hebt nu genoeg geleerd om opdracht D1 te kunnen maken.


13 Werken met datasets 13.1 Inleiding In dit hoofdstuk ga je verder met ADO.Net. In hoofdstuk 12 heb je geleerd hoe je met gegevens uit een onlinedatabase kunt werken. In dit hoofdstuk kijk je hoe je kunt werken met een database als deze niet altijd is verbonden. Je gaat nu gebruikmaken van datasets. Als eerste ga je grafisch een dataset maken waarna je met code deze gaat uitbreiden en toepassen. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen maken van een dataset. • Gegevens uit een dataset kunnen lezen. • Gegevens kunnen muteren in een dataset.

13.2 Het maken van een dataset In deze paragraaf ga je een dataset maken met daarin een aantal tabellen uit de database Northwind. Als je deze database niet hebt, dan kun je het script instnwnd.sql uitvoeren. Dit script maakt de betreffende database. Maak een nieuw project aan met als naam

Hoofdstuk13. Ga naar het venster van Data Sources aan de linkerzijde

van Visual Studio. Als de optie er niet bij staat, ga je naar Other Windows, Data Sources.

Je krijgt het venster te zien zoals hiernaast is

weergegeven.

Klik op de link Add New Data Source of klik op . Je komt in de wizard Data Source Configuration Wizard. Kies voor de optie Database en druk op de knop Next.


Je moet kiezen voor de optie Dataset. In de bovenstaande afbeelding is dit de enige

keuze. Door andere instellingen kunnen hier meer opties staan. Druk op Next om verder te gaan.

Je moet de connection gaan maken. Klik op de knop New Connection.


Als het de eerste keer is dat je een databaseconnectie maakt, dan kun je het volgende scherm krijgen.

Kies de optie Microsoft SQL Server en druk op de knop Continue. Je krijgt het volgende scherm te zien.


Vul de servernaam in van je SQL-server. Selecteer hierna de database Northwind.

Voordat je verder gaat is het verstandig om de verbinding te controleren. Als er dan

later iets fout gaat, weet je zeker dat het niets met de verbinding heeft te maken.


Druk op de knop Test Connection om te kijken of er verbinding kan worden gemaakt met de database.

Als alles goed is gegaan krijg je een melding als hiernaast.

Druk twee keer op OK, een keer om het

dialoogvenster te sluiten en de ander om het venster Add connection af te sluiten.

Je krijgt het volgende scherm te zien.

Als je op het plusje klikt voor de Connection string, dan zal deze worden weergegeven.

In de vorige hoofdstukken heb je steeds deze connection string zelf moeten maken in code. Druk op de knop Next om verder te gaan met de wizard.


Je krijgt de naam te zien waaronder de connection string wordt opgeslagen. In dit

voorbeeld pas je de naam niet aan. Druk op Next. Je moet aangeven welke onderdelen van de database je wilt gebruiken in de dataset.

Selecteer de tabellen Customers en Orders.

De wizard geeft zelf een suggestie voor de naam van de dataset. Deze naam ga je aanpassen naar dsNorthwind.


Druk nu op de knop Finish om de wizard af te sluiten.

Je krijgt nu aan de linkerkant de inhoud van de zojuist

gemaakte dataset te zien.

Ga met de muis op het tabel Customers staan en

sleep dit op je form.

Je ziet dat Visual Studio automatisch een datagrid maakt en een knoppenbalk.

Test de applicatie uit.


Je hebt nu een volledig databaseprogramma waarmee je alle bewerkingen uit kunt voeren: Select, Insert, Update, Delete. Standaard krijg je een DataGridView als je een tabel vanaf de Data Sources sleept naar een form. Je kunt ook kiezen voor een Detailview.

13.3 Oefening 10 Maak nu bij je project een nieuwe Windows Form aan en noem deze frmOrders. Het huidige formulier hernoem je van Form1 naar frmKlanten. Maak nu nog een nieuwe Windows Form aan en noem deze frmHoofdmenu. Zorg ervoor dat de applicatie standaard begint met dit formulier. Op dit formulier komt een menu met daarin de volgende menuopties.

Zorg ervoor dat de formulieren frmKlanten en frmOrders worden opgestart als MDIchild zodra de juiste menuoptie is aangeklikt. Op het formulier frmOrders moet het tabel Orders komen te staan in Detail View. 13.4 Werken met datasets in code In het begin van dit hoofdstuk heb je met behulp van wizards, grafisch een dataset gemaakt. In deze paragraaf ga je nogmaals een dataset maken maar nu door middel van programmacode. Je gaat dezelfde applicatie maken als aan het begin van dit hoofdstuk maar nu met behulp van code. Je gaat het scherm van de klanten nogmaals maken.


Voeg de Form frmKlantenCode toe aan je project.

Maak de nieuwe menuoptie KlantenCode aan op frmHoofdmenu die de zojuist

aangemaakte form zichtbaar maakt.

Plaats op frmKlantenCode een DataGridView met als naam dgKlant.

Ga nu naar het Load-event van frmKlantenCode (dubbelklik op het form) en neem de

volgende code over.

Vergeet niet om de bibliotheek voor SQL toe te voegen.

using System.Data.SqlClient;

LET OP Het kan voorkomen dat je aan het einde van code-regels een return-teken zie staan. Als dit voorkomt, moet je alles gewoon op één regel plaatsen. Start de applicatie op en je zult zien dat de gridview wordt gevuld met gegevens uit de

database.


Maar wat heb je nu gedaan in de code? Hieronder wordt kort uitgelegd waar elk stukje code voor dient. Regel Omschrijving 23 - 24 SqlConnection Conn = new SqlConnection();

Conn.ConnectionString = @"Data Source=AO-RONALD\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True"; In de bovenstaande code heb je een connectie gemaakt met de database Northwind. Deze code heb je al verschillende malen gezien.

26 SqlDataAdapter daKlant = new SqlDataAdapter("select * from customers", Conn); In de bovenstaande code maak je een data-adapter aan met de naam daKlant. De data-adapter is het object dat de verbinding tussen de database en het dataset regelt. De data-adapter zorgt zelf voor het openen en sluiten van de connectie.

28 DataSet dsKlant = new DataSet(); In deze code wordt een dataset aangemaakt met als naam dsKlant. Deze dataset ga je hierna vullen met gegevens uit de database.

30 daKlant.Fill(dsKlant, "Klant"); De dataset wordt gevuld door de data-adapter aan te roepen met als methode Fill. Het tweede argument is de naam (Klant) waaronder deze gegevens beschikbaar zullen zijn in de DataSet. Als de gegevens uit 1 tabel komen gebruik je meestal gewoon de naam van de tabel, je mag ook zelf een naam verzinnen. Geef je geen naam op dan krijgt de tabel de naam Table1 (verder worden tabellen oplopend genummerd).

31 dgKlant.DataSource = dsKlant; Hier geef je aan dat de DataGridView de DataSet als gegevensbron moet gebruiken. Dit noemen we: Databinding.

32 dgKlant.DataMember = "Klant"; Omdat deze DataSet diverse gegevenstabellen kan bevatten geef je in de eigenschap DataMember de naam in van de gegevenstabel die je gaat gebruiken: Klant.


13.5 Gegevens aanpassen in een dataset In de vorige paragraaf heb je kort gezien hoe je door gebruik te maken van code een DataSet kunt maken. In deze paragraaf ga je het programma zo aanpassen dat je ook kunt toevoegen en muteren. Hiervoor zal je wel het een en ander in de code moeten veranderen. Plaats een button op frmKlantenCode met de volgende naam.

Opschrift Naam Aanpassen btnUpdate Je venster komt er als volgt uit te zien.

Neem de code op de volgende pagina over.


Test de applicatie door iets aan te passen en daarna op de button btnUpdate te klikken.

Sluit het venster en start het venster opnieuw op om te kijken of de wijziging is doorgevoerd.

Je ziet dat er gebruik wordt gemaakt van een methode om de dataset te vullen. Daarnaast staat er nog een regel in die niet is behandeld. SqlCommandBuilder cmdBldr = new SqlCommandBuilder(daKlant); De SqlCommandBuilder cmdBldr leest de select-routine in de SqlDataAdapter daKlant en genereert zelf de update, delete en insert-instructies en koppelt deze aan de methode Update van de SqlDataAdapter daKlant. Je hebt nu in feite een volledige databaseapplicatie gemaakt. Het ziet er nog niet allemaal mooi uit, maar het begin is gemaakt. In de komende 4 hoofdstukken ga je langzaam werken aan een volledige databaseapplicatie die objectgeoriënteerd in lagen is geprogrammeerd.


14 Windowsklassen gebruiken 14.1 Inleiding In hoofdstuk 10 heb je gezien hoe je door middel van overerving op basis van bestaande klassen een nieuwe klasse kunt maken. Van dit principe kun je als je Windowsapplicaties gaat maken veelvuldig gebruikmaken. Je maakt dan je eigen Windowsklassen en objecten aan en daar voeg je de gewenste functionaliteit aan toe. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen maken van een eigen TextBox. • Functionaliteiten kunnen toevoegen aan een Windowsklasse die overerft is. 14.2 Het maken van een eigen TextBox Stel: je wilt in je Windowsapplicatie gebruikmaken van een TextBox waarin mensen teksten kunnen invoeren, maar dat je ook allerlei vervormingen met die teksten kunt doen om bijvoorbeeld in spellen te gebruiken. In dat geval zou je scrambleTextBox kunnen maken die dit soort functionaliteit in zich heeft. Je gaat dus overerven van de klasse TextBox. Maak een nieuw Windows Formproject aan met als naam EigenTextBox.

Voeg een nieuwe klasse toe en geef deze de naam scrambleTextBox.



De klasse is nu klaar voor gebruik. Later in dit hoofdstuk zal worden toegelicht wat de bovenstaande code doet. 14.3 Het gebruiken van de zelfgemaakte klasse Je hebt nu zelf een TextBox gemaakt. Normaal sleep je een TextBox uit de Toolbox op je Form. Met je zelfgemaakte TextBox is dit ook mogelijk. Je moet er alleen iets extra’s voor doen. Zoals je weet, wordt jouw programmacode door een compiler omgezet naar uitvoerbare code. Dit is nog niet gebeurd. Als je jouw project zou Builden, zal je code gecompileerd worden. Ga naar de menuoptie Build en kies dan de

optie Build EigenTextBox.

Je ziet dat je zelfgemaakte TextBox verschijnt in de

Toolbox. Sleep deze nu naar je form.


Je ziet dat de TextBox een roze achtergrondkleur heeft.

Geef je TextBox de naam txtStart.

Plaats nu een normale TextBox (txtResultaat) en een Button (btnLaatZien) op je form,

zodat je hetzelfde krijgt als op het voorbeeld.

Dubbelklik nu op btnLaatZien en voeg de volgende code toe.

Start je applicatie en type een tekst in je zelfgemaakte TextBox. Druk dan op de button

en kijk of je applicatie werkt.


Als het goed is verschijnt de tekst uit jouw eigen TextBox achterstevoren in de ‘normale’ TextBox. 14.4 Uitleg van de code Kijk nu even naar de code van de eigen gemaakte klasse. Deze regel zorgt ervoor dat je een nieuwe klasse genaamd scrambleTextBox gaat maken op basis van een ‘normale’ Windows TextBox. class scrambleTextBox : System.Windows.Forms.TextBox Regel Omschrijving 23 - 24 SqlConnection Conn = new SqlConnection();

Conn.ConnectionString = @"Data Source=AO-RONALD\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True"; In de bovenstaande code heb je een connectie gemaakt met de database Northwind. Deze code heb je al verschillende malen gezien.

26 SqlDataAdapter daKlant = new SqlDataAdapter("select * from customers", Conn); In de bovenstaande code maak je een data-adapter aan met de naam daKlant. De data-adapter is het object dat de verbinding tussen de database en het dataset regelt. De data-adapter zorgt zelf voor het openen en sluiten van de connectie.

28 DataSet dsKlant = new DataSet(); In deze code wordt een dataset aangemaakt met als naam dsKlant. Deze dataset ga je hierna vullen met gegevens uit de database.

30 daKlant.Fill(dsKlant, "Klant"); De dataset wordt gevuld door de data-adapter aan te roepen met als methode Fill. Het tweede argument is de naam (Klant) waaronder deze gegevens beschikbaar zullen zijn in de DataSet. Als de gegevens uit 1 tabel komen gebruik je meestal gewoon de naam van de tabel, je mag ook zelf een naam verzinnen. Geef je geen naam op dan krijgt de tabel de naam Table1 (verder worden tabellen oplopend genummerd).

31 dgKlant.DataSource = dsKlant; Hier geef je aan dat de DataGridView de DataSet als gegevensbron


moet gebruiken. Dit noemen we: Databinding.

32 dgKlant.DataMember = "Klant"; Omdat deze DataSet diverse gegevenstabellen kan bevatten geef je in de eigenschap DataMember de naam in van de gegevenstabel die je gaat gebruiken: Klant.

In plaats van het voorvoegsel System.Windows.Forms hier te gebruiken kon je dit ook boven in de code toevoegen met het statement

using System.Windows.Forms; Je had dan achter de dubbele punt alleen het woord TextBox hoeven zetten. Vervolgens moet je een constructor maken voor deze nieuwe klasse. Dat gebeurt met de volgende commando’s. public scrambleTextBox() : base() { this.BackColor = System.Drawing.Color.FromArgb(255, 192, 255); } De eerste regel geeft aan dat je een constructor maakt zonder parameters mee te geven. De tweede regel geeft aan dat deze constructor gebaseerd is op de constructor zonder parameters van de klasse TextBox. Vervolgens wordt de achtergrondkleur van de TextBox ingesteld op een andere kleur waardoor je hem kunt onderscheiden van een normale TextBox. 14.5 Samenvatting In dit hoofdstuk heb je geleerd hoe je bestaande Windowsklassen kunt gebruiken om nieuwe klassen te maken. Je bent nu in staat om zelf een klasse te maken op basis van een andere. Als je het hoofdstuk goed bestudeerd hebt, moet je opdracht A4 maken uit het opdrachtenboek. Deze opdracht moet je af laten tekenen op de aftekenlijst door de docent.


15 Events 15.1 Inleiding In het vorige hoofdstuk heb je gebruikgemaakt van Windowsklassen. In dit hoofdstuk kijk je naar events. Events zijn een essentieel onderdeel van OOP. Je kunt niet zonder events werken als je bezig bent met Windows Formapplicaties. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen toepassen van events. • Door middel van programmacode events toevoegen aan een object. 15.2 Wat zijn events? Er wordt wel gezegd dat programma’s event-driven zijn. Op z’n Nederlands: gebeurtenisgestuurd. Dit wil zeggen dat het programma reageert op events die optreden en dat de code die uitgevoerd wordt, bepaald wordt door deze events. De Nederlandse benaming voor event is gebeurtenis. Je kunt je heel veel verschillende soorten events voorstellen. • Het klikken op een button. • Het openen van een form. • Het wijzigen van de afmetingen van een form. • Het typen van tekst in een textbox. • Enz.

Het aantal verschillende events dat op kan treden is erg groot. We zullen slechts een zeer beperkt aantal van deze events gebruiken. 15.3 Hoe events te gebruiken Vrijwel elke klasse die geleverd wordt via het .NET framework beschikt over voor gedefinieerde events. Je kunt deze events zien in het eigenschappen venster van Visual Studio. Maak een nieuw Windows Formproject met als naam

Events.

Klik nu op Form1 zodat deze is geselecteerd.

Klik nu op de knop Events .


Je krijgt een overzicht van alle events die beschikbaar zijn voor dit object.

Bij een form zijn dit er minimaal 76. Je ziet dat er nogal wat events zijn.

Dubbelklik op het event Load.

Je komt in de code-editor en kunt beginnen met het invoeren van de code die

uitgevoerd moet worden als het event optreedt.

Een event ziet er altijd als volgt uit.

In dit geval is het een Form_Load event dat wordt uitgevoerd als het formulier, in dit geval Form1, geladen wordt. Je kunt meestal wel aan de naam van het event bepalen wanneer het event wordt uitgevoerd. In de methode worden twee parameters mee gegeven. De eerste is van het type Object en bevat gegevens over het object dat ervoor gezorgd heeft dat het event is afgegaan. Je kunt dit bijvoorbeeld in een if-statement gebruiken in de volgende vorm.

In de bovenstaande code wordt de code alleen uitgevoerd als het event door het object button1 is gegenereerd. De tweede parameter is van het type EventArgs en bevat nadere informatie over het event. Dit zal in dit deel niet verder uitgewerkt worden. 15.4 Zelf een event aanmaken in code Je gaat nu het project uitbreiden met twee buttons. Als je op die twee buttons klikt, gaan ze straks naar hetzelfde event toe die je door middel van programmacode hebt gemaakt.


Voeg aan je form twee buttons toe en geef deze

de namen btnA en btnB. Zorg ervoor dat op de button leesbaar is welke A of B is.

Je krijgt dan het resultaat zoals hiernaast is weergegeven. Ga naar de code van je formulier en pas de code

aan zoals hieronder is weergegeven.

Voer de applicatie uit en kijk wat er gebeurt.

In regel 22 en 23 wordt door middel van programmacode een event aangemaakt voor de beide buttons. In dit event is een controle (regel 28) waar het event getriggerd is. Op basis hiervan krijgt je form een andere titel. 15.5 Samenvatting In dit hoofdstuk heb je geleerd hoe je events kunt gebruiken om nieuwe klassen te maken. Je bent nu in staat om zelf code aan events toe te voegen of zelf events te maken. Als je het hoofdstuk goed bestudeerd hebt, moet je opdracht W6 maken uit het opdrachtenboek. Deze opdracht moet je af laten tekenen door de docent.


16 Software-architectuur 16.1 Inleiding Tijdens de lessen ASP.NET heb je een begin gemaakt met het programmeren in C#. Je hebt gekeken naar objectgeoriënteerd programmeren en het schrijven van code. Nu is het tijd om volgens een bepaald model te gaan programmeren. Er zijn hiervoor verschillende mogelijkheden. In dit lesmateriaal wordt het 3-tiermodel gebruikt. Na bestudering van dit hoofdstuk dien je tot het volgende in staat te zijn. • Het kunnen beschrijven van het 3-tiermodel. 16.2 3-tiermodel Objectgeoriënteerd werken zorgt voor betere code (testbaar, onderhoudbaar en overdraagbaar). Bovendien zorgt object georiënteerd werken dat code herbruikbaar is. De modelleertaal UML (Unified Modelling Language) kun je gebruiken om te ontwerpen, te documenteren en voor de interne communicatie over het ontwerp. Het 3-tier model (drielagenmodel) bestaat uit een gescheiden presentatielaag, een businesslogiclaag en een databaselaag. In het vervolg ga je dit model gebruiken voor het maken van je applicaties. In de volgende afbeelding is weergegeven hoe dit model in elkaar zit.


Bron: Wikipedia (https://en.wikipedia.org/wiki/Multitier_architecture)

Het werken met dit model geeft de volgende voordelen. • De code is beter te testen en is beter onderhoudbaar en overdraagbaar. Met name het

scheiden van de vormgeving van de rest van de toepassing is hierbij belangrijk. De kosten vallen hierdoor ook lager uit.

• Het is geschikt voor latere uitbreiding. Het is bijvoorbeeld veel eenvoudiger een upgrade

te doen van de database als alle daaraan gerelateerde code geconcentreerd is op één plek en niet overal in de applicatie voorkomt. Het toevoegen van een stuk business-logic kan opgepakt worden als een aparte module, een apart project.

• Er kan parallel ontwikkeld worden door verschillende expertteams.

Databasevraagstukken vragen om andere experts dan vormgevingsvraagstukken (presentatielaag).

• De vormgeving is gescheiden van de rest van de toepassing en kan dus eenvoudig

aangepast worden voor andere doeleinden (bijvoorbeeld voor opname van delen van de toepassing in andere applicaties of websites).

• De code is goed herbruikbaar doordat elke module een op zichzelf staand stukje

functionaliteit is en dus opnieuw gebruikt kan worden in verschillende applicaties.


Door dit model te gebruiken kun je applicaties snel en eenvoudig maken. In principe zijn verschillende applicaties niets meer dan verschillende presentatielagen op één datalaag en één businesslogiclaag. Dit zorgt voor een behoorlijke daling in de ontwikkelprijs en het onderhoud. Een voorbeeld Je maakt een ASP.NET-applicatie in C# voor een winkel. Deze winkel wil ook graag een standaloneapplicatie zodat klanten in de winkel zelf snel kunnen zoeken naar artikelen en voorraadgegevens. Je hoeft nu alleen de presentatielaag opnieuw te maken voor deze standaloneapplicatie omdat de logische- en datalaag van de ASP-applicatie gebruikt kunnen worden. Hierdoor kun je dus relatief goedkoop en snel een nieuwe applicatie maken.

Programmeren in VBA › vanhelden › Bestanden... · ©Stichting Praktijkleren – Programmeren in...

Documents

Transcript of Programmeren in VBA › vanhelden › Bestanden... · ©Stichting Praktijkleren – Programmeren in...