3. Inleiding tot webontwikkeling ASP.NET
3.1. Introduction
In het vorige hoofdstuk zijn de principes van webontwikkeling besproken die onafhankelijk zijn van de gebruikte programmeertaal. Momenteel domineren drie technologieën de markt voor webontwikkeling:
- J2EE, een Java-ontwikkelingsplatform. In combinatie met de Struts-technologie, die op verschillende applicatieservers is geïnstalleerd, wordt het J2EE-platform voornamelijk gebruikt in grote projecten. Vanwege de gebruikte taal – Java – kan een J2EE-applicatie draaien op de belangrijkste besturingssystemen (Windows, Unix, Linux, Mac OS, ...)
- PHP is een geïnterpreteerde taal die eveneens onafhankelijk is van het besturingssysteem. In tegenstelling tot Java is het geen objectgeoriënteerde taal. De versie PHP5 zou echter objecten in de taal moeten introduceren. PHP is eenvoudig te gebruiken en wordt op grote schaal ingezet in kleine en middelgrote projecten.
- ASP.NET is een technologie die alleen werkt op Windows-computers met het .NET-platform (XP, 2000, 2003, ...). Als ontwikkeltaal kan elke taal worden gebruikt die compatibel is met .NET en c.a.d. Er zijn er meer dan tien, te beginnen met de talen van Microsoft (C#, VB.NET, J#), Delphi van Borland, Perl, Python, ...
In het vorige hoofdstuk zijn korte voorbeelden gegeven voor elk van deze drie technologieën. Dit document richt zich op webontwikkeling met de taal ASP.NET. We gaan ervan uit dat deze taal bekend is. Dit is een belangrijk punt. We richten ons hier uitsluitend op het gebruik ervan in de context van webontwikkeling. Laten we dit punt verder toelichten aan de hand van de MVC-methodologie voor webontwikkeling.
Een webapplicatie die voldoet aan het MVC-model zal als volgt worden opgebouwd:
Een dergelijke architectuur, ook wel 3-tier of 3-lagenarchitectuur genoemd, streeft ernaar het MVC-model (Model View Controller) te volgen:
- de gebruikersinterface is de V (de weergave)
- de applicatielogica is de C (de controller)
- de gegevensbronnen vormen de M (het model)
De gebruikersinterface is vaak een webbrowser, maar het kan ook een stand-alone applicatie zijn die via het netwerk verzoeken naar de webservice stuurt en de resultaten die deze terugstuurt, opmaakt. De applicatielogica bestaat uit scripts die de verzoeken van de gebruiker verwerken. De gegevensbron is vaak een database, maar het kunnen ook eenvoudige platte bestanden zijn, een directory LDAP, een externe webservice, ... De ontwikkelaar doet er goed aan een grote onafhankelijkheid tussen deze drie entiteiten te handhaven, zodat als er één verandert, de andere twee niet of nauwelijks hoeven te veranderen.
- De bedrijfslogica van de applicatie wordt ondergebracht in klassen die gescheiden zijn van de klasse die de vraag-antwoorddialoog regelt. Zo kan het bovenstaande blok [Logique applicative] uit de volgende elementen bestaan:
In het blok [Logique Applicative] kunnen we een onderscheid maken tussen
- de controllerklasse, die de toegangspoort tot de applicatie vormt,
- het blok [Classes métier], dat de klassen bevat die nodig zijn voor de logica van de applicatie. Deze zijn onafhankelijk van de client.
- het blok [Classes d'accès aux données], dat de klassen bevat die nodig zijn om de gegevens te verkrijgen die de servlet nodig heeft, vaak persistente gegevens (BD, bestanden, service WEB, ...)
- het blok met de pagina’s ASP, dat de weergaven van de applicatie vormt.
In eenvoudige gevallen is de applicatielogica vaak teruggebracht tot twee klassen:
- de controllerklasse die de communicatie tussen client en server verzorgt: verwerking van het verzoek, genereren van de verschillende antwoorden
- de businessklasse die gegevens van de controller ontvangt om te verwerken en deze vervolgens de resultaten terugstuurt. Deze businessklasse beheert vervolgens zelf de toegang tot de persistente gegevens.
Het specifieke karakter van webontwikkeling ligt in het schrijven van de controllerklasse en de weergavepagina’s. De business- en datatoegangsklassen zijn klassieke .NET-klassen die zowel in een webapplicatie als in een Windows-applicatie of zelfs een console-applicatie kunnen worden gebruikt. Het schrijven van deze klassen vereist een goede kennis van objectgeoriënteerd programmeren. In dit document worden ze in VB.NET geschreven; we gaan er dus vanuit dat u deze taal beheerst. Vanuit dit perspectief is het niet nodig om langer dan nodig stil te staan bij de code voor de gegevenstoegang. In vrijwel alle boeken over ASP.NET is een hoofdstuk gewijd aan ADO.NET. Het bovenstaande schema laat zien dat de toegang tot de gegevens plaatsvindt via volstrekt klassieke .NET-klassen die niet weten dat ze in een webcontext worden gebruikt. De controller, die de teamleider van de webapplicatie is, hoeft zich geen zorgen te maken over ADO.NET. Hij hoeft alleen maar te weten bij welke klasse hij de benodigde gegevens moet opvragen en hoe hij dat moet doen. Dat is alles. Het plaatsen van ADO.NET-code in de controller is niet in overeenstemming met het hierboven uitgelegde MVC-concept en dat zullen we dan ook niet doen.
3.2. De hulpmiddelen
Dit document is bedoeld voor studenten, dus we gaan werken met gratis tools die via internet kunnen worden gedownload:
- het .NET-platform (compilers, documentatie)
- de ontwikkelomgeving WebMatrix, die de Cassini-webserver meebrengt
- verschillende SGBD (MSDE, MySQL)
De lezer wordt verwezen naar de bijlage "Webtools", waarin wordt aangegeven waar deze verschillende tools te vinden zijn en hoe ze geïnstalleerd moeten worden. Meestal hebben we slechts drie tools nodig:
- een teksteditor om de webapplicaties te schrijven.
- een ontwikkeltool VB.NET om de VB-code te schrijven wanneer deze omvangrijk is. Dit soort tools biedt doorgaans hulp bij het invoeren van code (automatische codeaanvulling) en het signaleren van syntactische fouten, hetzij tijdens het typen van de code, hetzij tijdens het compileren.
- een webserver om de geschreven webapplicaties te testen. In dit document wordt Cassini gebruikt. Lezers die over de server IIS beschikken, kunnen Cassini vervangen door IIS. Beide zijn compatibel met .NET. Cassini is echter beperkt tot het beantwoorden van uitsluitend lokale verzoeken (localhost), terwijl IIS verzoeken van externe computers kan beantwoorden.
Een uitstekende commerciële omgeving om in VB.NET te ontwikkelen is Visual Studio.NET van Microsoft. Met deze zeer uitgebreide IDE kun je allerlei soorten documenten beheren (VB.NET-code, HTML-documenten, XML, stylesheets, ...). Bij het schrijven van code biedt het de waardevolle hulp van automatische code-aanvulling. Dit gezegd zijnde, heeft deze tool, die de productiviteit van de ontwikkelaar aanzienlijk verbetert, een keerzijde: het dwingt de ontwikkelaar in een standaard ontwikkelingsmodus die weliswaar efficiënt is, maar niet altijd geschikt.
Het is mogelijk om de Cassini-server buiten [WebMatrix] te gebruiken en dat zullen we vaak doen. Het uitvoerbare bestand van de server bevindt zich in <WebMatrix>\<versie>\WebServer.exe, waarbij <WebMatrix> de installatiemap van [WebMatrix] is en <version> het versienummer:
Laten we een DOS-venster openen en naar de map van de Cassini-server gaan:
E:\Program Files\Microsoft ASP.NET Web Matrix\v0.6.812>dir
...
29/05/2003 11:00 53 248 WebServer.exe
...
Laten we [WebServer.exe] zonder parameters starten:
Het bovenstaande venster geeft aan dat de applicatie [WebServer/Cassini] drie parameters ondersteunt:
- /port: poortnummer van de webservice. Dit kan willekeurig zijn. Standaard is de waarde 80
- /path: het fysieke pad naar een map op de schijf
- /vpath: virtuele map die aan de voorgaande fysieke map is gekoppeld.
We plaatsen onze voorbeelden in een bestandsstructuur met als rootmap P en met mappen chap1, chap2, ... voor de verschillende hoofdstukken van dit document. Aan deze fysieke map P koppelen we het virtuele pad V. We starten Cassini dus met de volgende DOS-opdracht:
Als we bijvoorbeeld willen dat de fysieke root van de server de map [D:\data\devel\aspnet\poly] is en de virtuele root [aspnet], dan is de DOS-opdracht om de webserver te starten:
U kunt deze opdracht in een snelkoppeling plaatsen. Zodra Cassini is gestart, wordt er een pictogram in de taakbalk geplaatst. Door hierop te dubbelklikken, krijgt u toegang tot een paneel voor het starten en stoppen van de server:
Het paneel toont de drie parameters waarmee het is gestart. Het bevat twee knoppen voor starten en stoppen, evenals een testlink naar de root van de webstructuur. We volgen deze link. Er wordt een browser geopend en de pagina URL [http://localhost/aspnet] wordt opgevraagd. We krijgen de inhoud van de map die in het bovenstaande veld [Physical Path] is aangegeven:
In dit voorbeeld komt de opgevraagde URL overeen met een map en niet met een webdocument, waardoor de server de inhoud van deze map heeft weergegeven en niet een specifiek webdocument. Als er in deze map een bestand met de naam [default.aspx] staat, wordt dit weergegeven. Laten we bijvoorbeeld het volgende bestand aanmaken en dit in de hoofdmap van de webboomstructuur van Cassini plaatsen (hier d:\data\devel\aspnet\poly):
Laten we nu de URL [http://localhost/aspnet] opvragen met een browser:
We zien dat in werkelijkheid de URL [http://localhost/aspnet/default.aspx] is weergegeven. Verderop in dit document zullen we aangeven hoe Cassini moet worden geconfigureerd met de notatie Cassini(path,vpath), waarbij [path] de naam is van de hoofdmap van de webstructuur van de server en [vpath] het bijbehorende virtuele pad. We herinneren eraan dat bij de Cassini(path,vpath)-server de URL [http://localhost/vpath/XX] overeenkomt met het fysieke pad [path\XX]. We zullen al onze documenten onder een fysieke root plaatsen die we <webroot> zullen noemen. Zo kunnen we het hebben over het bestand <webroot>\chap2\here1.aspx. Voor elke lezer zal deze root <webroot> een map op zijn of haar eigen computer zijn. Hier laten de schermafbeeldingen zien dat deze map vaak [d:\data\devel\aspnet\poly] is. Dit zal echter niet altijd het geval zijn, aangezien de tests op verschillende computers zijn uitgevoerd.
3.3. Eerste voorbeelden
We zullen enkele eenvoudige voorbeelden geven van dynamische webpagina’s die zijn gemaakt met VB.NET. De lezer wordt uitgenodigd om deze te testen om te controleren of zijn ontwikkelomgeving correct is geïnstalleerd. We zullen ontdekken dat er verschillende manieren zijn om een ASP.NET-pagina op te bouwen. We zullen er één kiezen voor de verdere ontwikkeling.
3.3.1. Basisvoorbeeld – variant 1
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
We gaan verder met het voorbeeld uit het vorige hoofdstuk. We maken het volgende [heure1.aspx]-bestand:
<html>
<head>
<title>Demo asp.net </title>
</head>
<body>
Il est <% =Date.Now.ToString("T") %>
</body>
</html>
Deze code is HTML-code met een speciale tag <% ... %>. Binnen deze tag kan VB.NET-code worden geplaatst. Hier is de code
een C-tekenreeks die de huidige tijd weergeeft. De tag <% ... %> wordt vervolgens vervangen door deze C-tekenreeks. Als C dus de tekenreeks 18:11:01 is, wordt de regel HTML met de code VB.NET als volgt:
Laten we de bovenstaande code in het bestand [<webroot>\chap2\heure1.aspx] plaatsen. Laten we Cassini (<webroot>,/aspnet) starten en met een browser de pagina URL [http://localhost/aspnet/chap2/heure1.aspx] opvragen:
Zodra we dit resultaat hebben verkregen, weten we dat de ontwikkelomgeving correct is geïnstalleerd. De pagina [heure1.aspx] is gecompileerd, aangezien deze VB.NET-code bevat. De compilatie ervan heeft een DLL-bestand opgeleverd dat in een systeemmap is opgeslagen en vervolgens door de Cassini-server is uitgevoerd.
3.3.2. Basisvoorbeeld – variant 2
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
Het document [heure1.aspx] bevat zowel HTML-code als VB.NET-code. In zo’n eenvoudig voorbeeld levert dit geen problemen op. Als er meer code VB.NET moet worden opgenomen, is het wenselijk om de code HTML verder te scheiden van de code VB. Dit kan door de code VB te groeperen binnen een <script>-tag:
<script runat="server">
' berekening van de weer te geven gegevens door de code HTML
...
</script>
<html>
....
' weergave van de berekende waarden door het scriptgedeelte
</html>
Het voorbeeld [heure2.aspx] illustreert deze methode:
<script runat="server">
Dim maintenant as String=Date.Now.ToString("T")
</script>
<html>
<head>
<title>Demo asp.net </title>
</head>
<body>
Il est
<% =maintenant %>
</body>
</html>
We plaatsen het document [heure2.aspx] in de boomstructuur [<webroot>\chap2\heure2.aspx] van de Cassini-webserver (<webroot>,/aspnet) en roepen het document op met een browser:
3.3.3. Basisvoorbeeld – variant 3
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
We gaan nog een stap verder in het scheiden van de code VB en de code HTML door ze in twee afzonderlijke bestanden onder te brengen. De code HTML komt in het document [heure3.aspx] te staan en de code VB in [heure3.aspx.vb]. De inhoud van [heure3.aspx] is als volgt:
<%@ Page Language="vb" src="heure3.aspx.vb" Inherits="heure3" %>
<html>
<head>
<title>Demo asp.net</title>
</head>
<body>
Il est
<% =maintenant %>
</body>
</html>
Er zijn twee fundamentele verschillen:
- de richtlijn [Page] met nog onbekende attributen
- het gebruik van de variabele [maintenant] in de code HTML, terwijl deze nergens is geïnitialiseerd
De richtlijn [Page] dient hier om aan te geven dat de code VB, die de pagina zal initialiseren, zich in een ander bestand bevindt. Het is het attribuut [src] dat dit aangeeft. We zullen zien dat de code VB die van een klasse is met de naam [heure3]. Op een voor de ontwikkelaar transparante manier wordt een .aspx-bestand omgezet in een klasse die afstamt van een basisklasse met de naam [Page]. In dit geval moet ons document HTML afleiden van de klasse die de gegevens definieert en berekent die het moet weergeven. Hier is dat de klasse [heure3], gedefinieerd in het bestand [heure3.aspx.vb]. Ook moet deze ouder-kindrelatie tussen het document VB [heure3.aspx.vb] en het document HTML [heure3.aspx] worden aangegeven. Het attribuut [inherits] specificeert deze koppeling. Het moet de naam aangeven van de klasse die is gedefinieerd in het bestand waarnaar het attribuut [src] verwijst.
Laten we nu de code VB van de pagina bekijken:
Public Class heure3
Inherits System.Web.UI.Page
' te weergeven gegevens van de webpagina
Protected maintenant As String
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
'de gegevens van de webpagina worden berekend
maintenant = Date.Now.ToString("T")
End Sub
End Class
Let op de volgende punten:
- de code VB definieert een klasse [heure3] die is afgeleid van de klasse [System.Web.UI.Page]. Dit is altijd het geval, aangezien een webpagina altijd moet zijn afgeleid van [System.Web.UI.Page].
- De klasse declareert een beschermd (protected) attribuut [maintenant]. We weten dat een beschermd attribuut rechtstreeks toegankelijk is in afgeleide klassen. Hierdoor kan het document HTML [heure3.aspx] in zijn code toegang krijgen tot de waarde van het gegeven [maintenant].
- De initialisatie van het attribuut [maintenant] vindt plaats in een procedure [Page_Load]. We zullen later zien dat een object van het type [Page] door de webserver op de hoogte wordt gesteld van een aantal gebeurtenissen. De gebeurtenis [Load] vindt plaats wanneer het object [Page] en de bijbehorende componenten zijn aangemaakt. De handler voor deze gebeurtenis wordt aangeduid door de richtlijn [Handles MyBase.Load]
- De naam [XX] van de gebeurtenishandler kan willekeurig zijn. De handtekening ervan moet echter overeenkomen met de hierboven aangegeven handtekening. We zullen deze voorlopig niet toelichten.
- Vaak wordt de gebeurtenishandler [Page.Load] gebruikt om de waarden te berekenen van de dynamische gegevens die de webpagina moet weergeven.
De documenten [heure3.spx] en [heure3.aspx.vb] worden in [<webroot>\chap2] geplaatst. Vervolgens wordt met een browser de URL [http://localhost/aspnet/chap2/heure3.aspx] opgevraagd bij de webserver (<webroot>,/aspnet):
3.3.4. Basisvoorbeeld - variant 4
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
We gebruiken hetzelfde voorbeeld als hiervoor, maar we bundelen alle code opnieuw in één enkel bestand [heure4.aspx]:
<script runat="server">
' weer te geven gegevens van de webpagina
Private maintenant As String
' evt page_load
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
'de gegevens van de webpagina worden berekend
maintenant = Date.Now.ToString("T")
End Sub
</script>
<html>
<head>
<title>Demo asp.net</title>
</head>
<body>
Il est
<% =maintenant %>
</body>
</html>
We zien hier weer de reeks uit voorbeeld 2:
Deze keer is de code VB in procedures gestructureerd. We zien hier de procedure [Page_Load] uit het vorige voorbeeld terug. We willen hier laten zien dat een afzonderlijke .aspx-pagina (die niet gekoppeld is aan een VB-code in een apart bestand) impliciet wordt omgezet in een klasse die is afgeleid van [Page]. Daardoor kunnen de attributen, methoden en gebeurtenissen van deze klasse worden gebruikt. Dat is hier het geval: we gebruiken de gebeurtenis [Load] van deze klasse.
De testmethode is identiek aan de voorgaande:
3.3.5. Basisvoorbeeld - variant 5
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
Net als in voorbeeld 3 worden de code VB en de code HTML in twee afzonderlijke bestanden opgesplitst. De code VB wordt in [heure5.aspx.vb] geplaatst:
Public Class heure5
Inherits System.Web.UI.Page
' te weergeven gegevens van de webpagina
Protected maintenant As String
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
'de gegevens van de webpagina worden berekend
maintenant = Date.Now.ToString("T")
End Sub
End Class
De code HTML is opgenomen in [heure5.aspx]:
<%@ Page Inherits="heure5" %>
<html>
<head>
<title>Demo asp.net</title>
</head>
<body>
Il est
<% =maintenant %>
</body>
</html>
Deze keer geeft de richtlijn [Page] niet langer de koppeling aan tussen de code HTML en de code VB. De webserver kan de code VB niet meer vinden om deze te compileren (het src-attribuut ontbreekt). Het is aan ons om deze compilatie uit te voeren. In een DOS-venster compileren we daarom de klasse VB [heure5.aspx.vb]:
dos>dir
23/03/2004 18:34 133 heure1.aspx
24/03/2004 09:47 232 heure2.aspx
24/03/2004 10:16 183 heure3.aspx
24/03/2004 10:16 332 heure3.aspx.vb
24/03/2004 14:31 440 heure4.aspx
24/03/2004 14:45 332 heure5.aspx.vb
24/03/2004 14:56 148 heure5.aspx
dos>vbc /r:system.dll /r:system.web.dll /t:library /out:heure5.dll heure5.aspx.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4
Hierboven bevond het uitvoerbare bestand [vbc.exe] van de compiler zich in het bestand PATH op de DOS-machine. Als dat niet het geval was geweest, had het volledige pad naar [vbc.exe] moeten worden opgegeven, dat zich bevindt in de mapstructuur van de map waarin SDK.NET is geïnstalleerd. De klassen die zijn afgeleid van [Page] hebben bronnen nodig die aanwezig zijn in DLL en [system.dll, system.web.dll]; vandaar dat hiernaar wordt verwezen via de optie /r van de compiler. De optie /t:library geeft aan dat we een DLL willen genereren. De optie /out geeft de naam aan van het te genereren bestand, in dit geval [heure5.dll]. Dit bestand bevat de klasse [heure5] die het webdocument [heure5.aspx] nodig heeft. De webserver zoekt de DLL-bestanden die hij nodig heeft echter op welbepaalde locaties. Een van die locaties is de map [bin] in de hoofdmap van zijn mappenstructuur. Deze hoofdmap is wat we <webroot> hebben genoemd. Voor de server IIS is dit doorgaans <station>:\inetpub\wwwroot, waarbij <station> het station is (C, D, ...) waarop IIS is geïnstalleerd. Voor de Cassini-server komt deze root overeen met de parameter /path waarmee u de server hebt gestart. Ter herinnering: deze waarde kunt u verkrijgen door te dubbelklikken op het pictogram van de server in de taakbalk:
<webroot> komt overeen met het hierboven genoemde attribuut [Physical Path]. We maken dus een map <webroot>\bin aan en plaatsen [heure5.dll] daarin:
We zijn klaar. We vragen de URL [http://localhost/aspnet/chap2/heure5.aspx] op bij de Cassini-server (<webroot>,/aspnet):
3.3.6. Basisvoorbeeld - variant 6
Benodigde hulpmiddelen: een teksteditor, de Cassini-webserver
We hebben tot nu toe laten zien dat een dynamische webapplicatie uit twee componenten bestaat:
- VB-code om de dynamische delen van de pagina te berekenen
- HTML-code, die soms VB-code bevat voor de weergave van deze waarden op de pagina. Dit deel vertegenwoordigt het antwoord dat naar de webclient wordt verzonden.
Component 1 wordt de controllercomponent van de pagina genoemd en onderdeel 2 de presentatiecomponent. De presentatiecomponent moet zo min mogelijk VB-code bevatten, of zelfs helemaal geen VB-code. We zullen zien dat dit mogelijk is. Hier laten we een voorbeeld zien waarin er slechts één controller is en geen presentatiecomponent. Het is de controller die zelf het antwoord aan de client genereert, zonder hulp van de presentatiecomponent.
De presentatiecode ziet er dan als volgt uit:
We zien dat er geen HTML-code meer in staat. Het antwoord wordt rechtstreeks in de controller opgesteld:
Public Class heure6
Inherits System.Web.UI.Page
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
' het antwoord wordt opgesteld
Dim HTML As String
HTML = "<html><head><title>heure6</title></head><body>Il est "
HTML += Date.Now.ToString("T")
HTML += "</body></html>"
' het wordt verzonden
Response.Write(HTML)
End Sub
End Class
De controller genereert hier het volledige antwoord in plaats van alleen de dynamische delen ervan. Bovendien verstuurt hij het. Dit gebeurt via de eigenschap [Response] van het type [HttpResponse] van de klasse [Page]. Dit is een object dat het antwoord van de server aan de client vertegenwoordigt. De klasse [HttpResponse] beschikt over een methode [Write] om naar de stream HTML te schrijven, die vervolgens naar de client wordt verzonden. Hier plaatsen we de volledige stream HTML die verzonden moet worden in de variabele [HTML] en sturen we deze naar de client via [Response.Write(HTML)].
We vragen de URL [http://localhost/aspnet/chap2/heure6.aspx] op bij de Cassini-server (<webroot>,/aspnet):
3.3.7. Conclusie
Vervolgens zullen we methode 3 gebruiken, waarbij de code VB en de code HTML van een dynamisch webdocument in twee afzonderlijke bestanden worden geplaatst. Deze methode heeft als voordeel dat een webpagina in twee componenten wordt opgesplitst:
- een controllercomponent die uitsluitend bestaat uit de code VB voor het berekenen van de dynamische delen van de pagina
- een presentatiecomponent, die het antwoord is dat naar de klant wordt verzonden. Deze bestaat uit HTML-code, die soms VB-code bevat voor de weergave van de dynamische waarden. We streven er altijd naar om zo min mogelijk VB-code in het presentatiegedeelte te hebben; het ideaal is om er helemaal geen te hebben.
Zoals uit methode 5 is gebleken, kan de controller onafhankelijk van de webapplicatie worden gecompileerd. Dit heeft als voordeel dat men zich uitsluitend op de code kan concentreren en bij elke compilatie een overzicht krijgt van alle fouten. Zodra de controller is gecompileerd, kan de webapplicatie worden getest. Zonder voorafgaande compilatie voert de webserver de compilatie uit, waarna de fouten één voor één worden gemeld. Dit kan als omslachtig worden ervaren.
Voor de volgende voorbeelden volstaan de volgende hulpmiddelen:
- een teksteditor om de documenten HTML en VB van de applicatie te maken wanneer deze eenvoudig zijn
- een ontwikkeltool zoals IDE of .NET om de klassen VB.NET te genereren, zodat u kunt profiteren van de ondersteuning die dit soort tools bieden bij het schrijven van code. Een voorbeeld van zo'n tool is CSharpDevelop (http://www.icsharpcode.net). Een voorbeeld van het gebruik wordt getoond in de bijlage [Les outils du développement web].
- de tool WebMatrix om de presentatiepagina’s van de applicatie te bouwen (zie bijlage [Les outils du développement web]).
- de Cassini-server
Al deze tools zijn gratis.