Inhalt
Vorwort
1 Wie .NET und ASP.NET funktionieren
2 Installation
3 Hinweise zu VB.NET
4 »Hallo, Welt!« – Ein ASP.NET-Crashkurs
5 Die Page-Klasse
6 HTML-Serversteuerelemente
7 Validierung von Anwendereingaben
8 Webserversteuerelemente
9 Webserversteuerelemente für die Darstellung von Listen
10 Webserversteuerelemente selbst erstellen
11 Der Status von Seiten, Sitzungen und Applikationen
12 ASP.NET und Datenbanken
13 »Wer darf was?« ASP.NET und Sicherheit
14 Webanwendungen erstellen und konfigurieren
15 Leistungssteigerung durch Caching
16 Web Services
A Anhang
Index
Download (ca 14,3 MB)
Buch bestellen (29,90 EUR)
Ihre Meinung?@
<< zurück | Galileo Computing / <openbook> / Einstieg in ASP.NET | vor >>
Einstieg in ASP.NET von Matthias Lohrer
| Kapitel 4 »Hallo, Welt!« – Ein ASP.NET-Crashkurs
|  | 4.1 Der Aufbau von ASP.NET-Seiten
|  |  | 4.1.1 Die @Page-Direktive
|  |  | 4.1.2 Der serverseitige Skript-Block
|  |  | 4.1.3 Der Block mit HTML-Code
|  | 4.2 Das erste ASP.NET-Skript: »Hallo, Welt!«
|  |  | 4.2.1 »Hallo Welt!« – fast wie ASP
|  |  | 4.2.2 »Hallo, Welt!« im ASP.NET-Stil
|  |  | 4.2.3 »Hallo, Welt!« mit serverseitigen Steuerelementen
|  | 4.3 Formulare mit ASP.NET auswerten: »Hallo, Anwender!«
|  |  | 4.3.1 ASP.NET begrüßt den Anwender
|  |  | 4.3.2 Ein Grundgerüst für ASP.NET-Formulare
|  |  | 4.3.3 Validierung von Anwendereingaben
|  | 4.4 Zusammenfassung und Ausblick
## 4.2 Das erste ASP.NET-Skript: »Hallo, Welt!« ### 4.2.1 »Hallo Welt!« – fast wie ASP Die erste Programmieraufgabe ist immer die gleiche. Ein Entwickler beginnt mit dem Erlernen einer neuen Sprache, indem er der Welt seinen Gruß entrichtet. hallo01.aspx zeigt, wie das mit ASP.NET funktioniert:
    <!-- hallo01.aspx -->
    <%@ Page Language="VB" Debug="True" Strict="True"  %>
    <script runat="server">
    Dim tmp As String ="Hallo, Welt!"
    </script>
    <html><head><title ><% = tmp %></title></head><body>
    <h1><% = tmp %></h1>
    </body></html>
Hier klicken, um das Bild zu Vergrößern Abbildung 4.1 Geschafft! Abbildung 4.1 zeigt das Ergebnis. Dieses erste Beispiel ist wenig spektakulär. Im Prinzip arbeitet es noch so ähnlich wie das klassische ASP. Im Skriptblock wird die Variable tmp definiert, die im HTML-Block zweimal mit <% = tmp %> ausgegeben wird. Gerade am Anfang vergisst man leicht, an den nötigen Stellen das Attribut runat="server" anzugeben. Falls Sie beispielsweise statt <script runat="server"> nur <script> schreiben, erhalten Sie im Browser eine Fehlermeldung wie in Abbildung 4.2. Hier hat ASP.NET beim Kompilieren bemerkt, dass es den Inhalt der Variablen tmp ausgeben soll, dass es diese aber gar nicht kennt. Auch das ist ein bedeutender Unterschied zum klassischen ASP. Während man dort bei Fehlern oft auf Vermutungen angewiesen war, unterstützt ASP.NET den Entwicklungsprozess durch aussagekräftige Fehlermeldungen. Hier klicken, um das Bild zu Vergrößern Abbildung 4.2 Abbildung 4.2:ASP.NET erzeugt aussagekräftige Fehlermeldungen. ### 4.2.2 »Hallo, Welt!« im ASP.NET-Stil Das gleiche Ergebnis kann auf verschiedene Arten erzeugt werden. Es entspricht etwas mehr dem ASP.NET-Stil, wenn Sie den Variableninhalt nicht einfach als Schnipsel in den HTML-Code fallen lassen, sondern die beiden HTML-Elemente, die den variablen Inhalt erhalten sollen, aus dem Code-Block der aspx-Seite heraus steuern. Eine Möglichkeit wäre etwa folgende:
    <!-- hallo02.aspx -->
    <%@ Page Language="VB" Debug="True" Strict="True"  %>
    <script runat="server">
    Sub Page_Load (ByVal Sender As Object, _
                   ByVal E As EventArgs)
       Dim tmp As String ="Hallo, Welt!"
       myTitle.InnerText = tmp
       myH1.InnerText = tmp
    End Sub
    </script>
    <html><head>
    <title id="myTitle" runat="server" ></title></head>
    <body><h1 id="myH1" runat="server"></h1>
    </body></html>
Der HTML-Block wird hier nicht mehr mit <% ... %>-Einsprengseln vermischt. Die beiden Elemente, die den variablen Text zugewiesen bekommen sollen, sind auf eine charakteristische Art und Weise ergänzt worden. Beiden haben ein id-Attribut und das Attribut runat="server" erhalten. Dadurch wird es möglich, den Inhalt dieser Elemente über den Skript-Code zu beeinflussen. Auch im Skript-Block gibt es eine signifikante Neuerung. Hier wird die Ereignisprozedur Page_Load definiert. Eine Prozedur mit diesem Namen wird beim Laden der Seite stets automatisch ausgeführt. Page_Load verfügt immer über die folgende Signatur, die auch für die meisten anderen Ereignisprozeduren charakteristisch ist.
    Sub Page_Load (ByVal Sender As Object, _
                   ByVal E As EventArgs)
Mit dem Wort Ereignisprozedur wird bereits auf ein charakteristisches Merkmal von ASP.NET hingewiesen. ASP.NET ist durch und durch objektorientiert, und das bedeutet auch ereignisorientiert. Beim Laden, beim Anzeigen, beim Eingeben und Klicken – unablässig werden Ereignisse ausgelöst, auf die der Entwickler mit eigenen Routinen reagieren kann. Page_Load ist eine solche Ereignisprozedur, die in sehr vielen aspx-Seiten verwendet wird, weil Sie an dieser Stelle die Seite bequem initialisieren können. Genau das machen Sie auch in hallo02.aspx. Über ihre id sind die beiden serverseitigen Elemente im Code bequem zugänglich, und Sie können den Text dynamisch zuweisen:
       myTitle.InnerText = tmp
       myH1.InnerText = tmp
Wo aber kommt InnerText her? InnerText ist eine Eigenschaft der Klasse HtmlGenericControl. Genauer gesagt hat die Klasse HtmlGenericControl diese Eigenschaft von der abstrakten Basisklasse HtmlContainerControl geerbt. ASP.NET hat das title- und das h1-Element in Objekte vom Typ HtmlGenericControl umgewandelt, als es im HTML-Code jeweils das Attribut runat="server" vorgefunden hat. Alle so genannten Container-Elemente verfügen über die Eigenschaft InnerText. Unter Container-Elementen versteht man solche HTML-Elemente, die selbst andere HTML-Elemente enthalten können, und das gilt für die meisten HTML-Elemente. Das img-Element wäre etwa ein Beispiel für ein HTML-Element, das kein Container-Element ist, denn es kann keine weiteren HTML-Elemente in sich aufnehmen. Eine weitere nützliche Eigenschaft von HtmlGenericControl neben innerText ist InnerHtml. Damit können Sie dem jeweiligen Element nicht nur puren Text, sondern auch komplette HTML-Sequenzen zuweisen. Die Überschrift umbricht beispielsweise auf zwei Zeilen, wenn Sie folgenden Code verwenden:
    myH1.InnerHtml = "Hallo, <br>Welt!"
Achtung Wenn Sie hier stattdessen InnerText verwendet hätten, würde im Browser der Text Hallo, <br>Welt! genau in dieser Form erscheinen. InnerText sorgt dafür, dass eventuelle Sonderzeichen, wie etwa die spitzen Klammern, in das jeweilige HTML-Äquivalent umgeformt werden. ASP.NET würde bei der Zuweisung
    myH1.InnerText = "Hallo, <br>Welt!"
folgenden HTML-Code erzeugen:
    <h1 id="myH1">Hallo, &lt;br&gt;Welt!</h1>
Sie können das selbst nachprüfen, wenn Sie den Skript-Code entsprechend anpassen, das Skript im Browser aufrufen und sich dann über Ansicht • Quelltext den HTML-Quellcode anzeigen lassen. Abbildung 4.3 zeigt alle drei Ansichten: den ASP.NET-Quellcode, die Darstellung im Browser und den HTML-Code, der im Browser angekommen ist. Hier klicken, um das Bild zu Vergrößern Abbildung 4.3 Die Eigenschaft InnerText zitiert den übergebenen Text. InnerHTML würde das <br>-Tag unverändert lassen. ### 4.2.3 »Hallo, Welt!« mit serverseitigen Steuerelementen Im vorangegangenen Beispiel haben Sie den HTML-Code komplett selbst erstellt, und mit Hilfe des Skriptcodes haben Sie innerhalb eines HTML-Elements Text eingefügt. Noch mehr dem ASP.NET-Stil entspricht es, wenn Sie stärker von der HTML-Codierung abstrahieren. Vom typischen ASP.NET-Ansatz her würden Sie beispielsweise sagen: An dieser Stelle soll eine Meldung ausgegeben werden. Die Meldung soll so und so aussehen, und wie das am Ende in HTML codiert wird, interessiert mich eigentlich nicht. ASP.NET soll selbst den benötigten HTML-, CSS- und JavaScript-Code generieren. Das Listing hallo03.aspx gibt eine zusätzliche Meldung aus, die mit Hilfe eines solchen serverseitigen Steuerelements realisiert wird. Abbildung 4.4 zeigt die Darstellung im Browser und den von ASP.NET generierten HTML-Code.
    <!-- hallo03.aspx -->
    <%@ Page Language="VB" Debug="True" Strict="True"  %>
    <%@ Import Namespace="System.Drawing.Color" %>
    <script runat="server">
    Sub Page_Load (ByVal Sender As Object, _
                   ByVal E As EventArgs)
       Dim tmp As String ="Hallo, Welt!"
       myTitle.innerText = tmp
       myH1.InnerText = "Hallo, Welt!"
       meldung.Text = "Oh, Du schöner Westerwald!"
       meldung.Font.Bold = True
       meldung.Font.Size = new FontUnit(12)
       meldung.BackColor = System.Drawing.Color.FromArgb _
                                              (200, 0, 100)
       meldung.ForeColor = System.Drawing.Color.LightGreen
    End Sub
    </script>
    <html><head>
    <title id="myTitle" runat="server" ></title></head>
    <body><h1 id="myH1" runat="server"></h1>
    <asp:Label id="meldung" runat="server" />
    </body></html>
Hier klicken, um das Bild zu Vergrößern Abbildung 4.4 Serverseitige ASP.NET-Steuerelemente generieren selbstständig HTML-, CSS- und JavaScript-Code. Dieses Beispiel zeigt ein grundlegendes ASP.NET-Prinzip recht deutlich. Der Entwickler schreibt in den HTML-Block der aspx-Datei lediglich ein recht abstraktes Element, das mit dem herkömmlichen HTML-Code nichts mehr zu tun hat:
    <asp:Label id="meldung" runat="server" />
Mit Hilfe des Skriptcodes beeinflusst er die Eigenschaften dieses Elements. Das geschieht hier wieder innerhalb der Ereignisprozedur Page_Load:
       meldung.Text = "Oh, Du schöner Westerwald!"
       meldung.Font.Bold = True
       meldung.Font.Size = new FontUnit(12)
       meldung.BackColor = System.Drawing.Color.FromArgb _
                                              (200, 0, 100)
       meldung.ForeColor = System.Drawing.Color.LightGreen
Die Umsetzung in HTML- und CSS-Code übernimmt ASP.NET. So entsteht:
    <span id="meldung" style="color:LightGreen;background-color:#C80064;font-size:12pt;
    font-weight:bold;">Oh, Du schöner Westerwald!</span>
Achtung ASP.NET ist ein Code-Generator. Als gestandener Webentwickler muss man sich erst daran gewöhnen, dass ASP.NET einem die HTML-Bausteine aus der Hand nimmt und selbst anfängt zu bauen.
Wenn Sie es gewöhnt sind, dass im Browser exakt der HTML-Code ankommt, den Sie selbst codiert haben, müssen Sie sich bei ASP.NET umgewöhnen. Der erste Eindruck beim Blick in den HTML-Code, den ASP.NET generiert hat, ist oft eher »Und das soll von mir kommen?«
<< zurück | <top> | vor >>
Zum Katalog
Einstieg in ASP.NET bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung

.NET-Bibliothek
| Einstieg in VB.NET
| VB.NET
| Einstieg in C#
| Visual C#
| VB.NET und Datenbanken

Empfehlung
| Einstieg in XML

Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

MyGalileo
Der Service für registrierte Leser: Info

Copyright © Galileo Press GmbH 2003
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de