3. Einführung in die Webentwicklung ASP.NET

3.1. Introduction

Im vorigen Kapitel wurden die Grundlagen der Webentwicklung vorgestellt, die unabhängig von der verwendeten Programmiersprache sind. Derzeit dominieren drei Technologien den Markt der Webentwicklung:

J2EE, eine Java-Entwicklungsplattform. In Verbindung mit der Struts-Technologie, die auf verschiedenen Anwendungsservern installiert ist, wird die Plattform J2EE vor allem in Großprojekten eingesetzt. Aufgrund der verwendeten Sprache – Java – kann eine J2EE-Anwendung auf den wichtigsten Betriebssystemen (Windows, Unix, Linux, Mac OS, …) laufen.
PHP ist eine interpretierte Sprache, die ebenfalls betriebssystemunabhängig ist. Im Gegensatz zu Java handelt es sich hierbei nicht um eine objektorientierte Sprache. Die Version PHP5 soll jedoch Objekte in die Sprache einführen. Da PHP einfach zu handhaben ist, wird es häufig in kleinen und mittleren Projekten eingesetzt.
ASP.NET ist eine Technologie, die nur auf Windows-Rechnern mit der Plattform .NET (XP, 2000, 2003, …) läuft. Als Entwicklungssprache kann jede mit .NET und c.a.d kompatible Sprache verwendet werden. Es gibt mehr als ein Dutzend davon, angefangen bei den Sprachen von Microsoft (C#, VB.NET, J#) über Delphi von Borland bis hin zu Perl, Python, ...

Im vorigen Kapitel wurden kurze Beispiele für jede dieser drei Technologien vorgestellt. Dieses Dokument befasst sich mit der Webentwicklung ASP.NET mit der Sprache VB.NET. Wir gehen davon aus, dass diese Sprache bekannt ist. Dieser Punkt ist wichtig. Wir befassen uns hier ausschließlich mit ihrer Verwendung im Kontext der Webentwicklung. Lassen Sie uns diesen Punkt näher erläutern, indem wir auf die MVC-Methodik der Webentwicklung eingehen.

Eine Webanwendung, die dem Modell MVC entspricht, wird wie folgt aufgebaut sein:

Eine solche Architektur, die als 3-Tier- oder 3-Schichten-Architektur bezeichnet wird, zielt darauf ab, das MVC-Modell (Model-View-Controller) einzuhalten:

Die Benutzeroberfläche ist die V (die Ansicht)
die Anwendungslogik ist das C (der Controller)
die Datenquellen sind das M (Modell)

Die Benutzeroberfläche ist häufig ein Webbrowser, es könnte sich jedoch auch um eine eigenständige Anwendung handeln, die über das Netzwerk Anfragen an den Webdienst sendet und die von diesem zurückgesendeten Ergebnisse aufbereitet. Die Anwendungslogik besteht aus Skripten, die die Anfragen des Benutzers verarbeiten. Die Datenquelle ist oft eine Datenbank, es können aber auch einfache Textdateien, ein Verzeichnis LDAP, ein entfernter Webdienst usw. sein. Der Entwickler sollte darauf achten, eine weitgehende Unabhängigkeit zwischen diesen drei Komponenten zu wahren, damit bei einer Änderung an einer der Komponenten die beiden anderen nicht oder nur in geringem Umfang angepasst werden müssen.

Die Geschäftslogik der Anwendung wird in Klassen untergebracht, die von der Klasse getrennt sind, welche den Anfrage-Antwort-Dialog steuert. Somit könnte der oben genannte Block [Logique applicative] aus folgenden Elementen bestehen:

Im Block [Logique Applicative] lassen sich unterscheiden:

die Controller-Klasse, die den Einstieg in die Anwendung bildet,
den Block [Classes métier], der die für die Anwendungslogik erforderlichen Klassen umfasst. Diese sind vom Client unabhängig.
den Block [Classes d'accès aux données], der Klassen enthält, die zum Abrufen der für das Servlet erforderlichen Daten notwendig sind, häufig persistente Daten (BD, Dateien, Dienst WEB, ...)
der Block der Seiten ASP, der die Ansichten der Anwendung bildet.

In einfachen Fällen beschränkt sich die Anwendungslogik oft auf zwei Klassen:

die Controller-Klasse, die den Client-Server-Dialog sicherstellt: Bearbeitung der Anfrage, Generierung der verschiedenen Antworten
die Fachklasse, die vom Controller zu verarbeitende Daten erhält und ihm im Gegenzug Ergebnisse liefert. Diese Fachklasse verwaltet dann selbst den Zugriff auf die persistenten Daten.

Die Besonderheit der Webentwicklung liegt in der Erstellung der Controller-Klasse und der Darstellungsseiten. Die Geschäfts- und Datenzugriffsklassen sind klassische .NET-Klassen, die sowohl in einer Webanwendung als auch in einer Windows-Anwendung oder sogar in einer Konsolenanwendung verwendet werden können. Die Erstellung dieser Klassen erfordert gute Kenntnisse in der objektorientierten Programmierung. In diesem Dokument werden sie in VB.NET geschrieben; wir gehen daher davon aus, dass diese Sprache beherrscht wird. Vor diesem Hintergrund ist es nicht notwendig, sich ausführlicher als nötig mit dem Code für den Datenzugriff zu befassen. In fast allen Büchern über ASP.NET ist ein Kapitel dem Thema ADO.NET gewidmet. Das obige Schema zeigt, dass der Datenzugriff über ganz klassische .NET-Klassen erfolgt, die nicht wissen, dass sie in einem Webkontext verwendet werden. Der Controller, der sozusagen der Teamleiter der Webanwendung ist, muss sich nicht um ADO.NET kümmern. Er muss lediglich wissen, von welcher Klasse er die benötigten Daten anfordern muss und wie er dies tun soll. Das ist alles. Das Einfügen von ADO.NET-Code in den Controller entspricht nicht dem oben erläuterten MVC-Konzept, und wir werden dies nicht tun.

3.2. Die Tools

Dieses Dokument richtet sich an Studierende, daher werden wir mit kostenlosen Tools arbeiten, die im Internet heruntergeladen werden können:

die Plattform .NET (Compiler, Dokumentation)
die Entwicklungsumgebung WebMatrix, die den Webserver Cassini mit sich bringt
verschiedene SGBD (MSDE, MySQL)

Der Leser wird gebeten, den Anhang „Web-Tools“ zu konsultieren, in dem angegeben ist, wo diese verschiedenen Tools zu finden sind und wie sie installiert werden. In den meisten Fällen benötigen wir nur drei Tools:

einen Texteditor zum Schreiben der Webanwendungen.
ein Entwicklungstool VB.NET zum Schreiben des VB-Codes, wenn dieser umfangreich ist. Ein solches Tool bietet in der Regel Unterstützung bei der Codeeingabe (automatische Code-Vervollständigung) sowie die Anzeige von Syntaxfehlern entweder bereits während der Codeeingabe oder bei der Kompilierung.
einen Webserver zum Testen der geschriebenen Webanwendungen. In diesem Dokument wird Cassini verwendet. Leser, die über den Server IIS verfügen, können Cassini durch IIS ersetzen. Beide sind mit .NET kompatibel. Cassini ist jedoch darauf beschränkt, nur lokale Anfragen (localhost) zu beantworten, während IIS auch Anfragen von externen Rechnern beantworten kann.

Eine hervorragende kommerzielle Entwicklungsumgebung für VB.NET ist Visual Studio.NET von Microsoft. Dieses sehr umfangreiche IDE ermöglicht die Verwaltung aller Arten von Dokumenten (VB.NET-Code, HTML-Dokumente, XML, Stylesheets usw.). Beim Schreiben von Code bietet es die wertvolle Hilfe der automatischen Code-Vervollständigung. Allerdings hat dieses Tool, das die Produktivität des Entwicklers deutlich steigert, den Nachteil seiner Vorzüge: Es zwingt den Entwickler in einen zwar effizienten, aber nicht immer geeigneten Standard-Entwicklungsmodus.

Es ist möglich, den Cassini-Server außerhalb von [WebMatrix] zu nutzen, und genau das werden wir häufig tun. Die ausführbare Datei des Servers befindet sich in <WebMatrix>\<version>\WebServer.exe, wobei <WebMatrix> das Installationsverzeichnis von [WebMatrix] und <version> dessen Versionsnummer ist:

Öffnen wir ein DOS-Fenster und wechseln wir in den Ordner des Cassini-Servers:

E:\Program Files\Microsoft ASP.NET Web Matrix\v0.6.812>dir
...
29/05/2003  11:00               53 248 WebServer.exe
...

Starten wir [WebServer.exe] ohne Parameter:

E:\Program Files\Microsoft ASP.NET Web Matrix\v0.6.812>webserver

Das obige Fenster zeigt uns, dass die Anwendung [WebServer/Cassini] drei Parameter akzeptiert:

/port: Portnummer des Webdienstes. Kann beliebig sein. Standardwert ist 80
/path: Physischer Pfad zu einem Ordner auf der Festplatte
/vpath: virtueller Ordner, der dem oben genannten physischen Ordner zugeordnet ist.

Wir werden unsere Beispiele in einer Dateistruktur mit dem Stammverzeichnis P und den Ordnern chap1, chap2, … für die verschiedenen Kapitel dieses Dokuments ablegen. Diesem physischen Ordner P ordnen wir den virtuellen Pfad V zu. Daher starten wir Cassini mit dem folgenden DOS-Befehl:

dos> WebServer /port:80 /path:P vpath:V

Wenn wir beispielsweise möchten, dass das physische Stammverzeichnis des Servers der Ordner „[D:\data\devel\aspnet\poly]“ und sein virtuelles Stammverzeichnis „[aspnet]“ ist, lautet der DOS-Befehl zum Starten des Webservers:

dos> WebServer /port:80 /path:D:\data\devel\aspnet\poly vpath:/aspnet

Dieser Befehl kann in eine Verknüpfung eingefügt werden. Nach dem Start legt Cassini ein Symbol in der Taskleiste an. Durch Doppelklick darauf gelangt man zu einem Fenster zum Starten und Beenden des Servers:

Das Fenster zeigt die drei Parameter an, mit denen es gestartet wurde. Es verfügt über zwei Schaltflächen zum Stoppen und Starten sowie einen Testlink zum Stammverzeichnis seiner Webstruktur. Wir folgen diesem Link. Ein Browser wird geöffnet und die Seite URL [http://localhost/aspnet] wird aufgerufen. Wir erhalten den Inhalt des Ordners, der im obigen Feld [Physical Path] angegeben ist:

Im Beispiel entspricht die angeforderte URL URL einem Ordner und keinem Webdokument, daher hat der Server den Inhalt dieses Ordners und kein bestimmtes Webdokument angezeigt. Wenn in diesem Ordner eine Datei mit dem Namen [default.aspx] vorhanden ist, wird diese angezeigt. Erstellen wir beispielsweise die folgende Datei und legen wir sie im Stammverzeichnis der Cassini-Webstruktur ab (hier: d:\data\devel\aspnet\poly):

<html>
    <head>
        <title>Page d'entrée</title>
    </head>
    <body>
    Page d'index...
    </body>
</html>

dos>dir d:\data\devel\aspnet\poly\default.aspx
23/03/2004  18:21                  107 default.aspx

Rufen wir nun die Seiten URL und [http://localhost/aspnet] mit einem Browser auf:

Man sieht, dass tatsächlich die Dateien URL und [http://localhost/aspnet/default.aspx] angezeigt wurden. Im weiteren Verlauf des Dokuments werden wir erläutern, wie Cassini mithilfe der Notation Cassini(path,vpath) konfiguriert werden muss, wobei [path] der Name des Stammordners der Web-Verzeichnisstruktur des Servers und [vpath] der zugehörige virtuelle Pfad ist. Es sei daran erinnert, dass beim Cassini(path,vpath)-Server die URL [http://localhost/vpath/XX] dem physischen Pfad [path\XX] entspricht. Wir werden alle unsere Dokumente unter einem physischen Stammverzeichnis ablegen, das wir <webroot> nennen werden. So können wir beispielsweise von der Datei <webroot>\chap2\here1.aspx sprechen. Für jeden Leser ist dieses Stammverzeichnis <webroot> ein Ordner auf seinem eigenen Rechner. Die hier gezeigten Screenshots verdeutlichen, dass dieser Ordner häufig [d:\data\devel\aspnet\poly] lautet. Dies ist jedoch nicht immer der Fall, da die Tests auf verschiedenen Rechnern durchgeführt wurden.

3.3. Erste Beispiele

Wir werden einfache Beispiele für dynamische Webseiten vorstellen, die mit VB.NET erstellt wurden. Der Leser ist aufgefordert, diese zu testen, um zu überprüfen, ob seine Entwicklungsumgebung korrekt installiert ist. Wir werden feststellen, dass es mehrere Möglichkeiten gibt, eine ASP.NET-Seite zu erstellen. Wir werden eine davon für die weiteren Entwicklungen auswählen.

3.3.1. Grundlegendes Beispiel – Variante 1

Benötigte Werkzeuge: ein Texteditor, der Cassini-Webserver

Wir greifen das Beispiel aus dem vorherigen Kapitel wieder auf. Wir erstellen die folgende [heure1.aspx]-Datei:

<html>
  <head>
      <title>Demo asp.net </title>
  </head>
  <body>
      Il est <% =Date.Now.ToString("T") %>
  </body>
</html>

Dieser Code ist der Code HTML mit einem speziellen Tag <% ... %>. Innerhalb dieses Tags kann man Code VB.NET einfügen. Hier der Code

Date.Now.ToString("T")

eine C-Zeichenkette, die die aktuelle Uhrzeit darstellt. Das Tag <% ... %> wird dann durch diese C-Zeichenkette ersetzt. Wenn C also die Zeichenkette 18:11:01 ist, wird die Zeile HTML, die den Code VB.NET enthält, zu:

      Il est 18:11:01

Speichern wir den obigen Code in der Datei [<webroot>\chap2\heure1.aspx]. Starten wir Cassini (<webroot>,/aspnet) und rufen wir mit einem Browser die Seiten URL und [http://localhost/aspnet/chap2/heure1.aspx] auf:

Sobald dieses Ergebnis vorliegt, wissen wir, dass die Entwicklungsumgebung korrekt installiert ist. Die Seite [heure1.aspx] wurde kompiliert, da sie Code aus VB.NET enthält. Bei der Kompilierung wurde eine DLL-Datei erzeugt, die in einem Systemordner gespeichert und anschließend vom Cassini-Server ausgeführt wurde.

3.3.2. Einfaches Beispiel – Variante 2

Benötigte Tools: ein Texteditor, der Cassini-Webserver

Das Dokument [heure1.aspx] enthält sowohl HTML-Code als auch VB.NET-Code. In einem so einfachen Beispiel stellt dies kein Problem dar. Wenn jedoch weiterer Code aus VB.NET eingebunden werden soll, ist es ratsam, den Code aus HTML stärker vom Code aus VB zu trennen. Dies kann erreicht werden, indem der Code VB innerhalb eines <script>-Tags zusammengefasst wird:

<script runat="server">
     ' Berechnung der anzuzeigenden Daten durch den Code HTML
...
</script>
<html>
....
' Anzeige der berechneten Werte durch den Skriptteil
</html>

Das Beispiel [heure2.aspx] veranschaulicht diese 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>

Wir legen das Dokument [heure2.aspx] in der Verzeichnisstruktur [<webroot>\chap2\heure2.aspx] des Cassini-Webservers (<webroot>,/aspnet) ab und rufen das Dokument mit einem Browser auf:

3.3.3. Einfaches Beispiel – Variante 3

Benötigte Tools: ein Texteditor, der Cassini-Webserver

Wir treiben die Trennung des Codes VB und des Codes HTML weiter voran, indem wir sie in zwei separate Dateien auslagern. Der Code HTML wird in der Datei [heure3.aspx] enthalten sein und der Code VB in der Datei [heure3.aspx.vb]. Der Inhalt von [heure3.aspx] lautet wie folgt:


<%@ Page Language="vb" src="heure3.aspx.vb" Inherits="heure3" %>
<html>
    <head>
        <title>Demo asp.net</title>
    </head>
    <body>
        Il est
        <% =maintenant %>
    </body>
</html>

Es gibt zwei grundlegende Unterschiede:

die Anweisung [Page] mit noch unbekannten Attributen
die Verwendung der Variablen [maintenant] im Code HTML, obwohl sie nirgendwo initialisiert ist

Die Anweisung [Page] dient hier dazu, anzugeben, dass sich der Code VB, der die Seite initialisiert, in einer anderen Datei befindet. Das Attribut [src] gibt diese an. Wir werden feststellen, dass es sich bei dem Code VB um den einer Klasse namens [heure3] handelt. Für den Entwickler transparent wird eine .aspx-Datei in eine Klasse umgewandelt, die von einer Basisklasse namens [Page] abgeleitet ist. In diesem Fall muss unser Dokument HTML von der Klasse abgeleitet sein, die die Daten definiert und berechnet, die es anzeigen soll. Hier ist dies die Klasse [heure3], die in der Datei [heure3.aspx.vb] definiert ist. Außerdem muss diese Eltern-Kind-Beziehung zwischen den Dokumenten VB, [heure3.aspx.vb] und den Dokumenten HTML, [heure3.aspx] angegeben werden. Dieses Attribut [inherits] legt diese Verknüpfung fest. Es muss den Namen der Klasse angeben, die in der Datei definiert ist, auf die das Attribut [src] verweist.

Betrachten wir nun den Code VB auf der Seite:

Public Class heure3
    Inherits System.Web.UI.Page

     ' Anzuzeigende Daten der Webseite
    Protected maintenant As String

    Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
         'Die Daten der Webseite werden berechnet
        maintenant = Date.Now.ToString("T")
    End Sub
End Class

Beachten Sie bitte Folgendes:

Der Code VB definiert eine Klasse [heure3], die von der Klasse [System.Web.UI.Page] abgeleitet ist. Dies ist immer der Fall, da eine Webseite stets von [System.Web.UI.Page] abgeleitet sein muss.
Die Klasse deklariert ein geschütztes (protected) Attribut [maintenant]. Es ist bekannt, dass ein geschütztes Attribut in den abgeleiteten Klassen direkt zugänglich ist. Dies ermöglicht es dem Dokument HTML [heure3.aspx], in seinem Code auf den Wert der Daten [maintenant] zuzugreifen.
Die Initialisierung des Attributs [maintenant] erfolgt in einer Prozedur [Page_Load]. Wir werden später sehen, dass ein Objekt vom Typ [Page] vom Webserver über eine Reihe von Ereignissen benachrichtigt wird. Das Ereignis [Load] tritt ein, wenn das Objekt [Page] und seine Komponenten angelegt wurden. Der Handler für dieses Ereignis wird durch die Direktive [Handles MyBase.Load] festgelegt

    Private Sub XX(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Der Name [XX] des Ereignis-Handlers kann beliebig sein. Seine Signatur muss jedoch der oben angegebenen entsprechen. Wir werden diese vorerst nicht näher erläutern.
Häufig wird der Ereignis-Handler [Page.Load] verwendet, um die Werte der dynamischen Daten zu berechnen, die auf der Webseite angezeigt werden sollen.

Die Dokumente [heure3.spx] und [heure3.aspx.vb] werden in [<webroot>\chap2] abgelegt. Anschließend wird mit einem Browser die Datei URL [http://localhost/aspnet/chap2/heure3.aspx] vom Webserver (<webroot>,/aspnet) angefordert:

3.3.4. Einfaches Beispiel – Variante 4

Benötigte Tools: ein Texteditor, der Cassini-Webserver

Wir behalten das gleiche Beispiel wie zuvor bei, fassen aber den gesamten Code erneut in einer einzigen Datei [heure4.aspx] zusammen:

<script runat="server">
     ' Anzuzeigende Daten der Webseite
    Private maintenant As String

     ' evt page_load
    Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
         'Die Daten der Webseite werden berechnet
        maintenant = Date.Now.ToString("T")
    End Sub
</script>

<html>
    <head>
        <title>Demo asp.net</title>
    </head>
    <body>
        Il est
        <% =maintenant %>
    </body>
</html>

Wir finden die Sequenz aus Beispiel 2 wieder:

<script runat="server">
.... code VB
</script>

<html>
... code HTML
</html>

Diesmal wurde der Code VB in Prozeduren gegliedert. Die Prozedur [Page_Load] aus dem vorherigen Beispiel ist ebenfalls enthalten. Hier soll gezeigt werden, dass eine einzelne .aspx-Seite (die nicht mit einem Code VB in einer separaten Datei verknüpft ist) implizit in eine von [Page] abgeleitete Klasse umgewandelt wird. Daher können die Attribute, Methoden und Ereignisse dieser Klasse verwendet werden. Genau das geschieht hier, wo das Ereignis [Load] dieser Klasse verwendet wird.

Die Testmethode ist identisch mit den vorherigen:

3.3.5. Grundlegendes Beispiel – Variante 5

Benötigte Werkzeuge: ein Texteditor, der Cassini-Webserver

Wie in Beispiel 3 werden der Code „VB“ und der Code „HTML“ in zwei separate Dateien aufgeteilt. Der Code „VB“ wird in „[heure5.aspx.vb]“ abgelegt:

Public Class heure5
    Inherits System.Web.UI.Page

     ' anzuzeigende Daten der Webseite
    Protected maintenant As String

    Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
         'Die Daten der Webseite werden berechnet
        maintenant = Date.Now.ToString("T")
    End Sub
End Class

Der Code HTML wird in [heure5.aspx] eingefügt:


<%@ Page Inherits="heure5" %>
<html>
    <head>
        <title>Demo asp.net</title>
    </head>
    <body>
        Il est
        <% =maintenant %>
    </body>
</html>

Diesmal weist die Anweisung [Page] nicht mehr auf die Verbindung zwischen dem Code HTML und dem Code VB hin. Der Webserver kann den Code VB nicht mehr finden, um ihn zu kompilieren (das Attribut „src“ fehlt). Diese Kompilierung müssen wir selbst vornehmen. In einem DOS-Fenster kompilieren wir daher die 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

dos>dir heure5.dll
24/03/2004  14:51                3 072 heure5.dll

Oben befand sich die ausführbare Datei „[vbc.exe]“ des Compilers in der Datei „PATH“ des DOS-Rechners. Wäre dies nicht der Fall gewesen, hätte man den vollständigen Pfad zu „[vbc.exe]“ angeben müssen, das sich im Verzeichnisbaum des Ordners befindet, in dem „SDK.NET“ installiert wurde. Die von [Page] abgeleiteten Klassen benötigen Ressourcen, die in den Dateien DLL und [system.dll, system.web.dll] vorhanden sind, weshalb diese über die Option /r des Compilers referenziert werden. Die Option /t:library dient dazu, anzugeben, dass eine DLL erzeugt werden soll. Die Option /out gibt den Namen der zu erzeugenden Datei an, in diesem Fall [heure5.dll]. Diese Datei enthält die Klasse [heure5], die das Webdokument [heure5.aspx] benötigt. Der Webserver sucht jedoch an ganz bestimmten Orten nach den DLL-Dateien, die er benötigt. Einer dieser Orte ist der Ordner „[bin]“, der sich im Stammverzeichnis seiner Verzeichnisstruktur befindet. Dieses Stammverzeichnis haben wir als <webroot> bezeichnet. Für den Server „IIS“ ist dies in der Regel <Laufwerk>:\inetpub\wwwroot, wobei <Laufwerk> das Laufwerk (C, D, ...), auf dem IIS installiert wurde. Beim Cassini-Server entspricht dieses Stammverzeichnis dem Parameter /path, mit dem Sie ihn gestartet haben. Zur Erinnerung: Diesen Wert erhalten Sie durch einen Doppelklick auf das Server-Symbol in der Taskleiste:

<webroot> entspricht dem oben genannten Attribut [Physical Path]. Wir erstellen also einen Ordner <webroot>\bin und legen [heure5.dll] darin ab:

Wir sind bereit. Wir fordern die Dateien URL und [http://localhost/aspnet/chap2/heure5.aspx] vom Cassini-Server (<webroot>,/aspnet) an:

3.3.6. Einfaches Beispiel – Variante 6

Benötigte Werkzeuge: ein Texteditor, der Cassini-Webserver

Wir haben bisher gezeigt, dass eine dynamische Webanwendung aus zwei Komponenten besteht:

Code VB zur Berechnung der dynamischen Teile der Seite
HTML-Code, der manchmal VB-Code enthält, um diese Werte auf der Seite anzuzeigen. Dieser Teil stellt die Antwort dar, die an den Web-Client gesendet wird.

Komponente 1 wird als Controller-Komponente der Seite bezeichnet, Teil 2 als Präsentationskomponente. Die Präsentationskomponente sollte so wenig VB-Code wie möglich enthalten, am besten gar keinen VB-Code. Wir werden sehen, dass dies möglich ist. Hier zeigen wir ein Beispiel, bei dem es nur einen Controller und keine Präsentationskomponente gibt. Der Controller generiert die Antwort an den Client selbst, ohne die Hilfe der Präsentationskomponente.

Der Präsentationscode sieht dann wie folgt aus:

 <%@ Page src="heure6.aspx.vb" Language="vb" AutoEventWireup="false" Inherits="heure6" %>

Man sieht, dass darin kein HTML-Code mehr enthalten ist. Die Antwort wird direkt im Controller erstellt:

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
         ' die Antwort wird erstellt
        Dim HTML As String
        HTML = "<html><head><title>heure6</title></head><body>Il est "
        HTML += Date.Now.ToString("T")
        HTML += "</body></html>"
         ' die Antwort wird gesendet
        Response.Write(HTML)
    End Sub
End Class

Der Controller generiert hier die gesamte Antwort und nicht nur deren dynamische Teile. Außerdem sendet er sie ab. Dies geschieht über die Eigenschaft [Response] vom Typ [HttpResponse] der Klasse [Page]. Es handelt sich um ein Objekt, das die vom Server an den Client gesendete Antwort darstellt. Die Klasse [HttpResponse] verfügt über eine Methode [Write], um in den Datenstrom HTML zu schreiben, der an den Client gesendet wird. Hier speichern wir den gesamten zu sendenden Datenstrom HTML in der Variablen [HTML] und senden diese über [Response.Write(HTML)] an den Client.

Wir fordern die URL [http://localhost/aspnet/chap2/heure6.aspx] vom Cassini-Server (<webroot>,/aspnet) an:

3.3.7. Fazit

Im Folgenden werden wir Methode 3 verwenden, bei der der Code „VB“ und der Code „HTML“ eines dynamischen Webdokuments in zwei separate Dateien aufgeteilt werden. Diese Methode hat den Vorteil, dass eine Webseite in zwei Komponenten aufgeteilt wird:

eine Controller-Komponente, die ausschließlich aus dem Code VB besteht, um die dynamischen Teile der Seite zu berechnen
eine Präsentationskomponente, die die an den Client gesendete Antwort darstellt. Sie besteht aus HTML-Code, der manchmal VB-Code zur Anzeige der dynamischen Werte enthält. Wir werden stets darauf hinarbeiten, so wenig VB-Code wie möglich im Präsentationsteil zu haben, wobei es ideal wäre, gar keinen zu haben.

Wie in Methode 5 gezeigt wurde, kann der Controller unabhängig von der Webanwendung kompiliert werden. Dies hat den Vorteil, dass man sich ausschließlich auf den Code konzentrieren kann und bei jeder Kompilierung eine Liste aller Fehler erhält. Sobald der Controller kompiliert ist, kann die Webanwendung getestet werden. Ohne vorherige Kompilierung übernimmt der Webserver diese Aufgabe, und die Fehler werden dann einzeln gemeldet. Dies kann als mühsam empfunden werden.

Für die folgenden Beispiele reichen folgende Werkzeuge aus:

ein Texteditor zum Erstellen der Dokumente HTML und VB der Anwendung, sofern diese einfach sind
ein Entwicklungswerkzeug wie IDE oder .NET zum Erstellen der Klassen VB.NET, um von der Unterstützung dieses Werkzeugs beim Schreiben von Code zu profitieren. Ein solches Tool ist beispielsweise CSharpDevelop (http://www.icsharpcode.net). Ein Anwendungsbeispiel ist im Anhang [Les outils du développement web] dargestellt.
das Tool WebMatrix zum Erstellen der Präsentationsseiten der Anwendung (siehe Anhang [Les outils du développement web]).
den Cassini-Server

Alle diese Tools sind kostenlos.