Programmeren in ASP.NET/Veelgebruikte objecten

Uit Wikibooks
Naar navigatie springen Naar zoeken springen

Programmeren in ASP.NET

  1. Wat is ASP.NET?
  2. Wat heb ik nodig voor ASP.NET?
  3. Een ASP.NET-server installeren
  4. Je eerste ASP.NET-pagina
  5. HTML-controls
  6. Foutzoeken
  7. Web-server-controls
  8. Webformulieren
  9. Veelgebruikte objecten
  10. Validering
  11. Master-pagina's
  12. Navigatie
  13. Gegevenstoegang
  14. Werken met databanken
  15. Databankgegevens wijzigen
  16. Werken met datacontrols
  17. GridView
  18. FormView en DetailsView
  19. User-controls
  20. Custom controls
  21. AJAX
  22. Viewstate
  23. Configuratiebestanden
  24. Webservices
  25. Beveiliging
  26. Personalisatie en profielen
  27. Thema's en skins
  28. WebParts
  29. Globalisering
  30. Caching
  31. Mail vanuit ASP.NET
  32. Reguliere expressies
  33. Server-side afbeeldingen
  34. Mobiele toepassingen
  35. Meer informatie
  36. Appendix: foutmeldingen


Het Page-object[bewerken]

Elk aspx-bestand zorgt ervoor dat er een pagina gegenereerd wordt om naar de browser te sturen. Deze pagina wordt in het object model van ASP.NET afgeleid van het Page-object. Als je met Visual Studio.NET programmeert, zal je merken dat elk codebehind-bestand een class bevat die afgeleid is van het Page-object.

Dit betekent dat alle functies, subroutines en eventuele property's die je toevoegt aan een pagina, in feite methodes en property's worden van de class die behoort bij de pagina. Alle controls op de pagina zullen ook tot deze class behoren. Alle property’s kan je ook opvragen in code via de Me-identifyer.

Het Page-object heeft een heleboel eigenschappen, methodes en property's. Het Page-object is op zijn beurt afgeleid van het Control-object, hetgeen nog extra eigenschappen en methodes oplevert.

We noemen hier enkel de belangrijkste:

Tabel: het Page-object

  Naam Beschrijving
Property's Application verwijst naar het huidige Application-object.
IsPostBack False indien de pagina voor de eerste keer wordt weergegeven. True indien de pagina het resultaat is van een round-trip.
Request verwijst naar het Request-object
Response verwijst naar het Response-object
Server verwijst naar het huidige Server-object
Session verwijst naar het huidige Session-object
User informatie over de gebruiker die de pagina opvraagt
Controls de verzameling controls op de pagina
Methodes DataBind() voert voor alle controls op de pagina databinding uit
FindControl() stelt je in staat een control binnen een pagina te vinden op basis van bijvoorbeeld de ID
Events Init wordt gegenereerd wanneer de pagina wordt geïnitialiseerd.
Load wordt gegenereerd wanneer de pagina wordt geladen, nadat alle controls (inclusief hun viewstate) zijn geladen.
PreRender wordt gegenereerd net voordat de pagina wordt geschreven.

Het HttpRequest-object[bewerken]

Het object HttpRequest is de opvolger van het Request-object in ASP. HttpRequest wordt gemapt naar de eigenschap Request van het Page-object, en daardoor kan je het op dezelfde manier blijven gebruiken als in ASP.

In dynamische sites komt het veel voor dat de gebruiker via een HTML-formulier gegevens naar de server stuurt. Met ASP.NET kan je die gegevens gebruiken om bijvoorbeeld op te slaan in een database, te versturen via een e-mail of juist andere gegevens op te zoeken.

De algemene vorm van een formulier is:

<form action="..." method="..." >
...formulierobjecten...
</form>

In een formulier kunnen verschillende objecten voorkomen: tekstvakken, tekstvak met meerdere regels, keuzerondje, selectievak, keuzelijst, opdrachtenknop.

Wanneer het formulier verstuurd wordt, dan wordt er een lijst met sleutels, dit zijn namen en overeenkomstige waarden gemaakt. De naam van een sleutel is telkens het name-attribuut van het formulierelement, en de waarde is hetgeen de gebruiker invulde of selecteerde.

De waarden in een formulier zijn altijd van het subtype String. Dit betekent dat als je een getal of een datum verstuurt, dit gebeurt in de vorm van een string. Bij het verwerken van de gegevens moet je dan eerst de string opnieuw omzetten naar een getal.

Formulieren koppelen met een ASPX-bestand[bewerken]

Met de opdrachtenknop submit en het action-attribuut van een formulier kan je vanuit een formulier een ASPX-bestand oproepen (dit mag zelfs op een andere server staan). Het formulier zelf hoeft geen ASPX-bestand te zijn, gewoon HTML mag ook.

De gegevens in een formulier kunnen op twee manieren naar de server gestuurd worden, met de POST- of met de GET-methode. Met POST worden de gegevens naar de server gestuurd als onderdeel van de HTTP-headers, met GET als onderdeel van de URL.

Gegevens gebruiken met de GET-methode[bewerken]

Hieronder zie je een voorbeeld van het HTML formulier:

form1.htm

<HTML>
 <head>
  <title>GET-methode</title>
 </head>
 <BODY>
  <form method="GET" action="formget1.aspx">   
     Naam <input type="text" name="naam">
     <br />
     Land <input type="text" name="land">
     <br />
     <input type="submit" value="Verstuur">
  </form>
 </BODY>
</HTML>

Als je in dit formulier als naam "Marie" invult, en als land "Nederland", krijg je na het versturen de volgende URL:

http://servernaam/formget1.aspx?naam=Marie&land=Nederland

Merk op dat alle gegevens in de URL verwerkt werden. De verschillende waarden worden gescheiden door &-tekens, verder worden bijvoorbeeld spaties gecodeerd zodat er geen onbruikbare URL ontstaat.

GET heeft als nadeel dat de gegevens deel uit maken van de URL, wat vooral onhandig is als het bijvoorbeeld om een wachtwoord gaat. Verder is de lengte van een URL beperkt. Sommige oudere browsers ondersteunen geen URL's langer dan 255 tekens. Opera ondersteunt ongeveer 4050 karakters, IE 4.0+ ongeveer 2083 karakters, en Netscape 6 ongeveer 2000.

Hoe kan je nu vanuit je code te weten komen wat de gebruiker ingevuld heeft? Wanneer de GET-methode is gebruikt, kan je waardes uitlezen uit de QueryString-collectie van het Request-object met de opdracht

Waarde=Request.QueryString("NaamVanInvoer")

formget1.aspx

<%@ Page Language="VB" %>
<script runat="server">
	Sub Page_Load(Sender As Object, E As EventArgs)
		Label1.Text="Hallo " & Request.QueryString("naam") & " uit " & 
			Request.QueryString("land")
	End Sub
</script>
<HTML>
<head>
<title>GET-methode</title>
</head>
<BODY>
	<asp:Label id="Label1" runat="server">
	</asp:Label>
</BODY>
</HTML> 

Opmerkingen

  • Waarden in de querystring zijn niet hoofdlettergevoelig
  • In plaats van Request.Querystring("land") kan je kortweg Request("land") gebruiken.
  • Deze methode heeft als nadeel dat je in de URL de doorgegeven waarde kan zien. Als je dat niet wil (bijvoorbeeld met wachtwoorden), gebruik dan de POST-methode. Langs de andere kant kan dit een voordeel zijn bij het zoeken naar fouten: je ziet welke gegevens er uit het formulier komen door de URL te bekijken.
  • De GET-methode geeft met bepaalde browsers problemen indien de door te geven waarde spaties bevat.

Gegevens doorgeven met de POST-methode[bewerken]

Wanneer de POST-methode is gebruikt, dan werkt de QueryString-methode niet (ze geeft een blanco resultaat). Je kan je waardes nu uitlezen uit een andere collectie: de Form-Collectie van het Request-object. Dit doe je met de opdracht Request.Form("NaamVanWaarde"). Hieronder zie je een voorbeeld van het HTML-formulier en vervolgens de code om er wat mee te doen.

form2.htm

<HTML>
<head>
  <title>POST-methode</title>
</head>
<BODY>
<form method="POST" action="formpost2.aspx">
   Naam <input type="text" name="naam">
   <br /> 
   Land <input type="text" name="land">
   <br />
   <input type="submit" value="Verstuur">
</form>
</BODY>
</HTML>

formpost2.aspx

<%@ Page Language="VB" %>
<script runat="server">
	Sub Page_Load(Sender As Object, E As EventArgs)
		Label1.Text="Hallo " & Request.Form("naam") & " uit " & 
			Request.Form("land")
	End Sub
</script>
<HTML>
<head>
  <title>POST-methode</title>
 </head>
<BODY>
	<asp:Label id="Label1" runat="server">
	</asp:Label>
</BODY>
</HTML> 

Opmerkingen

  • In plaats van Request.Form kan je kortweg Request gebruiken, dus Request.Form("getal") kan korter als Request("getal").
  • Je kan de doorgegeven waarden niet zien in de url zoals bij GET, maar als je “Trace=True” instelt in de pagina worden ze onderaan getoond.
  • Als je de pagina na het versturen ververst in de browser, dan zal de browser toestemming vragen om dezelfde gegevens opnieuw te versturen.

Keuze tussen GET en POST in een formulier[bewerken]

Zoals reeds gezegd hebben elk van deze methodes hun voor- en nadelen:

GET POST
Versturen <form method="GET"> <form method="POST">
Uitlezen

Request.QueryString("NaamWaarde")
of
Request("NaamWaarde")

Request.Form("NaamWaarde")

of
Request("NaamWaarde")

Wanneer gebruiken:
  • Tijdens de ontwerpfase: fouten in een formulier kunnen gemakkelijker opgespoord worden door de URL te bekijken
  • Als je de gebruiker wil toelaten de opgevraagde pagina toe te voegen aan zijn of haar Favorieten.
  • Als je direct toegang wil geven tot de pagina via hyperlinks, bijvoorbeeld: www.test.be/index.aspx?taal=nl
  • Wordt door ASP.NET standaard gebruikt voor alle webformulieren.
  • Als er een wachtwoord moet doorgegeven worden. Met GET zou het wachtwoord gewoon leesbaar zijn in de URL.
  • Als er grote tekstvakken (textarea) doorgegeven moeten worden, bijvoorbeeld commentaar, opmerkingen of boodschappen van de gebruiker.
  • Als de URL via GET te lang zou worden (meer dan 1000 tekens).

Opmerking
QueryString en Form kunnen soms tegelijk gebruikt worden. Je kan bijvoorbeeld instellen:

<form action="pag.aspx?taal=nl" method="post">
<input type="text" name="naam">
</form>

In dit geval zal Request.QueryString("taal") als resultaat "nl" geven, en Request.Form("naam") hetgeen door de gebruiker ingevuld werd in het vak "naam".

Werken met verborgen velden[bewerken]

Een verborgen (hidden) veld is van de vorm

<input type="hidden" name="variabele naam" value="waarde"> 

en wordt niet in een formulier getoond.

Wat is dan het nut van zo'n veld?

Verborgen velden kan je gebruiken om zelf bepaalde opties door te sturen, zonder dat deze door de bezoeker gekozen kunnen worden. Ze kunnen ook dienen als een omweg om opties door te sturen die al in een vorig formulier door de gebruiker gekozen werden (bv. een stap voor stap procedure).

ASP.NET gebruikt verborgen velden voor het bewaren van Viewstate|viewstate. Je hoeft hiervoor zelf niets te doen.

Herhalende waarden[bewerken]

In een URL is dit ook toegelaten:

http://www.naam.be/test.aspx?naam=Jan&naam=Els

Merk op dat er twee verschillende waarden opgegeven worden voor dezelfde sleutel "naam". Hoe krijg je dan toegang tot deze afzonderlijke waarden?

In feite geven Request.QueryString() en Request.Form() een collectie van namen en waarden terug (een collectie is een object dat lijkt op een array). Je krijgt toegang tot de afzonderlijke waarden door de methode GetValues() van het NameValueCollection-object te gebruiken.

herhalendewaarden.aspx

<%@ Page Language="VB" %>
<script runat="server">
    Sub Page_Load(sender As Object, e As EventArgs)
    	   ' De regel hieronder geeft: "Jan,Els"
    	   Label1.Text=Request.QueryString("naam")
	   ' De regel hieronder geeft: "Jan"
    	   Label2.Text=Request.QueryString.GetValues("naam")(0)
	   ' De regel hieronder geeft: "Els"
    	   Label3.Text=Request.QueryString.GetValues("naam")(1)
	   ' De lus hieronder geeft "Jan<br>Els "
	   Dim Item As String
	   For Each Item In Request.QueryString.GetValues("naam")
		  Label4.Text=Label4.Text & "<br>" & Item
	   Next
	End Sub
</script>
<html>
<head>
    <title>Herhalende waarden</title>
</head>
<body>
    <form runat="server">
        <asp:Label id="Label1" runat="server"></asp:Label><br>
        <asp:Label id="Label2" runat="server"></asp:Label><br>
        <asp:Label id="Label3" runat="server"></asp:Label><br>
        <asp:Label id="Label4" runat="server"></asp:Label><br>
    </form>
</body>
</html>

Om te testen vraag je deze pagina op met het adres:

http://servernaam/herhalendewaarden.aspx?naam=Jan&naam=Els

Als er maar één waarde is, geven beide methodes hetzelfde resultaat, dus dan heeft het geen belang welke methode je gebruikt.

Request.ServerVariables[bewerken]

De eigenschap ServerVariables van het HttpRequest-object bevat een aantal interessante gegevens over de server en over de gebruiker.

Dit script geeft je een volledige lijst:

servervariables.aspx (fragment)

Function GetSrvVariables() as String
Dim retString as String = ""
Dim i, j As Integer
Dim arr1(), arr2() As String
Dim coll As NameValueCollection
coll=Request.ServerVariables ' Laad de ServerVariables-collectie
arr1 = coll.AllKeys ' Plaats de namen van alle keys in een string-array.
For i = 0 To UBound(arr1)
       retString = retString & arr1(i) 
       arr2 = coll.GetValues(i) ' Haal alle waarden onder deze key.
        For j = 0 To UBound(arr2)
                retString = retString & ": " & arr2(j) & "<br>"
        Next j
Next i
Return retString
End function

Oefeningen[bewerken]

  1. Maak een HTML-pagina (geen ASPX) waar je twee getallen kan invullen. Na het versturen verschijnt een ASPX-pagina waar de som getoond wordt.
  2. Maak een pagina welkom.aspx met een welkom-boodschap. Als de pagina opgevraagd wordt als welkom.aspx of als welkom.aspx?taal=nl, dan is de boodschap in het Nederlands. Als ze opgevraagd wordt als welkom.aspx?taal=fr, dan is de boodschap in het Frans. Test dit uit door zelf de url in te tikken.

Het HttpResponse-object[bewerken]

Het object HttpResponse stelt je in staat gegevens terug te zenden naar de browser. Het is gemapt naar de eigenschap Response van het Page-object, zodat het direct beschikbaar is.

In ASP werd de methode Response.Write() veel gebruikt, maar in ASP.NET is dit nog maar zelden nodig, omdat de server-controls bijna alle uitvoer op zich nemen.

Het HttpResponse-object heeft ook de mogelijkheid om andere soorten bestanden aan te maken naast HTML-bestanden. Voorbeelden hiervan kan je vinden bij het maken van afbeeldingen.

Een methode van HttpResponse die dikwijls van pas komt is Redirect(url). Hiermee kan je de gebruiker doorsturen naar een andere pagina (url is het relatief of absoluut adres van die pagina).

Bijvoorbeeld:

If(ingevoerdWachtwoord<>"123") Then Response.Redirect("start.aspx")

Als het wachtwoord juist is, wordt de gebruiker doorgestuurd naar de startpagina.

Oefeningen[bewerken]

  1. Maak een pagina waar je met radioknoppen kan kiezen tussen 2 talen: Nederlands of Frans. Bij het klikken op "Submit" wordt de gebruiker naar een pagina in die taal gebracht.
  2. Maak een pagina met een quizvraag. Als de bezoeker het juiste antwoord gekozen heeft, toon je een andere pagina. Anders keer je terug naar de quizvraag.

Het HttpSessionState-object[bewerken]

Wat is een sessie?[bewerken]

We praten over een sessie als een gebruiker een pagina van een website opvraagt. Alle pagina's die de gebruiker opent behoren tot dezelfde sessie. Een sessie eindigt als de browser gesloten wordt of als de gebruiker voor een bepaalde tijd geen pagina's meer heeft opgevraagd (time-out). Dit betekent ook dat je meerdere sessies tegelijk kan openen door meerdere browservensters na mekaar te openen.

Wat is het HttpSessionState-object?[bewerken]

Binnen een sessie is het handig om gegevens te bewaren die relevant zijn voor de gebruiker, bijvoorbeeld een gebruikersnaam. Het zou vervelend zijn als de gebruiker deze gegevens telkens weer opnieuw zou moeten opgeven. Je kan deze gegevens opslaan in het HttpSessionState-object. Het wordt gemapt naar de eigenschap Session van het Page-object, zodat het direct toegankelijk is.

Het HttpSessionState-object kan je gebruiken om de waarde van variabelen van de ene naar de andere ASPX-pagina door te geven, of om binnen één pagina bij te houden wat de gebruiker eerder al gedaan heeft.

Stel: in bestand1.aspx plaats je de volgende opdracht in Page_Load:

Session("taal")="nl"

Als de gebruiker verdergaat naar bestand2.aspx (bijvoorbeeld via een hyperlink), dan kan je in bestand 2.aspx het volgende doen:

If(Session("taal")="nl") Then ...

en dan is deze voorwaarde inderdaad voldaan.

In het volgende voorbeeld wordt bijgehouden hoe dikwijls de pagina al ververst werd binnen dezelfde sessie:

session1.aspx

<%@ Page Language="VB" %>
<script runat="server">

Sub Page_Load(Sender As Object, e As EventArgs)
    Session("Teller") = Session("Teller") + 1
    Label1.Text=Session("Teller")
End Sub

</script>
<html>
<head>
    <title>Session</title>
</head>
<body>
    <form runat="server">
        <asp:Label id="Label1" runat="server"></asp:Label>
    </form>
</body>
</html>

Telkens je de pagina ververst, verhoogt de teller (ook als je ondertussen naar andere pagina's surft). Maar als je de browser sluit en dan een nieuwe browser opent, dan is er een nieuwe sessie en de teller begint dan weer bij 1.

Je kan alle Session-variabelen op een bepaald moment bekijken door in het Page-directief Trace="True" in te stellen.

Hoe werkt het Session-object?[bewerken]

De waardes in het HttpSessionState-object worden opgeslagen in het geheugen van de server. Om bij te houden welke sessie van een bepaalde gebruiker is, wordt er een cookie naar de browser gestuurd met een unieke waarde erin: de SessionID. Iedere keer als de browser een aanvraag doet, wordt deze cookie meegestuurd en kan de server terugvinden welke sessie erbij hoort. Deze cookie wordt ongeldig als de browser gesloten wordt, of als er 20 minuten verstreken zijn sinds de laatste aanvraag.

session2.aspx

<%@ Page Language="VB" %>
<script runat="server">

Sub Page_Load(Sender As Object, e As EventArgs)
    Label1.Text=Session.SessionID
End Sub

</script>
<html>
<head>
    <title>Session</title>
</head>
<body>
    <form runat="server">
        <asp:Label id="Label1" runat="server"></asp:Label>
    </form>
</body>
</html>

Indien de browser geen cookies accepteert, dan wordt door ASP.NET een truuk gebruikt met een code in de URL (dit noemt men URL-munging), zodat het Session-object nog steeds werkt.

Het is nadelig voor de snelheid van de server als je veel waardes opslaat in het HttpSessionState-object, zeker als er veel gebruikers zijn. Gebruik het dus met mate.

Let ook op: als de gebruiker op de "Back"-knop van de browser klikt, gaat hij of zij naar de vorige pagina, maar de session-variabelen blijven zoals ze zijn. Dit kan soms tot conflicten leiden.

Session.Abandon()[bewerken]

Deze methode vernietigt de inhoud van de session-variabelen. Per gebruiker wordt een sessie aangemaakt. Abandon() wist de sessie voor de huidige gebruiker.

Session.Timeout[bewerken]

Deze property bepaalt na hoeveel minuten de session-variabelen mogen gewist worden. Default is 20 minuten. Dit betekent dat een gebruiker die gedurende 20 minuten niets doet, zijn sessie verliest. De maximale waarde is 1 jaar.

Voorbeeld:

Session.Timeout=60

Session.LCID[bewerken]

Met de eigenschap LCID (Locale Culture ID) kan je selecteren welke regionale instellingen gebruikt moeten worden. Deze instellingen zijn heel belangrijk in internationale (niet-Engelse) toepassingen, vooral bij het weergeven en invoeren van datum en tijd, en voor het gebruik van de decimale komma. Standaard worden de instellingen van de computer van de gebruiker toegepast.

Voor België gebruik je deze instelling:

Session.LCID = 2067

Voor Nederland gebruik je deze instelling:

Session.LCID = 1043

Voor Amerikaans Engels:

Session.LCID = 1033

De LCID blijft gelden voor alle volgende statements binnen de sessie, tot ze ingesteld wordt op een andere waarde.

Je kan de LCID ook per pagina instellen, in het Page-directief van de pagina:

<%@Page language="VB" LCID="2067" %>

Een lijst met LCID's vind je hier: lijst met LCID's

Oefeningen[bewerken]

  1. Maak een pagina waar de datum op 3 manieren getoond wordt: Belgisch Nederlands, Amerikaans Engels, en Pools.
  2. Zelfde oefening, maar nu voor de currency (munt). Een regio-afhankelijke currency krijg je door te schrijven:
Dim curr As Decimal = 12.55
Label1.Text = curr.ToString("c")
  1. Maak een pagina waar de gebruiker een wachtwoord moet ingeven. Na 3 verkeerde pogingen wordt de toegang geweigerd.
  2. Maak een quiz met 3 meerkeuzevragen, elk op een aparte pagina. Op een 4e pagina geef je de score.

Het HttpApplicationState-object[bewerken]

Het HttpApplicationState-object werkt zoals het HttpSessionState-object, maar de waarden zijn gemeenschappelijk voor alle gebruikers. Dit object roep je op met de eigenschap Application van het Page-object.

Dit object maakt het mogelijk gegevens te delen tussen alle pagina's en alle gebruikers in een applicatie.

Met het HttpApplicationState-object kan je bijvoorbeeld een teller maken die telt hoe vaak een pagina bezocht is (door alle gebruikers samen), maar ook kan je bijvoorbeeld gegevens over de database-koppeling, of andere waarden die je door de hele site nodig hebt, opslaan. Hier is de teller opnieuw, maar nu met het HttpApplicationState-object (ververs de pagina om het resultaat te zien):

appvar1.aspx

<%@ Page Language="VB" %>
<script runat="server">

Sub Page_Load(Sender As Object, e As EventArgs)
    Application ("Teller") = Application ("Teller") + 1
    Label1.Text= Application ("Teller")
End Sub

</script>
<html>
<head>
    <title>Application</title>
</head>
<body>
    <form runat="server">
        <asp:Label id="Label1" runat="server"></asp:Label>
    </form>
</body>
</html>

Stel dat de bovenstaande code tegelijk door twee verschillende mensen bekeken zou worden. Doordat ASP.NET niet alle scripts meteen helemaal afmaakt, maar soms de uitvoering kan stoppen om even een ander script (deels) uit te voeren, zou het zo kunnen zijn dat de waarde die je ziet niet klopt. De waarde zou namelijk opgehoogd kunnen zijn, daarna opgehoogd kunnen zijn door de andere gebruiker en daarna pas in jouw browser geschreven worden. Nu is dit bij een teller niet zo belangrijk, maar het kan zijn dat het wel om informatie gaat die belangrijk is. In dat geval kun je de Lock()-methode gebruiken om ervoor te zorgen dat er geen andere gebruikers zijn die tegelijk toegang krijgen tot de waardes in het HttpApplicationState-object. Omdat dit vertragend werkt moet dit alleen gedaan worden als het nodig is, waarna zo snel mogelijk de Unlock()-methode wordt gebruikt:

appvar2.aspx (fragment)

Sub Page_Load(Sender As Object, e As EventArgs)
    Application.Lock()
    Application("Teller") = Application("Teller") + 1
    Label1.Text=Application("Teller")
    Application.Unlock()
End Sub

De teller kan je initialiseren in het opstartbestand global.asax. Het HttpApplicationState-object heeft nog meer mogelijkheden, maar deze worden weinig gebruikt.

Opmerking
Als de server crasht, of om één of andere reden herstart wordt, dan worden alle gegevens van het Application-object gewist. Bij professionele providers laat men daarom meerdere webservers samenwerken (een zogenaamde web farm).

Het HttpServerUtility-object[bewerken]

Het HttpServerUtility-object is een object met allerlei nuttige toepassingen. Het is beschikbaar via de eigenschap Server van het Page-object.

Enkele eigenschappen en methodes zijn:

Server.Execute(paginanaam) voert de huidige aanvraag uit met behulp van een andere pagina
Server.GetLastError() geeft een Exception-object dat informatie geeft over de laatst opgetreden fout
Server.HtmlEncode(tekst) codeert een string zodat die in de browser getoond kan worden (speciale tekens worden indien nodig aangepast, bv. > wordt &gt;)
Server.HtmlDecode(tekst) omgekeerde van HtmlEncode()
Server.MapPath(relpath) zet een relatief pad om in een absolute bestandslocatie
Server.Transfer(url) stuurt de verwerking door naar een andere pagina

Cookies[bewerken]

Een cookie is een bestand dat met Response.Cookies op de computer van de client wordt geplaatst. Als de client een pagina opvraagt, wordt automatisch de cookie(s) meegestuurd. Dan kan de server met het CookieCollection-object Request.Cookies de cookie opvragen. Dit is een manier om informatie over het vorige bezoek van de gebruiker bij te houden op de computer van de gebruiker zelf (en niet op de server). De cookies worden voor elke site apart opgeslagen, zodat je alleen cookies kan opvragen die door jouw site aangemaakt werden.

Algemene vorm: Response.Cookies("Cookienaam").Value=Waarde

Voorbeeld

Response.Cookies("kleur").Value = kleurGebruiker

om de gekozen kleur in een cookie weg te schrijven.

Dim kleurGebruiker As String = Request.Cookies("kleur").Value

om de gekozen kleur op een andere plaats weer op te vragen.

Er zijn twee soorten cookies:

  1. Session cookies: deze worden alleen behouden tijdens de huidige sessie. Na het sluiten van de browser worden ze verwijderd
  2. Blijvende cookies (persistent cookies): deze blijven bewaard op de pc van de bezoeker, ook na het afsluiten van de browser. Er is wel altijd een vervaldatum, waarna de cookie automatisch verdwijnt.

Je maakt van een cookie een blijvende cookie door er een vervaldatum aan mee te geven:

Response.Cookies("kleur").Value="rood"
Response.Cookies("kleur").Expires = #12/17/2005#

Als je geen vaste datum wil gebruiken, maar de datum wil laten afhangen van de datum van aanmaak:

Response.Cookies("kleur").Expires = DateTime.Now.AddDays(30)

Deze cookie zal vervallen na 30 dagen.

Je kan cookies verwijderen door ze opnieuw te maken met een vervaldatum die al verstreken is (Expires=DateTime.Now.AddDays(-1))

Cookie-voorbeeld[bewerken]

In het bestand cookies.aspx wordt gekeken of de cookie al bestaat, zoniet, kan de gebruiker zijn of haar keuze intikken. Deze keuze wordt bewaard in de cookie. Dan wordt de pagina opnieuw opgeroepen. Omdat de cookie nu bestaat zal de keuze getoond worden.

cookies.aspx

<%@ Page Language="VB" %>
<script runat="server">

    Sub Page_Load(sender As Object, e As EventArgs)
        ' vraag de cookie op
        If(Not IsNothing(Request.Cookies("kleur"))) Then
            lblKleur.Text=Server.HtmlEncode(Request.Cookies("kleur").Value)
            pnlInvoer.Visible=False
        Else
            pnlResultaat.Visible=False
        End If
    End Sub

    Sub btnVerzend_Click(sender As Object, e As EventArgs)
        ' bewaar de cookie
        Response.Cookies("kleur").Value=tbKleur.Text
        Response.Cookies("kleur").Expires=DateTime.Now.AddDays(30)        
        Response.Redirect("cookies.aspx")
    End Sub

</script>
<html>
<head>
    <title>Cookies</title>
</head>
<body>
    <form runat="server">
            <asp:Panel id="pnlInvoer" runat="server">
			Kies een kleur: 
			<asp:TextBox id="tbKleur" runat="server"></asp:TextBox>
            	<asp:Button id="btnVerzend" onclick="btnVerzend_Click" 
				runat="server" Text="Verzenden"></asp:Button>
            </asp:Panel>
            <asp:Panel id="pnlResultaat" runat="server">
			Dit is je kleur: 
			<asp:Label id="lblKleur" runat="server"></asp:Label>
            </asp:Panel>
    </form>
</body>
</html>

Merk op dat de vervaldatum wordt ingesteld op de datum van vandaag plus 30 dagen.

Cookies hebben een aantal nadelen:

  • de meeste browsers beperken de hoeveelheid informatie die je kan bewaren in een cookie. Meestal is die 4096 bytes met oudere browsers, en 8192 bytes met nieuwere.
  • sommige gebruikers stellen hun browser in om cookies te weigeren
  • omdat cookies bij de gebruiker opgeslagen worden, kan er soms mee gesjoemeld worden. Je kan gegevens uit een cookie nooit voor 100% vertrouwen. Gebruik bijvoorbeeld nooit cookies om te weten of een gebruiker gemachtigd is of niet.

Opmerking
De sleutel van de cookie is hoofdlettergevoelig. Dit betekent dat Request.Cookies("kleur") een andere waarde zal hebben dan Request.Cookies("Kleur").

Meer details over cookies vind je nog hier: http://www.codeproject.com/aspnet/AspNetCookies.asp

Oefeningen[bewerken]

  1. Maak een pagina waar de gebruiker zijn of haar naam kan invullen. Op de volgende pagina wordt een boodschap "Welkom, naam." getoond.
  2. Maak een pagina die toont hoeveel keer de gebruiker de pagina al bezocht heeft. Dit keer wordt het aantal behouden, ook als de gebruiker de browser sluit.
  3. Maak een pagina waar de gebruiker een wachtwoord moet ingeven. Na 3 verkeerde pogingen wordt de toegang geweigerd. Gebruik cookies.

Navigatie tussen pagina's[bewerken]

Er zijn drie manieren die je ondertussen kent om tussen pagina's te navigeren. Hieronder wordt een vergelijking gemaakt:

Methode Wat gebeurt er? Wanneer gebruiken?
Response.Redirect() De huidige pagina wordt naar de gebruiker gestuurd met een code 302 (object moved) en de nieuwe url. De browser gebruikt deze informatie om de nieuwe pagina op te vragen.

Het doorsturen gebeurt dus op de client en vereist 2 round trips.

  • als je wil doorverbinden naar een andere server
  • als je wil doorverbinden naar een niet aspx-bestand (bv. een html-bestand)
  • als je de query-string wil doorgeven als onderdeel van de url
Server.Transfer() De uitvoering wordt vanaf het huidige aspx-bestand doorgegeven naar het nieuwe aspx-bestand, op dezelfde server. De browser blijft de oorspronkelijke url tonen, omdat het doorsturen gebeurt op de server.
  • als je wil doorverbinden naar een bestand op dezelfde server.
  • als je de informatie uit een formulier (Form of QueryString) wil mee doorgeven (geef als tweede parameter True op)
Server.Execute() Het nieuwe aspx-bestand wordt uitgevoerd binnen het huidige. Na het uitvoeren van het nieuwe bestand gaat de uitvoer van het oude gewoon door. Je kan dit vergelijken met het oproepen van een functie.
  • als de uitvoer terug moet keren naar het huidige bestand.


Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.