ASP.net : ASP.net in vogelvlucht

  1. Wat is .net
  2. Common Language Runtime (CLR)
  3. Objecten en klassen
  4. .Net basisklassen
  5. Streefdoelen van ASP.net
  6. ASP.net code schrijven

Wat is .net

ASP.NET maakt deel uit van het .NET Framework. Om inzicht te krijgen in het .NET Framework volgt een overzicht van de voornaamste aspecten :

Common Language Runtime (CLR)

De Common Language Runtime wordt gebruikt als motor voor alle .NET toepassingen. De rol van de CLR kan je vergelijken met de JVM van Java. De CLR is verantwoordelijk voor het uitvoeren van de code ontwikkeld in .NET applicaties. .NET compilers leveren Intermediate language (IL) i.p.v. machinecode, deze code wordt dan just-in-time (JIT) door de CLR omgezet in machinecodeinstructies.

Objecten en klassen

Om .NET te begrijpen moet je weten wat er bedoeld wordt met een object, .NET is een objectgeoriënteerde omgeving.

Een object is een op zichzelf staande eenheid. Het houdt gegevens(data) vast en laat ons die gegevens door code die we schrijven manipuleren op een eenvoudige welgedefiniëerde manier. De beschrijving van een object leg je vast in een klasse (class definition). Om acties te ondernemen met gegevens van het object definiëren we in de klasse methoden.

De theorie hieromtrent leerde je reeds in de cursus C#.

.Net Basisklassen

.NET bevat een omvangrijke bibliotheek aan klassen die we kunnen gebruiken in onze applicaties. Deze klassen bevatten code die klaar voor gebruik is, en ons veel codegeschrijf kan besparen. Klassen worden gegroepeerd in namespaces. Namespaces bevatten dus klassen die te maken hebben met eenzelfde functionaliteit.

In de namespace System.Drawing ziten bijvoorbeeld klassen die ons in staat stellen grafische objecten zoals cirkels en rechthoeken te tekenen. We kunnen deze basisklassen in onze eigen projecten invoegen.

Streefdoelen van ASP.net

Onafhankelijk werken van script-interpreters

Klassieke ASP werkt met behulp van scripttalen. Dit impliceerde een aantal nadelen: Code wordt geïnterpreteerd i.p.v. gecompileerd: de code wordt pas omgezet in machineinstructies op het moment dat die wordt uitgevoerd, wat performantievelies tot gevolg heeft.
Met ASP.Net wordt wanneer een pagina de eerste keer wordt opgevraagd deze code gecompileerd in een .dll-assembly. Deze assembly wordt geplaatst in een submap %systemroot%/Micrososft.net/Framework/v1.n.nn/Temporary ASP.NET Files. Deze assembly bevat een klasse die werd afgeleid van de System.Web.UI.Page klasse. Deze klasse bevat alle code die gebruikt wordt om de respectievelijke pagina te openen en wordt uitgevoerd door het framework telkens de pagina wordt aangeroepen. De compilering van een pagina hoeft dus slechts één keer te gebeuren. Het enige wat nodig is, is wat hardeschijfruimte op de server. Je kan de locatie van deze map wijzigen door een tempdirectory attribuut op te nemen in het bestand machine.config (zie later). Wanneer een pagina wordt gewijzigd zal en nieuwe assembly worden samengesteld.

De code is nu typevast (variabelen moeten strikt getypeerd worden) en wordt dus gecompileerd.

Doordat ASP.NET pagina's werken met een extensie .aspx kan je op dezelfde server klassieke ASP en nieuwe ASP.NET pagina's gebruiken.

De hoeveelheid code verminderen om webapplicaties te bouwen

Door gebruik te maken van talloze voorgedefiniëerde servercontrols kan je de code in een webapplicatie drastisch verminderen in vergelijking met klassieke ASP of andere server-side talen. Je kunt ook je eigen servercontrols aanmaken waardoor code heel gemakkelijk opnieuw te gebruiken is.

ASP.net staat toe dat gebruikers bestaande functionaliteit uitbreiden / vervangen

Doordat het .NET model volledig gedefiniëerd is in het klassensysteem kan je zelf klassen afleiden op dat model of zelfs bestaande functionaliteit veranderen.

Taal is irrelevant (bijna)

Wanneer je ASP.NET gebruikt kan je als gebruiker vrij kiezen of je C#, VB.NET of zelfs J# wenst te gebruiken. Het is zelfs mogelijk om andere compilers in te stellen voor gebruik binnen het .NET Framework.

Geen tools nodig

Zoals voor ASP heb je voor het ontwikkelen van ASP.NET pagina's geen ontwikkeltools nodig. Je kunt natuurlijk wel gebruik maken van een tool zoals Visual Studio.NET, maar het is zeker geen must, met een teksteditor kan je alle functionaliteit binnen het .NET Framework aanspreken.

ASP.net code schrijven

VS 2005

<SCRIPT>-BLOKKEN

Wanneer je serverside code in een webpagina opneemt, dan moet je deze code markeren om ze te onderscheiden van gewone HTML-code. Om ASP.NET code van HTML code te onderscheiden kan je gebruik maken van de script tag met het attribuut runat="server".

ASP.NET is een technologie waarin met verschillende talen kan worden gewerkt, bovenaan de pagina kan je met een Page-directive aangeven met welke taal je wilt werken :

<%@ Page language="c#" %>
Om een stuk server-side code te markeren gebruik je :
<script language="c#" runat="server">
	…C# declaraties …
</script>
Wanneer je al een Page-directive hebt gebruikt mag je het attribuut language weglaten, vaak wordt het echter voor de duidelijkheid steeds vermeld.
Binnen een script blok mogen enkel declaraties staan: stukken code die we later in de toepassing willen gebruiken wanneer een ander stuk code hen 'triggert".
In zo'n script blok wordt bijvoorbeeld de Page_Load subroutine geplaatst die uitgevoerd wordt wanneer de pagina door de server geladen is.
<%@ Page Language="C#" %>
<script runat="server">

    private void Page_Load(object sender, System.EventArgs e) {

        Bericht.Text = "Welkom in de cursus ASP.net";
    }

</script>

<html>
<head>
</head>
<body>
    <form runat="server">
        <asp:Label id="Bericht" runat="server">Label</asp:Label>
    </form>
</body>
</html>

Opmerking: wanneer je werkt met Visual Studio.net, hou dan in het achterhoofd dat dit programma standaard werkt met een andere techniek voor het plaatsen van ASP.net code: codebehind. Deze techniek komt spoedig aan de orde. Wens je echter deze voorbeelden te maken met VS.net, dan moet de waarde van het attribuut AutoEventWireUp op true(standaard) ingesteld zijn. Anders zal de Page_Load routine niet worden uitgevoerd.

Verplaats het script-blok:

<%@ Page Language="C#" %>
<html>
<head>
</head>
<body>
    <form runat="server">
        <asp:Label id="Bericht" runat="server">Label</asp:Label>
    </form>
</body>
</html>
<script runat="server">

    private void Page_Load(object sender, System.EventArgs e) {

        Bericht.Text = "Welkom in de cursus ASP.net";
    }

</script>
Je merkt dat het resultaat in de browser exact hetzelfde is. De routine Page_Load wordt steeds uitgevoerd vooraleer de server iets van HTML-code terugstuurt naar de browser. De webserver gaat in feite bij een pagina-aanvraag eerst onderzoeken of er script-blokken aanwezig zijn, de code in deze blokken moet steeds in subroutines aanwezig zijn. De positie van deze blokken in niet relevant, ze worden steeds eerst verwerkt.

Inline codeblokken

Het zou natuurlijk erg onhandig zijn mochten we steeds eerst alle dynamische informatie moeten laten verschijnen vooraleer statische HTML-elementen worden getoond. Je kan ASP.NET code ook inline gebruiken met de <% en %> tags (zoals in klassieke ASP).
<%@ Page Language="C#" %>

<html>
<head>
</head>
<body>
    Een HTML-lijn <br/>
    <% Response.Write("Een ASP.net-lijn<br/>"); %>
    Een tweede HTML-lijn<br/>
    <% Response.Write("Een tweede ASP.net-lijn<br/>"); %>
    Een derde HTML-lijn
</body>
</html>
Deze manier van coderen wordt echter afgeraden omdat de ASP.NET code tussen de HTML-code verstrikt raakt en daardoor moeilijk te hergebruiken en onderhouden is. Het is beter te werken met een <script>blok in combinatie met ASP.NET servercontrols. Dit komt verder in de cursus uitgebreid aan bod.

CodeBehind

Met de code behind techniek kan je de programmalogica scheiden van de inhoud van de pagina. Wij hebben in de voorbeelden tot hiertoe steeds gebruik gemaakt van inline code of scriptblokken: de programmalogica en inhoud van de pagina staan in eenzelfde bestand.

Dit voorbeeld demonstreert het werken met Codebehind. De programmalogica staat in een apart bestand (voor VB is dat een .vb - bestand, voor C# een .cs-bestand). De @Page directive in het aspx-bestand bevat een inherits-attribuut, waarbij wordt aangeduid dat we wensen te erven van de MijnCodeBehind-klasse. De klasse kan gevonden worden in het bestand mijncodebehind.cs zoals aangeduid in het CodeFile-attribuut. Belangrijk hierbij is dat je op deze manier slechts van één klasse kan overerven.

De eerste drie regels importeren een aantal belangrijke namespaces uit het .NET Framework. In een webpagina (aspx) worden die namespaces reeds geïmporteerd, echter niet in een .cs-file. Hierna maken we een klasse MijnCodeBehind, deze klasse erft van de Page-klasse uit de System.Web.UI namespace. De namespace werd reeds geïmporteerd, dus de naam van de klasse Page volstaat hier. De naam van de klasse (MijnCodeBehind) stemt natuurlijk overeen met de naam opgegeven in het inherits-attribuut van de @Page-directive in het aspx-bestand.

Dan zorgen we ervoor dat de controls die we wensen te gebruiken in het aspx-bestand gekend zijn in de klasse MijnCodeBehind door ze publiek te declareren.
Daarna volgt de code voor de Page_Load methode.

CodeBehind.aspx
<%@Page Inherits="MijnCodeBehind" src="MijnCodeBehind.cs" %>
<html>
<head>
</head>
<body>
    <form runat="server">
		<asp:label id="bericht"  runat="server" />
    </form>
</body>
</html>
using System;
using System.Web.UI;
using System.Web.UI.WebControls;

public class MijnCodeBehind : Page
{
	   public Label bericht ;

	   public void Page_Load(Object Sender , EventArgs E){

			  bericht.Text = "Hallo ASP.net gebruiker";
		}
}

Visual Studio 2005 gebruikt hier partial classes, waardoor de WebForm (aspx) en de codebehind (aspx.cs) als het ware één klasse vormen.
Daardoor moeten de controls op de pagina (zoals het Label) niet meer gedeclareerd worden.

Meer tutorials:
leer ook: html | xhtml | css | asp | asp.net | c# | ado.net | linq | ajax | java | javascript
Valid HTML 4.01! Valid CSS! © - Cursusweb