Visual Web Developer 2005 Express Edition

André Wussow Visual Web Developer 2005 Express Edition

André Wussow

Visual Web Developer 2005 Express Edition

André Wussow : Visual Web Developer 2005 ISBN 3-935042-83-3

© 2006 entwickler.press Ein Imprint der Software & Support Verlag GmbH

http://www.entwickler-press.de http://www.software-support.biz

Ihr Kontakt zum Verlag und Lekorat: [email protected] Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

Korrektorat: mediaService, Siegen Satz: mediaService, Siegen Umschlaggestaltung: Melanie Hahn Bild mit freundlicher Genehmigung von HP. Belichtung, Druck & Bindung: M.P. Media-Print Informationstechnologie GmbH, Paderborn Alle Rechte, auch für Übersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datenträgern oder andere Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung für die Richtigkeit des gesamten Werks kann, trotz sorgfältiger Prüfung durch Autor und Verlag, nicht übernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschützt.

Inhaltsverzeichnis Vorwort

1

2

3

...................................................................................................

Visual Web Developer Express . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Systemvoraussetzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was wird in diesem Buch beschrieben? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An wen richtet sich dieses Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webseite und Buch-CD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Danksagungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Über den Autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kontakt zum Autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fehlerteufel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Installation und Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Startbildschirm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Programmoberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Visual Web Developer-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfache ASP.NET-Seite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erweiterte ASP.NET-Seite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Konfigurationsdatei web.config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Serversteuerelemente (Webcontrols) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Die erste eigene Webseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vorlagen, Master- und Inhaltsseiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Vorlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Masterseiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Masterseite erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Inhaltsseiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Inhaltsseite erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 Dateibasierte Datenbanklösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenbank einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ansicht erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gespeicherte Prozedur erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Microsoft SQL Server 2005 Express . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verbindung aufbauen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tabellen, Ansichten und gespeicherte Prozeduren . . . . . . . . . . . . . . . . . . . . . . . . 3.3 Einbinden der Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variante 1: Per Webcontrol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variante 2: Per Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Express Edition

9 10 10 11 12 12 13 14 14 15 17 17 18 19 21 23 25 26 29 30 32 41 41 43 44 48 49 53 53 55 57 60 61 62 64 64 64 72

5

Inhaltsverzeichnis 4

Navigation und Siteübersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 Das Menü-Steuerelement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Erstellung einer Siteübersicht-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Siteübersicht generieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Designvorlagen und Lokalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Designvorlagen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Cascading Style Sheets (CSS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Designvorlagen verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 Lokalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Administration und Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Sicherheit mit dem Visual Web Developer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Seiten schützen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Debugging und Error-Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Error-Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3 Fehlerseiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Anwendungsbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 Ein Newsskript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2 Ein Gästebuch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3 Ein Blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4 Eine Fotogalerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5 Eine E-Mail-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 Ein Counter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7 Der Transfer ins Netz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Webseitenverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 Administrationsoberfläche anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2 Skript pflegen und verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Webservices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Ein eigener Webservice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A Crashkurs „SQL“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.1 Was ist SQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.2 Abfragearten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Auswahlabfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aktionsabfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B Crashkurs „Visual Basic .NET“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.1 Was ist Visual Basic? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B.2 Variablen, Konstanten und Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variablen und Übersichtlichkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

79 79 81 85 87 87 90 93 95 101 101 104 107 107 111 112 117 117 122 128 136 143 148 157 159 159 162 167 168 183 183 183 184 186 189 189 190 192 192

Inhaltsverzeichnis B.3 B.4 B.5

Mathematische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Abfragen und Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die For...Next-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Do...Loop-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Entscheidungsfrage: For…Next oder Do…Loop? . . . . . . . . . . . . . . . . . . Funktionen und Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

B.6 B.7 B.8 B.9 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Express Edition

193 195 198 198 200 201 202 204 204 205 207

7

Vorwort Visual Web Developer 2005 Express Edition. Warum Express Edition? Hinter dem Begriff Express Edition versteckt sich eine ganze Reihe von Produkten aus dem Hause Microsoft. Hierbei handelt es sich stets um leicht abgespeckte Versionen der jeweiligen vollwertigen großen Schwestern. Dabei soll „vollwertig“ keinesfalls diese Edition wertlos machen. Sie warten lediglich mit einem kleineren Funktionsumfang auf den Benutzer. Auf der alljährlichen TechEd-Konferenz am 29.06.2004 verkündigte Microsoft zum ersten Mal die so genannte „light“-Version seiner kommenden neuen Entwicklungsumgebung Visual Studio 2005. Insgesamt gibt es in der Express-Produktfamilie vier Programmiersprachen (C++, C#, Visual Basic und J#), eine Entwicklungsumgebung für Webanwendungen (ASP) und einen Datenbankserver (SQL Server). Auch wenn hierbei stets die Sprache von abgespeckten Versionen ist, so ist der Funktionsumfang gar nicht so stark eingeschränkt wie vielleicht vermutet. Es handelt sich hierbei lediglich um Auskopplungen aus dem Visual Studio, der Code im Hintergrund ist der gleiche. Der Webpart im Visual Studio wird teilweise auch als Visual Web Developer betitelt. Ein enormer Vorteil soll sogar in der leichteren Bedienung sowie Erlernbarkeit liegen. Auch an der Dokumentation wurde hart gefeilt. Sie wurde enorm übersichtlich und vereinfacht gestaltet sowie mit einer Menge von Beispielanwendungen, so genannten Starter Kits, versehen. Express-Ergebnisse lassen sich problemlos in ein „großes“ Visual-StudioProjekt übernehmen. Auch die Installation geht schneller als beim herkömmlichen Visual Studio 2005. Durchschnittlich soll der Installationsvorgang innerhalb von zehn Minuten erfolgreich abgeschlossen sein. Während beim Visual Studio professionelle Entwickler im Visier der Redmonder stehen, wirft Microsoft mit seiner Express-Reihe ein Auge auf Hobbyprogrammierer, Semiprofessionelle, Einsteiger, Enthusiasten, Schüler und Studenten, die bislang durch die enorm hohen Anschaffungskosten eher abgeschreckt worden sind. Ein weiterer Grund der Express Editionen liegt darin, diese Sprachen auch außerhalb von Unternehmen zu fördern und diese weiter zu verbreiten. Die aktuell erhältlichen Versionen sind seitens Microsoft unentgeltlich und frei auf seinen Seiten erhältlich. Dieses Angebot gilt allerdings lediglich ein Jahr. Nach dem 6. November 2006 werden diese dann, abgesehen von der SQL Server Express Edition, für vorraussichtlich weniger als 50 Euro erhältlich sein. Der SQL Server bleibt in der Express Edition allerdings weiterhin kostenlos. Express Edition

9

Vorwort

Visual Web Developer Express Der Visual Web Developer symbolisiert professionelle Entwicklungswerkzeuge für die Programmierung von dynamischen und umfangreichen Webseiten basierend auf ASP.NET 2.0. Er konzentriert sich ausschließlich auf die Entwicklung von Web-Applikationen. Er bietet eine übersichtliche Oberfläche für eine benutzerfreundliche und übersichtliche Entwicklung von Web-Applikationen. Sein leistungsstarker CodeEditor wartet mit zahlreichen Funktionen auf. Beispielsweise unterstützt er das so genannte Syntax-Highlighting des Quellcodes. Somit wird dieser wesentlich übersichtlicher dargestellt. Dank IntelliSense wird das Schreiben des Codes beschleunigt und Syntaxfehler werden schon während der Programmierung deutlich markiert. Mit dem integrierten Datenbanken-Explorer wird der Zugriff auf verschiedene Datenquellen, wie zum Beispiel Access- und SQL-Server-Datenbanken, sehr einfach gemacht. Datenbanken können darüber sehr komfortabel angelegt und editiert werden. Ein weiteres Administrationstool ist nicht notwendig. Zur Programmierung der eigentlichen Seiten stehen zahlreiche Programmiersprachen zur Verfügung, wie beispielsweise Visual Basic .NET, C#.NET und J#.NET. Damit der Einstieg nicht so schwer fällt, werden auch spezielle StarterKits angeboten. Neu ist auch der integrierte Webserver. Während bei den Vorgänger-Versionen meistens ein Internet Information Server in der Voraussetzungs-Liste auftauchte, ist er in dieser Version bereits integriert. Somit lässt sich die eigene Applikation unkompliziert testen und debuggen – der Web Developer bringt alles mit. So auch ein Webseiten-Kopier-Tool, mit dem es möglich ist, die Webseite direkt ins Netz zu stellen.

Systemvoraussetzungen Für den einwandfreien Betrieb des Visual Web Developers wird ein Prozessor mit mindestens 600 Mhz Taktfrequenz vorausgesetzt, der Autor empfiehlt aber ein System mit mindestens 1000 Mhz, da die Anwendung recht komplex ist und somit flüssiger läuft. Optimal sind 1,5 Ghz und mehr. Als Betriebssystem wird Windows 2000 mit Service Pack 4, Windows XP mit Service Pack 2, Windows Server 2003 mit Service Pack 1, eine Windows x64Edition oder Windows Vista benötigt. 10

Vorwort

Laut Microsoft sind 256 MB Arbeitsspeicher unabkömmlich, der Autor befürwortet jedoch mindestens 512 MB für die reibungslose Arbeit mit dem Programm. 1024 MB sind optimal. Die Komplettinstallation inklusive der Express Edition des Microsoft SQL Server 2005 und der MSDN Express Library 2005 benötigt ca. 1,3 GB Festplattenkapazität. Die Komplettinstallation wird auf jeden Fall empfohlen, da der SQL Server als Datenbankserver für einige Beispielprogramme genutzt wird und die MSDN Express Library ein umfangreiches Nachschlagewerk mit vielen gut dokumentierten Beispielen darstellt. Das .NET 2.0 Framework ist natürlich auch Pflicht, denn es stellt die Basis für jede mit dem Web Developer entwickelte Anwendung dar. Auch der SQL Server benötigt dieses. Bei der Komplettinstallation wird es selbstverständlich mitinstalliert.

Was wird in diesem Buch beschrieben? Das Buch soll zwei wesentliche Aufgaben erfüllen. Zum einen soll es eine Schritt-für-Schritt-Anleitung zum Erstellen einer Webseite darstellen, zum anderen aber auch als ein Referenz-Werk fungieren. Da der Leser direkt, dank diesem Buch, in die Programmierung einsteigen kann, werden benötigte Grundkenntnisse in einem kurzen Abriss beschrieben. Dieser Part kann selbstverständlich, sofern bereits Kenntnisse vorhanden sind, übersprungen werden. Sehr wichtig sind auch die vielen verschiedenen Techniken zur Webseitenerstellung. Hinsichtlich dieser gibt es durchaus viele verschiedene Lösungen, von der schnell und einfach zu realisierenden bis hin zur etwas komplexeren, dafür aber komfortabel zu pflegenden, Variante. Jede dieser Lösung hat natürlich auch ihre Vor- und Nachteile, die offen gelegt werden. Bei der Wahl gibt es kein richtig oder falsch. Sie müssen die für sich praktikabelste Lösung herausfinden. Die wichtigsten Techniken zur Realisierung einer Webseite werden ausführlich erklärt. Datenbanken, Webservices, Multimedia, Templates und Webadministration sind ein paar Oberbegriffe, die besonders in der heutigen Zeit immer mehr an Gewicht zulegen. Doch neben diesen gängigen Methoden werden auch weitere Techniken erklärt, so dass der Leser mehrere Varianten zur Auswahl hat und seine bevorzugten Methoden entdecken und anwenden kann. Die Vielfältigkeit ist vorhanden, die Wahl muss selber getroffen werden. Veranschaulicht werden die Themen durch viele gut durchkommentierte Beispiele, so dass keine Fragen offen bleiben. Im Laufe des Buches wird eine komplette Webseite, beziehungsweise schon eher eine komplette Webanwendung, programmiert. Diese beinhaltet unter anderem ein Gästebuch, ein Blog, ein Express Edition

11

Vorwort

Newssystem, eine Multimedia-Galerie sowie verschiedene E-Mail-Lösungen. Selbstverständlich wird die endgültige Anwendung komplett ohne Programmierkenntnisse per Web-Frontend administrierbar sein – weltweit.

An wen richtet sich dieses Buch? Dieses Buch ist vor allem an Anfänger gerichtet. Computerkenntnisse sowie der Umgang mit dem Windows-Betriebssystem und dessen Anwendungen sind von Vorteil. Kenntnisse im Bereich der Programmierung werden nicht vorausgesetzt, sind aber natürlich auch erwünscht. Das Buch ist speziell an Einsteiger in die Webprogrammierung gerichtet. Es soll ihnen aufzeigen, wie schnell und unkompliziert eine Webseite erstellt werden kann. Ohne großen Aufwand wird eine komplexe Anwendung in einer vergleichbar kurzen Zeit erstellt. Gerade zur heutigen Zeit, wo der Trend der eigenen Homepage sichtlich steigt, ist es gut zu wissen, dass man nicht auf vorgefertigte Lösungen zurückgreifen muss.

Webseite und Buch-CD Auf der Buch-CD finden Sie mit freundlicher Genehmigung von Microsoft die Vollversion des Visual Web Developer 2005 in der Express Edition. Sämtliche Beispiele können Sie sich unter http://www.vwd-express.de herunterladen und bei sich lokal testen. Unter http://ww.monas-world.de finden Sie eine Live-Version der Beispiel-Webseite. Des Weiteren befinden sich dort Aktualisierungen und Zusätze zum Buch sowie ein Forum, wo Sie in direkten Kontakt mit dem Autor treten können. Selbstverständlich können in diesem Forum auch auftretende Probleme behandelt werden. Ebenso freut sich der Autor über neue Ideen und Anregungen und wird Ihnen bei der Realisation Ihrer Ideen gerne behilflich sein.

Tipp Der Autor stellt Ihnen auf der Buch-Webseite kostenlosen Webspace (Internet Speicherplatz) für einen 30-Tage-Test Ihrer ersten eigenen Internetseite zur Verfügung. Des Weiteren wartet für alle Leser ein einmaliges Special für längere Laufzeiten. Es lohnt sich. Link: http://www.vwd-express.de

12

Vorwort

Danksagungen Bedanken möchte ich mich an erster Stelle recht herzlich bei meinem Kollegen Peter Monadjemi, der mir in meiner bisherigen Laufbahn als Autor zu jeder Zeit mit Rat und Tat zur Seite stand. Egal mit welchen Fragen ich ihn durchbohrte, geduldig und hilfsbereit fand er stets die passende Antwort. Vor allem seine ehrliche und konstruktive Kritik führte zu dem, was aus mir geworden ist. Ohne ihn würde es dieses Buch definitiv nicht geben. Vielen Dank auch an Christiane Auf und Erik Franz von entwickler.press. Sie hatten die Idee zu diesem Buch und standen mir jederzeit mit Rat und Tat zur Verfügung. Danke auch an Tobias Hauser für die fachliche Überprüfung und seine sehr wertvolle Kritik. Durch ihre Förderung halten Sie dieses Werk in der Hand. Auch noch bedanken möchte ich mich bei Ilka Bonten und Sabine Esser, die für mich jede Menge Zeit aufbrachten, um mich und mein erstes Buch von Anfang an zu fördern. Diese Förderung beschreibt sich nicht nur durch ständige Motivation, sondern auch durch fachliche Unterstützung. In jedem Entwicklungsstadium haben beide sämtliche sprachlichen Unebenheiten sowie schwache Formulierungen eliminiert und korrigiert. Herzlichen Dank auch an Sebastian Löwenhag und Tim Hütz. Sie übernahmen die fachliche Seite und ließen ihre kritischen Blicke jederzeit über den Inhalt dieses Buches schweifen. Ihre freie Zeit opferten sie auch der Überprüfung jeglicher programmierter Anwendungen, damit Sie sich als Leser über funktionstüchtige Beispiele freuen können. Vielen lieben Dank auch an Ramona Steves für die Genehmigung zur Verwendung ihrer Person und Fotos für die Beispiel-Anwendung. Last but not least wäre da noch Andreas Franke von mediaService, der mir während der kritischen Endphase mit Rat und Tat zur Seite stand. Danke auch an all diejenigen, die mich zwischendurch motiviert und aufgebaut haben, wenn es mal nicht so gut lief oder voranschritt wie gewünscht, und auch Verständnis zeigten, wenn ich mal nicht so viel Zeit wie gewünscht oder gewollt aufbringen konnte. Danke auch an meine Familie, Freunde und Bekannte, die mich bisher auf irgendeine Weise gefördert und unterstützt haben, und mich zu dem gemacht haben, was ich heute bin. Danke. Express Edition

13

Vorwort

Über den Autor André Wussow wurde am 27. Mai im Jahre 1983 in Aachen geboren. Schon sehr früh entwickelte sich sein Interesse an Technik und deren Fortschritt. Aus diesem Grunde wechselte er 2000 nach Beendigung seines Pflichtschulteils auf ein technisches Gymnasium mit dem Schwerpunkt Elektrotechnik und erwarb darauf folgend 2003 die allgemeine Hochschulreife. Im Anschluss daran folgte eine Ausbildung zum Fotomedienlaboranten in einem Fotogroßlabor in Mönchengladbach. Diese Ausbildung verkürzte er erfolgreich auf zwei Jahre und schrieb sich 2005 in Aachen für den Studiengang Informatik ein. Nebenberuflich ist er bereits seit mehreren Jahren als Autor für diverse Verlage und Publikationen tätig. Hierbei liegen seine Themenschwerpunkte in der Programmierung mit Visual Basic .NET, ASP.NET, C++ und PHP. Des Weiteren ist er Geschäftsführer einer Webagentur, die sich ausschließlich mit Internetdienstleistungen beschäftigt, als freiberuflicher Fotograf und Designer tätig und in der Mobilfunk- sowie Foto-Medien-Branche aktiv.

Kontakt zum Autor Selbstverständlich freut sich der Autor über Lob, Anregungen und Kritik. Fehlerhinweise und Unstimmigkeiten sind selbstredend auch von großem Interesse, damit schnell reagiert werden kann und Aktualisierungen auf der oben genannten Webseite veröffentlicht werden. Der Autor steht Ihnen praktisch rund um die Uhr unter [email protected] zur Verfügung. Unter der Internetadresse http://www.vwd-express.de finden Sie aktuelle Informationen, Quellcodes und Korrekturen zum Buch.

14

Vorwort

Fehlerteufel Natürlich werden von vornherein fehlerfreie Beispiele angestrebt. Noch bevor sie in diesem Buch beschrieben und auf die Webseite gepackt werden, werden die Beispiele ausgiebig von verschiedenen Personen und auf verschiedenen Systemen getestet. Dennoch kann es durchaus einmal vorkommen, dass unerwartet Fehler auftreten. Sollten Sie auf einen solchen Fehler beim Abtippen eines Listings treffen, so probieren Sie bitte zuerst das entsprechende, fertige Beispiel von der Webseite aus. Sollte der gleiche Fehler auftreten und es sich wider Erwarten doch nicht um einen Druckfehler im Listing handeln, so wenden Sie sich bitte direkt an den Autor. Dieser wird dann schnellstmöglich reagieren und helfen sowie gegebenenfalls eine Aktualisierung auf der Webseite zum Buch vornehmen. Sämtliche Fehler gehen natürlich auf das Fehlerkonto des Autors.

Express Edition

15

1

Einführung

Im ersten Kapitel werden die Installation und die erste Benutzung des Visual Web Developers beschrieben. Sofern Sie noch nicht mit dem Visual Web Developer oder einer vergleichbaren Version, wie zum Beispiel der Visual Studio 2005 oder Visual Basic 2005 – Express Edition, gearbeitet haben, ist dieses Kapitel Pflicht für Sie. Andernfalls können Sie dieses Kapitel überlesen oder oberflächig durchblättern. Auf einen Blick: 쐌 Installation und Konfiguration 쐌 Der erste Programmstart 쐌 Anlegen und Laden von Projekten 쐌 Erklärung der Oberfläche 쐌 ASP.NET-Grundlagen 쐌 Die erste Webseite

1.1 Installation und Konfiguration Zur Installation legen Sie einfach die dem Buch beiliegende Installations-CD ein. Das Installationsprogramm startet normalerweise automatisch. Sollte der Autostart deaktiviert sein, muss das Setup-Programm (setup.exe) einfach über den Arbeitsplatz gestartet werden. Folgen Sie einfach den Anweisungen der Installationsroutine. Sie müssen lediglich den Zielort, an dem der Visual Web Developer installiert werden soll und die zu installierenden Komponenten auswählen und der Rest wie die Konfiguration wird automatisch durchgeführt.

Express Edition

17

1 – Einführung

Abb. 1.1: Die Installationsroutine

Wichtig ist es, dass Sie auf jeden Fall den SQL Server mitinstallieren, da er für die Beispiele in diesem Buch zwingend erforderlich ist. Weiterhin bekommen Sie dadurch eine leistungsfähige Datenbankengine, die sämtliche Anwendungsdaten verwalten kann.

1.2 Erste Schritte Nach der erfolgreichen Installation kann das Programm entweder über das Icon auf dem Desktop gestartet werden oder aber über den Eintrag im Startmenü. Der Visual Web Developer wird geladen und es öffnet sich der Startbildschirm. In diesem können Sie vorhandene Projekte öffnen oder neue anlegen. Neu und sehr informativ ist auch der so genannte MSDN-Newsflash. Er zeigt aktuelle Beiträge des MSDN (Microsoft Developer Network) an. Neben Beispielen und einer umfangreichen Dokumentation sind dies auch Update-Informationen, Tutorials und sogar Angebote für Entwickler, die mit dem Web Developer arbeiten.

18

Erste Schritte

Abb. 1.2: Der Startbildschirm

Tipp Wenn Sie sich bei Microsoft für die Nutzung der Software registrieren lassen, bekommen Sie 250 lizenzfreie Bilder sowie 100 lizenzfreie Icons, die Sie für Ihre Webseite verwenden können. Außerdem erhalten Sie Zugriff auf diverse E-Books und vorgefertigte Komponenten, die Sie einfach in Ihren eigenen Applikationen verwenden können. Link: http://msdn.microsoft.com/vstudio/express/register/ Das MSDN ist im Normalfall die erste Anlaufstelle für Entwickler, die mit Produkten der Visual-Familie arbeiten. Die Dokumentation ist sehr gut und größtenteils auch auf Deutsch verfügbar.

1.2.1

Der Startbildschirm

In der Startübersicht befindet sich ein weiterer Menüpunkt. Unter ZULETZT PROJEKTE befinden sich, wie der Name schon sagt, die zuletzt bear-

GEÖFFNETE

Express Edition

19

1 – Einführung

beiteten Projekte. Diese Auflistung ist nach dem ersten Programmstart natürlich leer, wenn sie ein Projekt begonnen haben, können sie hier schnell darauf zurückgreifen und weiter arbeiten. Außerdem können hier Projekte geöffnet werden, die nicht mehr in der Liste enthalten sind oder aber neue Projekte erstellt werden, womit nun begonnen werden soll. Mit einem Klick auf ERSTELLEN | WEBSITE… öffnet sich ein neues Fenster. In diesem befinden sich bereits so genannte Templates (Vorlagen). Diese stellen in einer gewissen Art und Weise Richtlinien dar, mit denen Projekte definiert werden können. Um einen Einblick in den Visual Web Developer zu erhalten, wird mit einer neuen ASP.NET-Webseite begonnen. Zusätzlich kann der Speicherort des Projektes bestimmt werden, dabei stehen Dateisystem, http und ftp zur Auswahl. Am Anfang wird das Dateisystem empfohlen, da es besonders leicht, dank des integrierten Webservers, getestet werden kann. Die Veröffentlichung im Netz per http oder ftp kann später immer noch problemlos nachgeholt werden.

Abb. 1.3: Ein neues Projekt erstellen

20

Erste Schritte

Eine weitere Auswahl kann auch in Form der Programmiersprache durchgeführt werden: Es kann zwischen Visual Basic .NET, Visual C# .NET und J# .NET (Java) ausgewählt werden. In diesem Buch werden sämtliche Beispiel mit Visual Basic .NET realisiert. Nachdem jede Auswahl getroffen, sowie der Speicherort festgelegt wurde, kann das Projekt angelegt werden. Das Programm befindet sich nun im „EntwicklerModus“, in dem effektiv an dem eigenen Projekt gearbeitet werden kann. Nun ist es Zeit, die Oberfläche kennen zu lernen.

1.2.2

Die Programmoberfläche

Abb. 1.4: Die Programmoberfläche

Auf der Oberfläche befinden sich fünf wichtige Bereiche. Der erste Bereich (1) stellt das Menü dar. Hierüber können Projekte geladen und erstellt, Eigenschaften betrachtet und editiert, Ansichtseinstellungen verändert, Komponenten und Referenzen hinzugefügt und verschiedene Tools aufgerufen werden. Während

Express Edition

21

1 – Einführung

der normalen Arbeit wird das Menü allerdings recht selten genutzt, wichtiger ist hier die Werkzeugleiste. Diese, auch Toolbox (2) genannt, bietet sämtliche verwendbaren Komponenten, die problemlos in das Projekt integriert und benutzt werden können. Dort befinden sich neben Textfeldern auch andere Formularelemente wie Radio- und Options-Felder, DropDown und Listboxelemente und natürlich auch Buttons. Aber auch Bilder, Tabellen, Datei-Upload-Möglichkeiten und Kalenderelemente lassen sich darüber einbinden. Neben diesen Elementen befinden sich dort aber auch Funktionen zum Einbinden von Datenbank-Quellen oder vorgefertigte Routinen für Passworteingaben, Navigationselementen und Formularüberprüfungen. Ein Blick lohnt sich auf jeden Fall und erspart in den meisten Fällen sehr viel Arbeit. Die einzelnen Elemente sind in so genannten Gruppen organisiert (siehe Tabelle 1.1). Gruppe

Inhalt

Standard

Standard-.NET-Steuerelemente, die auf dem Server ausgeführt werden und direkt angesprochen werden können

Daten

Erweiterte .NET-Steuerelemente für datengebundene Inhalte.

Validierung

Erweiterte .NET-Steuerelemente für die Überprüfung (Validierung) von Benutzereingaben.

Navigation

Vorgefertigte .NET-Steuerelemente zur Erleichterung der Seiten-Navigation.

Anmelden

Vorgefertigte .NET-Steuerelemente für geschützte Bereiche

WebParts

WebPart-Elemente, unter anderem für SharepointPortale und Microsoft Office.

HTML

Standard HTML-Elemente.

Tabelle 1.1: Der Toolbox-Inhalt

Das zentrale Fenster wird durch den Editor (3) dargestellt. Hier findet die eigentliche Programmierung und Gestaltung der Webseite statt. Neben einer so genannten WYSIWYG-Funktion (What you see is what you get-Funktion – HTML-Editor auf einer Vorschau basierend – Entwurfsmodus) bietet er einen

22

Visual Web Developer-Grundlagen

umfangreichen Quellcode-Editor (Quelle) mit Syntax-Highlighting und AutoVervollständigung bekannter Befehle und Funktionen. Fehler können somit schneller erkannt und beseitigt werden und wegen der automatischen Vervollständigung (auch IntelliSense genannt) findet man auch unbekanntere Funktionen schnell wieder. Zwischen beiden Editoren kann mit den unteren Schaltflächen umgeschaltet werden. Für die Übersichtlichkeit des Projektes und für das Management der zugehörigen Dateien ist der Explorer (4) verantwortlich. Hier kann zwischen PROJEKTMAPPEN- und DATENBANK-EXPLORER umgeschaltet werden. Letzteres hat eine ähnliche Aufgabe wie der Projektmappen-Explorer, nur dass er anstelle für die Dateien für die Datenbanken und Datentabellen verantwortlich ist, und die Benutzung enorm vereinfacht. Beide können spielend leicht angelegt und mit Daten gefüllt werden. Ein weiteres Tool zum Administrieren einer solchen Datenbank-Lösung ist also nicht notwendig. Alles, was zur Programmierung einer Webapplikation benötigt wird, bietet der Visual Web Developer auf wirklich komfortable Art und Weise. Ebenso komfortabel ist das eingerichtete Eigenschaften-Fenster (5), hier lassen sich alle integrierten Elemente wie gewünscht einstellen und einrichten. Neben einer eindeutigen Identifizierungs-ID (numerisch oder alphanumerisch) kann hier auch das Erscheinungsbild (Schriftart, Farbe, Größe, …) festgelegt werden. Es empfiehlt sich auf jeden Fall die umfangreiche Liste einmal durchzugehen, um alle Möglichkeiten kennen zu lernen. Es ist bekannt, dass der Mensch am besten aus der praktischen Erfahrung lernt, also kann es nur von Vorteil sein, verschiedene Schritte auszuprobieren, um alle Möglichkeiten abwägen und sich einprägen zu können.

1.3 Visual Web Developer-Grundlagen Dank der .NET-Plattform wird für sämtliche Programmiersprachen aus dem Hause Microsoft nur noch ein Laufzeitsystem benötigt. Dies hat den unmittelbaren Vorteil, dass Methoden- und Funktionsaufrufe nicht mehr direkt ausgeführt werden, sondern an die CLR (Common Language Runtime – das eigentliche .NET Framework) delegiert werden. Diese Runtime erzeugt eine spezielle Sprache: MSIL (Microsoft Intermediate Language). Diese Sprache ist hervorragend dokumentiert und jeder Compiler, der diese Sprache erzeugt, darf Code im Rahmen der Runtime ausführen lassen.

Express Edition

23

1 – Einführung

Somit lassen sich auch mehrere Programmiersprachen kombinieren. Eine in Visual Basic .NET erstellte Klasse lässt sich beispielsweise problemlos in Visual C# .NET ableiten. Dank dem .NET Framwork ist die Wahl der Programmiersprache zur Entwicklung von Anwendungen nur noch zweitrangig. Beim .NET Framework handelt es sich um eine umfangreiche Klassenbibliothek, die nahezu für alle Bereiche der Programmierung Lösungen anbietet. Die bisherigen, für jede Programmiersprache separierten Programmierschnittstellen sind zu einem gemeinsamen und vereinheitlichten Modell verschmolzen worden. Dieses Modell stellt die primäre Schnittstelle für die Entwicklung von .NET-Anwendungen dar. Während also früher ASP-Seiten (Active Server Pages) mit einer speziellen ASP.dll interpretiert worden sind, werden ASP.NET-Seiten durch das .NET Framework richtig kompiliert. Beim Aufruf einer ASP.NET-Seite trennt das Framework folglich den HTML-Code vom eigentlichen Programmcode, interpretiert letzteren und generiert eine statische HTML-Seite daraus. Dieser Vorgang wird mit jedem Seitenaufruf wiederholt. Auch wenn bei der Arbeit mit dem Visual Web Developer das Testen der Seite automatisch mit dem Internet Explorer erledigt wird, so bedeutet dies keinesfalls, das ASP.NET-Seiten nur auf diesem lauffähig sind. Das Framework arbeitet streng nach den HTML-Richtlinien und ASP.NET-Seiten sind folglich auf allen aktuellen Browsern lauffähig. Für die Programmierung von ASP.NET-Seiten, die mit diesem Framework realisiert worden sind, steht logischerweise der komplette Funktionsumfang zur Verfügung. Es gibt keinen Unterschied im Gegensatz zu üblichen DesktopAnwendungen. Der Programmierung sind kaum Grenzen gesetzt. Die Programmierung von ASP.NET-Seiten ist vielfältig. Diese Vielfältigkeit liegt einmal in der Wahl der Programmiersprache (z.B. Visual Basic, C# oder J#) und in dem Aufbau einer Seite. Hierbei unterscheidet man zwischen zwei Seitenarten: Einfach (HTML-Dokumente mit integrierten Skript-Tags für den Programmcode) und Erweitert (HTML-Dokument und Programmcode werden in getrennten Dateien bereitgestellt). Nun zum Aufbau einer ASP.NET-Seite. Zu Beginn befindet sich in der Regel ein ASP-Directive. Dieses dient der Einstellung diverser Compiler- und Seitenoptionen. Allerdings spielt es keine Rolle, wo dieses Directive positioniert wird. Es kann auch am Ende oder mitten in der Datei stehen. In der Regel wird dieses aber umgehend am Beginn der Seite angelegt, da es durchaus einer guten Struktur, sowie der Übersichtlichkeit, dient. 24

Visual Web Developer-Grundlagen Listing 1.1: Beispiel für ein ASP-Directive <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>

Es spielt übrigens keine Rolle, ob das Directive in einer einzigen Zeile steht, oder wie im Beispiel-Listing übersichtlich auf mehreren Zeilen verteilt ist. Mit dem Parameter Language wird die Programmiersprache definiert, in welcher der Programmcode geschrieben wird. Als Wert für diesen Parameter kann C#, VB, oder JS eingegeben werden. Der Codebehind-Parameter legt bei der Benutzung einer separaten Programmcode-Datei den Dateinamen fest, in welchem der Programmcode aufzufinden ist. Anhand dieser Datei muss bereits ersichtlich sein, in welcher Sprache sie geschrieben ist. Wurde zum Beispiel als Programmiersprache VB (oder C#) ausgewählt, so trägt die Datei die Dateiendung .vb (oder .cs) und muss in Visual Basic (bzw. C#) geschrieben sein. Mit Inherits wird die Klasse definiert, die in der Programmcode-Datei angelegt worden ist. In der Regel ist der Name der Klasse gleich dem Dateinamen. Dies ist allerdings keine Vorgabe. Der Parameter AutoEventWireup legt fest, ob die Seite automatisch an so genannte Ereignisse (z.B. wenn die Seite geladen wird oder ein Button geklickt wird) gebunden wird oder nicht. Wird der Parameter auf true gesetzt, so werden keine Handles benötigt. Ein Nachteil liegt allerdings darin, dass wenn zum Beispiel das Page_Load-Ereignis abgefragt werden soll, die dazugehörige Sub exakt den Namen des Ereignisses tragen muss. Auf false gesetzt, spielt der Name der Sub keine Rolle, da das Ereignis mit der Handles-Methode abgefangen wird. Standardmäßig ist der Wert false, da es für ordentlichen und übersichtlichen Programmcode sorgt. Wie bereits erwähnt gibt es zwei Varianten, um eine ASP.NET-Seite zu erstellen.

1.3.1

Einfache ASP.NET-Seite

Der Programmcode wird mit einem so genannten Skript-Tag unmittelbar in das HTML-Dokument eingebunden. Die Sprachendefinition erfolgt im KopfBereich mit dem ASP-Directive. Auch bei dem Skript-Tag spielt es keine Rolle, ob es sich am Anfang, in der Mitte oder am Ende der Seite befindet. Express Edition

25

1 – Einführung Listing 1.2: Beispiel für die einfache Variante <%@ Page Language="VB" AutoEventWireup="false" %> <script runat="server"> Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load MsgBox("Test") End Sub

In diesem Beispiel wird lediglich eine MsgBox mit der Mitteilung „Test“ ausgegeben. Programmcode und HTML-Code befinden sich in einer Datei. Dies hat den Vorteil, dass es pro ASP.NET-Seite nur eine einzige Datei gibt.

1.3.2

Erweiterte ASP.NET-Seite

Bei der erweiterten Variante werden, wie bereits weiter oben erwähnt, HTMLund Programmcode strikt voneinander getrennt. Mit dem ASP-Directive wird die Datei, die den Programmcode enthält, definiert und eingebunden. Listing 1.3: Der HTML-Part <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default"%>

26

Visual Web Developer-Grundlagen Listing 1.3: Der HTML-Part (Forts.)

Wie bereits bei der einfachen Variante soll lediglich beim Laden der Seite eine MsgBox mit der Mitteilung „Test“ ausgegeben werden. Listing 1.4: Der Programmcode-Part Partial Class _Default Inherits System.Web.UI.Page Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load MsgBox("Test") End Sub End Class

Zwei Varianten für ein und dieselbe Funktion. Auf den ersten Blick erscheint die erweiterte Variante ein wenig umständlicher und vor allem umfangreicher. Aber besonders bei größeren Projekten macht sie sich bezahlt, da sie übersichtlicher und ordentlicher ist. Des Weiteren zeugt es von einem guten Programmierstil, wenn Layout und Code strikt getrennt werden.

Express Edition

27

1 – Einführung

Abb. 1.5: Übersichtlichkeit im Projektmappen-Explorer

Im Visual Web Developer wird die erweiterte Variante übersichtlich dargestellt, indem die Code-Datei der Hauptdatei untergeordnet wird. Im gesamten Buch wird stets mit der erweiterten Variante gearbeitet. Auch ist es empfehlenswert sich diesen Stil anzueignen und stets damit zu arbeiten. Ein ASP.NET-Projekt besteht in der Regel aus vier Dateiobjekten: Dem Ordner App_Data, der .aspx- und .aspx.vb (oder .aspx.c / .aspx.js) und der Konfigurations-Datei web.config. In dem Ordner App_Data werden sämtliche Anwendungsdaten hinterlegt. Allerdings ist der Inhalt dieses Ordners nicht öffentlich verfügbar, er kann nur über den Programmcode integriert werden. Für Grafiken, Fotos und Ähnliches wird am besten ein eigener Ordner angelegt. Die eigentliche ASP.NET-Webseite wird durch die HTML- und Programmcode-Datei definiert. In der Konfigurationsdatei befinden sich alle Einstellungen der Seite. Anstelle der manuellen Konfiguration kann diese bequem über WEBSEITE | ASP.NET-KONFIGURATION festgelegt werden. Grundsätzlich gibt es mehrere geschützte ASP.NET-Ordner, die einem Projekt hinzugefügt werden können. Alle diese, so genannten Anwendungsordner sind gegen einen öffentlichen Zugriff geschützt. Daten in diesen Ordnern können folglich nicht über den Browser abgerufen werden. Ordner

Beschreibung

App_Code

Dateien in diesem Ordner können von allen ASP.NET-Seiten genutzt werden. Hier können zum Beispiel Programmcode-Dateien ausgelagert werden.

App_Data

In diesen Ordner werden Datenbank-Dateien (z.B. von Access oder SQLite) hinterlegt.

Tabelle 1.2: ASP.NET-Ordnerübersicht

28

Visual Web Developer-Grundlagen App_GlobalResources Speicherort für globale Resource-Dateien. Darunter fallen Sprach- oder Konfigurationsdateien. App_LocalResources

Speicherort für lokale Resource-Dateien. Darunter fallen Sprach- oder Konfigurationsdateien.

App_WebReferences

Speicherort für Web-Referenzen, wie zum Beispiel Webservices.

App_Themes

Speicherort für verschiedene Designvorlagen (Layouts) der Webseite.

App_Browsers

Speicherort für .browser-Dateien zur typenspezifischen Anpassung der verschiedenen Webbrowser.

Bin

Speicherort für kompilierte Assemblys (z.B. Programmbibliotheken [.dll]).

Tabelle 1.2: ASP.NET-Ordnerübersicht (Forts.)

1.3.3

Die Konfigurationsdatei web.config

In der Konfigurationsdatei web.config können alle webseitenspezifischen Einstellungen vorgenommen werden. Darunter fallen Zugangsdaten für Datenquellen, Webservice-Einstellungen oder auch die Benutzerverwaltung. Für jede Webseite gibt es eine eigene Konfigurationsdatei. Diese wird im XMLFormat definiert. Allerdings müssen die Einstellungen nicht manuell vorgenommen werden. Der Visual Web Developer bietet hierfür ein extra Konfigurationsprogramm (Menü WEBSEITE | ASP.NET KONFIGURATION), mit welchem sämtliche Einstellungen vorgenommen werden können. Nicht zu vergessen sind auch bereits vorgefertigte Code-Bausteine, die für viele klassischen Aufgaben bei der Programmierung von Webanwendungen vorgefertigte Lösungen anbieten. Diese Bausteine können für eigene Anwendungen verwendet werden und steigern die Effizienz bei der Programmierung. Bausteine gibt es beispielsweise für eine Sessionverfolgung ohne Cookies, Authentifizierung und Authorisierung, Caching, Darstellung und Bearbeitung von Daten aus Datenbanken und Steuerelemente für die Seitengestaltung. Diese Bausteine befinden sich in der Toolbox.

Express Edition

29

1 – Einführung

Abb. 1.6: Das ASP.NET-Websiteverwaltungs-Tool

1.3.4

Serversteuerelemente (Webcontrols)

Diese vorgefertigten Bausteine werden auch Webcontrols genannt. Doch Webcontrol ist nicht gleich Webcontrol. Es gibt zwei Kategorien: Benutzerdefinierte Websteuerelemente und Web-Benutzersteuerelemente. Benutzerdefinierte Websteuerelemente sind in einem Assembly zusammengefasst. Eine Assembly ist eine Softwarekomponente, früher auch durch so genannte DLLs (Dynamic Link Library) realisiert. Der Vorteil dieser Art von Steuerelementen liegt darin, dass mehrere Projekte das gleiche Element verwenden können und der somit ausgeführte Code in jedem Projekt gleich ist. Anders als bei den Web-Benutzersteuerelementen. Hier besteht das Element aus einem HTML-Fragment (.ascx Datei) und anderen Quellcode-Dateien. Um ein solches Steuerelement in mehrere Projekte einzubinden, benötigt jedes Projekt eine eigene Kopie. Aktualisierungen müssen für jedes Projekt durchgeführt 30

Visual Web Developer-Grundlagen

werden, da es keine zentrale Kopie gibt. Folglich ist es nicht gewährleistet, dass jedes Projekt auf dem gleichen Stand ist.

Abb. 1.7: Die Toolbox

Erfolgt die Verwendung von Serversteuerelementen allerdings nur in einem Projekt, so ist es letztendlich unbedeutend, auf welchen Typ zurückgegriffen wird. Bei der Standard-Installation des Visual Web Developers befinden sich allerdings nur benutzerdefinierte Websteuerelemente in der Toolbox. Hier kann allerdings auch zwischen HTML-Serversteuerelementen und Webserversteuerelementen unterschieden werden. Express Edition

31

1 – Einführung

HTML-Serversteuerelemente sind herkömmliche HTML-Elemente, denen lediglich der Tag runat=“server“ hinzugefügt wird, der sie zu HTML-Serversteuerelementen macht. Für die Programmierung mit dem Visual Web Developer ist dies allerdings eine eher unschöne Variante, da Webserversteuerelemente wesentlich leistungsfähiger sind. Sie weisen zwar eine andere Syntax auf, was für Web-Entwickler mit Kenntnissen in anderen Sprachen zu Beginn eine Umgewöhnung erfordert, sind aber in der Benutzung komfortabler und komplexer. Des Weiteren können Ereignisse dieser Elemente (z.B. die Selektion eines Eintrages aus einem Auswahlfeld) direkt abgegriffen und behandelt werden.

1.4 Die erste eigene Webseite Um sich mit dem Programm und der Oberfläche ein wenig zu beschäftigen und damit vertrauter zu werden, wird eine kleine, einfache und statische Webseite erstellt. Dazu wird, wie bereits beschrieben, ein neues Projekt angelegt und als Vorlage eine neue ASP.NET-Webseite ausgewählt. Anhand dieser Vorlage wird nun das Projekt erstellt. Diese Vorlage besteht standardmäßig aus dem Ordner App_Data, sowie den Dateien Default.aspx, Default.aspx.vb und web.config. Die Datei „Default.aspx“ wird außerdem direkt im Editor-Fenster des Visual Web Developers geladen. Laut der Standardeinstellung des Webservers stellt sie die Startseite der Webpräsenz dar und wird beim normalen Aufruf der Webseite (sofern keine Datei explizit angefordert wird), zuerst zum Besucher übertragen. Je nach Konfiguration des Webservers kann diese Vorgabe aber auch abgeändert werden. In der Entwurfs-Ansicht der Webseite kann auch ohne Programmierkenntnisse eine Seite grundsätzlich aufgebaut werden. Die untergeordnete Datei „Default.aspx.vb“ wird zunächst ignoriert, später werden hier spezielle Funktionen wie zum Beispiel Datenbank-Abfragen realisiert. Für das Grundlayout der Webseite werden so genannte Container verwendet. Ein Container, als Div-Element spezifiziert, dient primär der Gruppierung weiterer Elemente. Im Visual Web Developer befindet sich dieses Element unter der Gruppe HTML in der Toolbox. Es kann bequem per Drag & Drop auf die Seite gezogen werden. Die Anpassung des Div-Elementes erfolgt mit dem Stil-Generator (FORMAT | STIL). Da es das Hauptelement des Layouts werden soll wird die Breite auf 800 px (Pixeln) festgelegt. Des Weiteren soll eine Kopf-Grafik integriert werden. Dazu wird die entsprechende Grafik als Hintergrund-Bild eingebunden. Für diesen Zweck 32

Die erste eigene Webseite

kann gerne eine eigene Datei verwendet werden, oder aber die Beispiel-Grafik von der Autoren-Webseite. Bevor die Grafik als Hintergrund-Grafik definiert werden kann, muss diese dem Projekt hinzugefügt werden. Dies geschieht über das Menü WEBSEITE | VORHANDENES ELEMENT HINZUFÜGEN… .

Abb. 1.8: Der Stil-Generator

Ein weiteres Div-Element soll dafür sorgen, dass das Layout unten, links und rechts um einen Rahmen ergänzt wird. Im Stil-Generator wird dazu unter KONTUREN der Rahmen wie gewünscht mit einer Breite von 1 PX und der Farbe SCHWARZ festgelegt. Im nächsten Schritt wird ein weiteres Div-Element eingefügt. Es soll später das Menü für die Navigation beinhalten. Per Stil-Generator bekommt es eine Breite von 280 PX. Unter dem Punkt LAYOUT wird der Textfluss auf nach rechts eingestellt. Unter KONTUR wird der Rand oben auf 200 PX eingestellt. Nun kann die Navigation erstellt werden. Eine einfache Standard-Homepage (rein privat) benötigt meist die folgenden Menüpunkte: Startseite (auch Home genannt), Über mich, Gästebuch, Fotos und manchmal auch Kontakt. Natürlich Express Edition

33

1 – Einführung

gibt es für die Wahl der Menüpunkte kein allgemeingültiges Rezept; grundsätzlich müssen diese dem eigenen Bedarf angepasst werden. Für die Navigation wird das Menü-Element aus der NAVIGATION-Gruppe der Toolbox gewählt, da dieses bequem bearbeitet und nach eigenen Wünschen definiert werden kann.

Abb. 1.9: Das Menüelement aus der Toolbox einfügen

Um nun die einzelnen Einträge des Menüs anzupassen, muss nur im Eigenschaften-Fenster unter dem Eintrag ITEMS auf den rechten Button (…) geklickt werden. Es öffnet sich dann der Menüelement-Editor, in dem die Einträge bearbeitet oder hinzugefügt werden können und weitere Eigenschaften, wie zum Beispiel die Ziele der Verlinkungen, festgelegt werden können. In diesem Beispiel werden die Einträge, wie bereits oben genannt, angelegt.

Abb. 1.10: Der Menüelement-Editor

34

Die erste eigene Webseite

Über den oberen, linken Button können neue Einträge angelegt werden. Diese werden dann über das rechte Eigenschaften-Fenster näher definiert. Mit NavigateUrl wird der Link, also das Ziel, das angesurft werden soll, wenn dieser Eintrag angeklickt wird, definiert. Grundsätzlich kann hier auf alle Dateien verlinkt werden, wenn der Browser diese später erkennt und interpretieren kann, werden sie angezeigt, andernfalls zum Herunterladen angeboten. (mehr dazu im Kapitel 4.1) Allerdings können auf diese Weise nicht nur einfache Menüs erstellt werden, sondern auch komplexere Menüs mit Haupteinträgen und Untereinträgen. Ein solches Menü lohnt sich allerdings nur dann, wenn es dementsprechend viele Elemente geben soll, die auch gut gruppiert werden können. Mehr dazu wird an späterer Stelle erklärt und aufgezeigt werden. Wenn nun alle gewünschten Elemente eingetragen und definiert wurden, kann der Menüelement-Editor wieder mit einem Klick auf OK geschlossen werden. In der Navigationsspalte wird jetzt das Menü angezeigt. Allerdings sieht es bisher noch recht unspektakulär aus. Doch auch dafür hat der Visual Web Developer eine Abhilfe parat: Formatvorlagen. Wird der Fokus auf das Menü gesetzt, so erscheint in der oberen, rechten Ecke ein kleiner Pfeil. Bei einem Klick auf diesen öffnet sich ein neues Menü mit weiteren Konfigurationsmöglichkeiten.

Abb. 1.11: Menüaufgaben

Unter dem Punkt AUTOM. FORMATIERUNG… kann das Aussehen des Menüs verändert werden. Es gibt bereits einige vorgefertigte Vorlagen, die bei Bedarf aber auch manuell angepasst werden können. Nun folgt der eigentliche Inhalt der Webseite. In diesem Fall nichts Spektakuläres, lediglich ein kurzer Einführungstext bzw. eine Begrüßung. Dazu wird auch wieder ein weiteres Div-Element neben die Navigation positioniert. Express Edition

35

1 – Einführung

Es bekommt eine Breite von 490 px zugewiesen und der Textfluss wird wieder auf nach rechts eingestellt. Der Konturen-Rand nach oben wird auf 110 px und nach unten auf 30 px eingestellt. Weiterhin werden noch ein paar Schriftart-Einstellungen vorgenommen: Familie Verdana und Schriftgröße klein. Unter Text wird die Ausrichtung auf Blocksatz eingestellt. Zu guter Letzt wird noch ein letztes Div-Element hinzugefügt, was zum Abschluss der beiden vorherigen Div-Elemente dient. Dazu wird unter LAYOUT die Eigenschaft Unverankerte Objekte zulassen auf nur rechts eingestellt. Listing 1.5: Die komplette Webseite im Quelltext ... <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>

36

Die erste eigene Webseite Listing 1.5: Die komplette Webseite im Quelltext ... (Forts.) border:1px dashed #000000; text-align: left"> <StaticMenuItemStyle HorizontalPadding="5px" VerticalPadding="2px" /> <StaticHoverStyle BackColor="Gray" ForeColor="White" /> <StaticSelectedStyle BackColor="Gray"

Express Edition

37

1 – Einführung Listing 1.5: Die komplette Webseite im Quelltext ... (Forts.) ForeColor="White" />

Hallo und herzlich Willkommen auf meiner Webseite,

da private Webseiten und Homepages heutzutage ja an der Tagesordnung sind, dachte ich mir, ich muss mir auch einen Platz im Internet sichern. Aus diesem Grund habe ich nun auch meine erste, eigene Webseite.

Hier erfahrt Ihr alles Wissenswerte über mich, könnt mir einen Eintrag ins Gästebuch schreiben oder aber mir eine E-Mail zukommen lassen und natürlich auch ein paar Fotos von mir sehen, um mich ein wenig näher kennen zu lernen.

Viel Spaß wünscht Euch Mona.

Damit ist das Layout vollendet. Die erste und einfache Webseite mit dem Visual Web Developer ist fertig zum Anschauen. Was nun aber noch fehlt ist der Seitentitel der Webseite. Dieser kann direkt im Quellcode gesetzt werden oder aber über die Oberfläche im Eigenschaftsfenster des Dokuments (DOCUMENT) unter der Gruppierung Dokument mit der Eigenschaft Title.

38

Die erste eigene Webseite

Um die Seite nun im Webbrowser zu testen, muss die Tastaturkombination STRG+F5 gedrückt werden. Diese startet die Seite im Internet Explorer ohne sie zu debuggen, da diese Vorgehensweise noch nicht benötigt wird.

Abb. 1.12: Die fertige Seite interpretiert im Browser

Express Edition

39

2

Vorlagen, Master- und Inhaltsseiten

Im zweiten Kapitel werden ein paar erweiterte Techniken vorgestellt, um eine Webseite zu programmieren. Der Visual Web Developer bietet von Haus aus viele, bereits vorgefertigte, Vorlagen für die Erstellung eigener Webseiten. Ein weiterer wichtiger Punkt bei der Gestaltung von Webseiten sind Masterund Inhaltsseiten. Zur Realisierung dient die bereits erstellte Webseite aus dem ersten Kapitel als Vorbild, allerdings wird diese von Grund auf überarbeitet und angepasst gestaltet. Auf einen Blick: 쐌 Vorlagen 쐌 Masterseiten 쐌 Inhaltsseiten

2.1 Vorlagen Zur Erstellung neuer Webseiten-Elemente bietet der Visual Web Developer bereits viele vorgefertigte Vorlagen.

Abb. 2.1: Vorlagen für neue Elemente

Express Edition

41

2 – Vorlagen, Master- und Inhaltsseiten

Diese Vorlagen ersparen eine Menge Arbeit, da sie bereits vorgefertigte Informationen und Strukturen aufweisen. Neben herkömmlichen Vorlagen für Webseiten (Web Form) gibt es unter anderem auch Vorlagen für normale HTML-, Stylesheet-, XML- und Design-Dateien, SQL-Datenbanken und Webdienste. Für fast jeden Anwendungszweck ist die passende Vorlage vorhanden. Vorlage

Aufgabendefinition

Web Form

Ein Formular für normale Webanwendungen (Standard-ASP-Seite).

HTML-Seite

Eine herkömmliche HTML-Seite.

Stylesheet

Ein Cascading Stylesheet für das Festlegen von HTML-Stilen.

XML-Datei

Eine leere XML-Datei.

SQL-Datenbank

Eine leere SQL-Datenbank.

Siteübersicht

Eine Datei zum Erstellen einer Siteübersicht, auch Sitemap genannt.

JSkript-Datei

Eine Skriptdatei für JavaSkript-Code.

XSLT-Datei

Eine Datei für die Umwandlung von XMLDateien.

Masterseite

Eine Masterseite für Web-Anwendungen.

Webdienst

Eine Klasse zum Erstellen eines Webdienstes (Webservice).

Globale Anwendungsklasse

Eine Klasse zum Behandeln von Webanwendungsereignissen.

Textdatei

Eine leere Textdatei.

DataSet

Eine Datei zum Erstellen eines XML-Schemas mit DataSet-Klassen.

Mobiles Web Form

Ein Formular für mobile Webanwendungen.

Mobiles Web-Benutzersteuerelement

Ein ASP.NET-Server-Steuerelement für mobile Web Forms.

Tabelle 2.1: Verfügbare Webseitenelement-Vorlagen

42

Masterseiten Vorlage

Aufgabendefinition

Designdatei

Eine Datei zum Definieren eines ASP.NETDesigns.

Web-Benutzersteuerelement

Ein ASP.NET-Serversteuerelement.

Klasse

Eine leere Klassendeklaration.

Webkonfigurationsdatei

Eine Datei zum Konfigurieren von Webanwendungseinstellungen.

Ressourcendatei

.NET-Ressourcendatei (z.B. versch. Sprachen).

Generische Handler

Eine Seite zum Implementieren eines generischen Handlers.

VBSkript-Datei

Eine Skriptdatei, die VBSkript-Code enthält.

Konfigurationsdatei für mobile Webanwendungen

Eine Datei zum Konfigurieren von Einstellungen mobiler Webanwendungen.

Browserdatei

Eine Datei zum Definieren von Browserdefinitionen.

Tabelle 2.1: Verfügbare Webseitenelement-Vorlagen (Forts.)

In diesem Buch wird im weiteren Verlauf genauer auf die wichtigsten Vorlagen eingegangen. Alle Vorlagen zu erklären und zu behandeln würde den Umfang deutlich sprengen.

2.2 Masterseiten Bei einer Webseite mit vielen Inhalten, wie zum Beispiel Gästebuch, Newsbereich und Informationsseiten ist es sinnvoll, den Inhalt auf mehrere Seiten aufzuteilen. So ist es bisher auch gängig. Alles andere würde den Besucher erschlagen und wäre sehr unübersichtlich. Um nun aber zu vermeiden, dass in jede neue Seite noch einmal das Design hereinkopiert wird oder gar manuell angepasst wird, gibt es so genannte Masterseiten. Diese sind eigentlich normale ASP.NET-Webseiten, dienen aber späteren Seiten als Vorlage. So kann dann einfach der neue Inhalt in das Rahmendesign eingefügt werden, ohne dass große Veränderungen durchgeführt werden müssen. Alle Seiten stimmen folglich designtechnisch überein.

Express Edition

43

2 – Vorlagen, Master- und Inhaltsseiten

Ein weiterer Vorteil dieser Masterseiten liegt in der späteren Bearbeitung. Muss beispielsweise das Menü erweitert werden, so wird dies einmal auf der Masterseite durchgeführt und jede Seite ist auf dem aktuellen Stand. Somit sparen Masterseiten zusätzlich enorm viel Zeit und Aufwand. Es ist in jedem Fall ratsam, nicht nur bei größeren Projekten auf Masterseiten zurückzugreifen.

2.2.1

Eine Masterseite erstellen

Abb. 2.2: Dem Projekt ein neues Element hinzufügen

Zu Beginn wird für die neue dynamische Webseite ein eigenes Projekt erstellt und die Masterseite hinzugefügt. Dies geht per Menü WEBSEITE | ELEMENT HINZUFÜGEN. Es öffnet sich ein Fenster, in dem ein neues Element ausgewählt werden kann, in diesem Fall wird eine neue Masterseite gewählt. Der Name kann ruhig wie vorgegeben bleiben. Als Sprache wird wieder Visual Basic ausgewählt. Weiterhin soll sämtlicher Code in einer separaten Datei hinterlegt werden, um später den Programmcode separiert zu verwalten. Dann kann das Layout erstellt werden. Dafür wird das bereits bestehende aus dem Kapitel 1.4 verwendet und ein wenig abgeändert. Natürlich darf kein Inhalt hinterlegt werden, nur die Navigation bleibt auf der Masterseite, da diese ja überall angezeigt werden soll.

44

Masterseiten

Abb. 2.3: Masterseite auswählen

Dort wo später der Inhalt ersetzt wird, erscheint ein Platzhalter, ein so genanntes ContentPlaceHolder-Element. Dieser wird dort platziert, wo zuvor der Inhalt aufgeführt war, also anstelle des Begrüßungstextes. Bei der späteren Verwendung dieser Masterseite als Vorlage wird in diesem Bereich der Inhalt der aktuellen Seite angezeigt. Listing 2.1: Die fertige Masterseite <%@ Master Language="VB" CodeFile="MasterPage.master.vb" Inherits="MasterPage" %>

Express Edition

45

2 – Vorlagen, Master- und Inhaltsseiten Listing 2.1: Die fertige Masterseite (Forts.)

46

Masterseiten Listing 2.1: Die fertige Masterseite (Forts.) Value="Fotos"> <StaticMenuItemStyle HorizontalPadding="5px" VerticalPadding="2px" /> <StaticHoverStyle BackColor="Gray" ForeColor="White" /> <StaticSelectedStyle BackColor="Gray" ForeColor="White" />

Express Edition

47

2 – Vorlagen, Master- und Inhaltsseiten

Natürlich muss auch noch die Kopfgrafik in das neue Projekt kopiert und integriert werden. Ansonsten ist die Masterseite fertig und es kann mit dem eigentlichen Inhalt weitergemacht werden. Das Verschachteln von Masterseiten ist leider nicht möglich. Es gibt sicherlich einige sinnvolle Anwendungsgebiete für eine solche Vorgehensweise, die allerdings nicht mit dieser Methode realisiert werden können. Eine Masterseite kann nicht auf eine andere Masterseite referenziert werden. Allerdings können in einem Projekt mehrere, verschiedene Masterseiten verwendet werden, wenn es zum Beispiel mehrere verschiedene Gruppen von Seiten geben soll.

Abb. 2.4: Die fertige Masterseite im Editor

2.3 Inhaltsseiten Einer Inhaltsseite wird, wie es der Name allein schon ahnen lässt, lediglich der eigentliche Inhalt der Seite publiziert. Dank der Masterseite, die durch die Inhaltsseite referenziert wird, erscheint dieser schon während der Erstellung im gewünschten Layout. Bei der späteren Ausführung im Browser werden Inhalts- und Masterseite dann durch den Compiler verschmolzen. 48

Inhaltsseiten

2.3.1

Eine Inhaltsseite erstellen

Nun kann die fertige Masterseite verwendet werden und eine passende Inhaltsseite erstellt werden. Dazu wird eine neue Inhaltsseite über das Menü WEBSEITE | ELEMENT HINZUFÜGEN in Form von einer neuen Web Form integriert. Da sie die Startseite darstellen soll, wird sie Default.aspx benannt. Natürlich könnte sie auch Home.aspx oder Start.aspx betitelt werden. Wie auch immer, die Wahl liegt beim Programmierer. Auch hier wird als Sprache wieder Visual Basic ausgewählt, sowie eine eigene Datei für den Code erstellt. Um nun die Masterseite einzubinden, muss ein Häkchen bei dem Punkt Masterseite auswählen gemacht werden.

Abb. 2.5: Web Form hinzufügen

Im Anschluss daran erfolgt die Auswahl der Masterseite. Natürlich wird hier die bereits erstellte MasterPage.master ausgewählt. Nun kann im Editorfenster der für die Startseite relevante Inhalt eingegeben werden. Dafür steht ein ContentElement bereit, das das ContentPlaceHolder-Element auf der Masterseite referenziert.

Express Edition

49

2 – Vorlagen, Master- und Inhaltsseiten

Abb. 2.6: Die Inhaltsseite, basierend auf der Masterseite, im Editor

In diesem Content-Element kann nun ein Inhalt eingegeben werden. Auf der Startseite soll dies wie gehabt ein kurzer Begrüßungstext sein. Damit dieser später optisch zum Layout passt, muss noch die Schriftart verändert werden. Dies kann oben in der Schrift-Menüleiste erledigt werden.

Abb. 2.7: Schriftart und -größe anpassen

50

Inhaltsseiten

Sofern der Text bereits eingegeben wurde, muss er natürlich erst markiert werden, damit die Änderungen auch wirksam werden. Listing 2.2: Die fertige Contentseite <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" title="Mona's World - Home" %> <span style="font-size: 11pt; font-family: Verdana"> Hallo und herzlich Willkommen auf meiner Webseite,

da private Webseiten und Homepages heutzutage ja an der Tagesordnung sind, dachte ich mir, ich muss mir auch einen Platz im Internet sichern. Aus diesem Grund habe ich nun auch meine erste, eigene Webseite.

Hier erfahrt Ihr alles wissenswerte über mich, könnt mir einen Eintrag ins Gästebuch schreiben oder aber mir eine eMail zukommen lassen und natürlich auch ein paar Fotos von mir sehen, um mich ein wenig näher kennenzulernen.

Viel Spaß wünscht Euch Mona.


Abgesehen von dieser Methode, eine Masterseite dem Inhalt zuzuweisen, kann die Masterseite auch allgemein in der web.config definiert werden. Jede Inhaltsseite würde dann automatisch diese Masterseite verwenden. Allerdings ist diese Vorgehensweise nur dann ratsam, wenn wirklich jede Inhaltsseite eine und die gleiche Masterseite verwenden soll. Dazu muss lediglich der <pages>-Eintrag in der web.config wie im Listing 2.3 beschrieben modifiziert werden. Listing 2.3: Einbinden der Masterseite per web.config <pages masterPageFile="MasterPage.master " />

Express Edition

51

2 – Vorlagen, Master- und Inhaltsseiten

Abb. 2.8: Die fertige Seite im Browser

52

Dateibasierte Datenbanklösung

3

Datenquellen

Die Verwendung von verschiedenen Datenquellen ist aus vielerlei Hinsicht ein Muss für jede Webseite. Es gibt viele Aufgabenbereiche, wo statische Varianten von Webseiten an Ihre Grenzen stoßen. Seien es Gästebuch- oder Blog-Skripte auf privaten Webseiten, oder Kundenund Shopsysteme auf kommerziellen Internetpräsenzen. Die Verwendung von Datenquellen zur Verwaltung der Daten ist ein Muss. In diesem Kapitel erfahren Sie mehr über die Verwendung von Datenbanken und Datenbank-Dateien. Auf einen Blick: 쐌 Dateibasierte Datenbanklösung 쐌 Serverbasierte Datenbanklösung 쐌 Grundlagen zu Microsoft SQL Server 2005 Express 쐌 Einbinden der Datenbank in das eigene Projekt

3.1 Dateibasierte Datenbanklösung Der Visual Web Developer bietet die Möglichkeit, so genannte DatenbankDateien anzulegen. Diese Möglichkeit löst die veraltete Methode der Verwendung von Accessbasierten Datenbanken ab, da sie wesentlich komplexer sind. Per Menü WEBSEITE | NEUES ELEMENT HINZUFÜGEN … kann eine solche Datei angelegt werden. Auf die darauffolgende Frage, ob diese Datei in den Ordner App_Data gespeichert werden soll, muss zwingend zugestimmt werden, da ansonsten diese Datenquelle für jedermann uneingeschränkt von außen erreichbar ist, was tunlichst zu vermeiden ist. Der App_Data-Ordner ist nur für die Webseite zu erreichen, ein direkter Zugriff von außen auf diesen Ordner ist eingeschränkt oder nicht möglich.

Express Edition

53

3 – Datenquellen

Abb. 3.1: Datenbankdatei hinzufügen.

Abb. 3.2: Ansicht im Datenbank-Explorer

Nach dem Hinzufügen der Datenbankdatei wird diese unmittelbar direkt im Datenbank-Explorer angezeigt. Nun können unter anderem direkt Tabellen angelegt und mit Daten gefüllt werden. 54

Dateibasierte Datenbanklösung

3.1.1

Datenbank einrichten

Der Visual Web Developer stellt alle benötigten Funktionen zur Verfügung, um Tabellen, Ansichten oder Prozeduren zu erstellen. Ein zusätzliches Tool wird folglich nicht benötigt. Eine neue Tabelle wird über das Menü DATEN | NEU HINZUFÜGEN | TABELLE oder mit einem Rechtsklick auf die Gruppierung TABELLEN per NEUE TABELLE HINZUFÜGEN im Datenbank Explorer angelegt. Daraufhin öffnet sich im Editor ein neues Fenster, in dem die Tabelle genauer definiert werden kann.

Abb. 3.3: Neue Datentabelle anlegen.

Nun wird eine kleine Test-Tabelle angelegt. Sie soll lediglich eine ID für einen Eintrag speichern, so wie einen kurzen Text. Sie enthält folglich nur zwei Spalten. TestTabelle Name

Datentyp

NULL zulassen

ID

tinyint

Nein

text

text

Nein

Tabelle 3.1: Das Schema für die Test-Tabelle

Jeder Spalte muss neben einem Namen ein Datentyp zugewiesen werden und festgelegt werden, ob der Eintrag leer sein darf (NULL) oder nicht. Express Edition

55

3 – Datenquellen

Abb. 3.4: Datentabelle definieren.

Nun müssen allerdings noch ein paar weitere Definitionen für das ID-Feld vorgenommen werden. Dies geschieht unter Spalteneigenschaften im unteren Bereich des Editors unter der Gruppierung IDENTITÄTSSPEZIFIKATION. Dort werden die Ist-Identity auf „Ja“, die ID-Schrittweite, sowie der ID-Start auf „1“ gesetzt. Das bedeutet, dass die ID später ab 1 startet und für jeden weiteren Eintrag um 1 hoch gesetzt wird. So wird jeder Eintrag korrekt und eindeutig ansprechbar sein – voll automatisch. Beim späteren Befüllen der Tabelle muss nur noch ein Text eingegeben werden. Die ID wird automatisch generiert und eingetragen. Des Weiteren wird das IDFeld mit einem Rechtsklick auf PRIMÄRSCHLÜSSEL FESTLEGEN zum Primärschlüssel gemacht.

Abb. 3.5: Identitätsspezifikation definieren

56

Dateibasierte Datenbanklösung

Nachdem nun alle Felder festgelegt wurden, kann das Definitionsfenster der neuen Tabelle wieder geschlossen werden. Im Anschluss daran fordert der Visual Web Developer zum Speichern auf und erwartet einen Namen für die Tabelle: Sinngemäß wird sie TestTabelle genannt. Soll die Tabelle später noch einmal verändert werden, so reicht ein Doppelklick auf den Tabellennamen und schon öffnet sich das bekannte Fenster zum Bearbeiten einer Tabelle. Die Tabelle ist nun fertig zum Einpflegen der Daten. Dazu wird ein Rechtsklick auf die Inhalts-Tabelle gemacht und der Menüpunkt TABELLENDATEN ANZEIGEN ausgewählt. Es öffnet sich der Tabellen-Editor, in welchem sämtliche Daten verwaltet und eingepflegt werden können.

Abb. 3.6: Daten einpflegen

Dank der gut konfigurierten Tabelle muss nur das Feld text ausgefüllt werden. Die ID wird vollautomatisch generiert und eingefügt. Diese Vorgehensweise verhindert später auch doppelte Einträge. Die Daten werden sofort nach dem Eintragen in die Datenbank übernommen. Ein Speichern vor dem Schließen des Tabellen-Editors ist also nicht nötig.

3.1.2

Ansicht erstellen

Wenn es darum geht, Daten aus einer Datenbank auszulesen, so ist es sinnvoll, Ansichten zu erstellen, da diese einen enormen Vorteil bieten. Zum einen können mehrere Tabellen in einer Ansicht zusammengefasst werden und von der Webseite als eine einzige Tabelle angefragt werden und zum anderen können Daten verlinkt werden. Dies hat in jedem Fall den deutlichen Vorteil der Reduzierung von Datenbankabfragen, was zu einer schnelleren Verarbeitungszeit der Daten führt. Zur Demonstration der Arbeitsweise von Ansichten wird zuerst eine weitere Test –Tabelle erstellt. Express Edition

57

3 – Datenquellen TestTabelle2 Name

Datentyp

NULL zulassen

ID

tinyint

Nein

test_id

tinyint

Nein

titel

text

Nein

Tabelle 3.2: Das Schema für die zweite Test-Tabelle

Die zweite Test-Tabelle ist in dem Sinne der ersten Test-Tabelle untergeordnet und soll für jeden Eintrag in dieser einen Titel definieren. Die Identifikation erfolgt über die ID und wird über die Spalte test_id der zweiten Tabelle zugeordnet. Dazu wird die zweite Tabelle nun wieder mit Testdaten gefüllt.

Abb. 3.7: Daten einpflegen

Nun kann die Ansicht erstellt werden. Eine neue Ansicht wird über das Menü DATEN | NEU HINZUFÜGEN | ANSICHT oder mit einem Rechtsklick auf die Gruppierung ANSICHTEN per NEUE ANSICHT HINZUFÜGEN im Datenbank Explorer angelegt. Daraufhin öffnet sich im Editor ein neues Fenster, in dem die Ansicht genauer definiert werden kann. Zu Beginn wird festgelegt, dass Daten aus TestTabelle und TestTabelle2 verwendet werden sollen. Im Anschluss daran wird definiert, dass die Felder ID und text der TestTabelle und das Feld titel der TestTabelle2 verwendet werden sollen. Damit nun die Einträge korrekt zugeordnet werden, muss eine Bedingung erstellt werden. Dies geschieht, indem das Feld test_id der TestTabelle2 auf das Feld ID der TestTabelle gezogen wird. Fertig ist die Ansicht. Zu jedem Eintrag der TestTabelle wird nun der passende Titel aus der TestTabelle2 angezeigt.

58

Dateibasierte Datenbanklösung

Abb. 3.8: Neue Ansicht anlegen

Abb. 3.9: Die Ansicht definieren

Fertig ist die Ansicht. Der Definitions-Modus kann nun geschlossen und die Ansicht gespeichert werden. Um sich von dem Ergebnis der Ansicht zu vergewissern, kann über den Datenbank-Explorer mit einem Rechtsklick auf die Ansicht auf ERGEBNISSE ANZEIGEN die Ansicht überprüft werden.

Express Edition

59

3 – Datenquellen

Abb. 3.10: Das Ergebnis der Ansicht

3.1.3

Gespeicherte Prozedur erstellen

Gespeicherte Prozeduren sind kleine Skripte bzw. Programme, die unmittelbar auf dem Datenbanksystem ausgeführt werden. Sie dienen zum Beispiel dazu, mehrere Aktionen zu einer einzigen Aktion zusammenzufassen. Allerdings erfordern sie erweiterte SQL-Kenntnisse. Somit kann zum Beispiel mit nur einer einzigen Datenbank-Abfrage ein Eintrag in die TestTabelle und TestTabelle2 gesetzt werden. Automatisch wird so auch die Verknüpfung beider Tabellen erledigt. Eine neue Prozedur wird über das Menü DATEN | NEU HINZUFÜGEN | GESPEICHERTE PROZEDUR oder mit einem Rechtsklick auf die Gruppierung gespeicherte Prozeduren per NEUE GESPEICHERTE PROZEDUR HINZUFÜGEN im Datenbank Explorer angelegt. Daraufhin öffnet sich im Editor ein neues Fenster, in dem die Prozedur eingegeben werden kann. Das erfordert ein wenig Programmieraufwand. Zu Beginn wird per ALTER PROCEDURE die Prozedur definiert und betitelt. Ihr angehangen werden die Variablen, die übergeben werden sollen. Mit dem Zusatz OUT wird eine Variable zurückgeliefert. Mit AS wird die eigentliche Aktion der Prozedur festgelegt. Dies kann zum Beispiel ein INSERT INTO- oder DROP-Statement sein. Mit BEGIN TRANS wird der Anfang der Transaktion festgelegt. Dies ist wichtig, wenn mehrere Aktionen durchgeführt werden sollen, da sofern eine einzige Aktion fehlschlägt, insgesamt keine Daten verändert werden. Mit COMMIT wird die Transaktion durchgeführt. SET weist einer Variablen einen Wert zu und RETURN gibt eine Variable zurück. SCOPE_IDENTITY() liefert die aktuelle ID einer Tabelle zurück.

60

Microsoft SQL Server 2005 Express Listing 3.1: Die gespeicherte Prozedur ALTER PROCEDURE dbo.TestProzedur (@titel text, @text text, @id tinyint OUT) AS BEGIN TRAN INSERT INTO TestTabelle([text]) VALUES (@text) SET @id = SCOPE_IDENTITY() INSERT INTO TestTabelle2([test_id], [titel]) VALUES (@id, @titel) COMMIT RETURN @id

Im Falle dieser Prozedur wird ein Titel und Text übergeben. Der Text wird in die TestTabelle eingefügt und die aktuelle ID des eingefügten Datensatzes in die Variable @id gespeichert. Im Anschluss daran wird diese ID samt dem Titel in TestTabelle2 eingefügt. Des Weiteren wird die ID auch von der Prozedur zurückgegeben. Dies ist sinnvoll, wenn man diese zum Weiterverarbeiten benötigt. Natürlich kann auch der Name, Titel oder gar nichts zurückgeliefert werden. Das hängt voll und ganz vom Anwendungszweck ab. Vorteilhaft ist es in jedem Fall, damit so auf Anhieb überprüft werden kann, ob die Prozedur erfolgreich ausgeführt worden ist. Natürlich könnte auch ein Fehlercode zurückgeliefert werden, anhand dessen der Fehler direkt bestimmt werden könnte.

3.2 Microsoft SQL Server 2005 Express Der SQL Server 2005 Express ist der Nachfolger der MSDE-Datenbank (Microsoft SQL Server Desktop Engine) und wie sein Vorgänger kostenlos erhältlich. Im Gegensatz zu seinem großen Bruder, dem SQL Server 2005, ist sein Funktionsumfang ein wenig abgespeckt. Zum Beispiel dürfen Datenbanken maximal vier Gigabyte groß sein. Die Express Edition unterstützt maximal einen Prozessor und kann auch nur maximal einen Gigabyte Arbeitsspeicher nutzen.

Express Edition

61

3 – Datenquellen

Wie für den großen Bruder gibt es auch für die kleine Express Version ein Administrationswerkzeug (SQL Server Express Manager als kostenloses Management Tool). Allerdings ist dieses auch wieder eingeschränkt und kann lediglich eine Instanz managen, Datenbanken einrichten und verwalten. Doch neben all den wenigen Einschränkungen, die vor allem für Entwicklungszwecke und private Projekte keine Rolle spielen, unterstützt die Express Edition neben gespeicherten Prozeduren, Ansichten, Trigger und Cursor auch CLR und XML Unterstützung. Es können also recht schnell umfangreiche und höchstperformante Datenbankanwendungen realisiert werden.

3.2.1

Verbindung aufbauen

Um die Verbindung zum SQL Server aufzubauen, muss dieser erst einmal in das Projekt integriert werden. Hierfür kann ein bereits vorhandenes Projekt verwendet werden, oder aber auch ein neues erstellt werden. Zuerst muss in den Datenbank-Explorer umgeschaltet werden. Dies kann auf der linken Seite unter dem Explorer-Fenster erledigt werden oder aber über das Menü (ANSICHT | DATENBANK-EXPLORER).

Abb. 3.11: Der Datenbank-Explorer

In diesem kann eine Verbindung zum SQL Server aufgebaut werden. Das geht über den Button MIT DATENBANK VERBINDEN oder über das entsprechende Rechtsklick-Menü im Datenbank-Explorer.

62

Microsoft SQL Server 2005 Express

Im ersten Schritt muss die Datenquelle bestimmt werden. In diesem Fall wird der Provider für Microsoft-SQL-Datenbanken ausgewählt. Unter einem Provider versteht man in diesem Zusammenhang einen Treiber für eine Datenquelle. Als Datenanbieter fungiert dann der .NET-Framework-Datenanbieter für SQLServer. Im nächsten Fenster wird dann die eigentliche Verbindung definiert. Allerdings muss dort nun noch der Servername eingetragen werden, der meist identisch mit dem eigenen Rechnernamen ist, da der Server ja auf dem lokalen Rechner läuft. Sollte ein anderer SQL Server auf einem entfernten Rechner benutzt werden, so muss dort nur die eigene IP oder Host eingetragen werden. Unter der Gruppierung BEIM SERVER ANMELDEN müssen die bei der Installation festgelegten Daten eingetragen werden; wurde dort die Windows-Authentifizierung gewählt, sind keine weiteren Daten erforderlich, ansonsten müssen die festgelegten Zugangsdaten eingetragen werden.

Abb. 3.12: Datenverbindung hinzufügen

Express Edition

63

3 – Datenquellen

Als Datenbankname wird einfach „Webseite“ eingetragen. Sofern die eingegebene Datenbank nicht existent ist, kann diese direkt angelegt werden. Wird diese Option leer gelassen, so wird automatisch die Master-Datenbank verwendet. Der Server ist nun funktionsfähig in das Projekt integriert und kann weiter eingerichtet werden.

3.2.2

Tabellen, Ansichten und gespeicherte Prozeduren

Das Anlegen, Bearbeiten und Testen von Tabellen, Ansichten und Prozeduren wird beim SQL-Server genau so behandelt wie bei SQL-Datenbankdateien. Die genaue Vorgehensweise ist in Kapitel 3.1.1 (Datenbank einrichten), 3.1.2 (Ansicht erstellen) und 3.1.3 (gespeicherte Prozedur erstellen) beschrieben. Bei der Verwendung von Daten aus SQL-Datenbankdateien und von SQLDatenbankservern gibt es dank dem Visual Web Developer keinen Unterschied. Die Verwaltung und Pflege ist exakt gleich.

3.3 Einbinden der Datenbank Für das Einbinden der Datenbank gibt es zwei Varianten. Zumal bietet der Visual Web Developer die Möglichkeit dies per Serversteuerelementen zu erledigen, oder für codefeste Programmierer diese Aufgabe per Sourcecode zu erledigen. Die zweitere Variante ist zum einen von Vorteil, wenn es darum geht, eigene Serversteuerelemente zu erstellen oder aber um Datenbankinformationen individuell nach eigenen Vorgaben darzustellen. Welche Variante bei der Programmierung gewählt wird, hängt stehts vom Verwendungszweck ab. Wenn es lediglich darum geht, den Inhalt einer Tabelle übersichtlich darzustellen, dann reichen vorgefertigte Serversteuerelemente voll und ganz aus. Geht es aber darum, den Inhalt einer Tabelle nach eigenen Vorlagen auszugeben, so ist die zweite Variante sicherlich sinnvoller. Je nachdem lohnt es sich sogar, ein eigenes Steuerelement speziell für diesen Zweck zu erstellen.

3.3.1

Variante 1: Per Webcontrol

Die einfachste Methode, Daten aus einer Datenquelle auf einer Webseite darzustellen, kann bequem per Drag & Drop realisiert werden.

64

Einbinden der Datenbank

Die Tabelle, die auf der Webseite dargestellt werden soll, muss lediglich vom Datenbank Explorer auf die Webseite im Entwurfsmodus gezogen werden. Der Visual Web Developer erstellt automatisch zwei Steuerelemente: Ein SqlDataSource- und ein GridView-Steuerelement. Das SqlDataSource-Steuerelement dient als Daten-Provider und Schnittstelle zwischen der Datenquelle und der Webseite. Das GridView-Steuerelement bereitet die Tabelle grafisch auf und erzeugt ein Tabellenraster gefüllt mit den Daten aus der Datentabelle. Dies ist die einfachste Methode, Daten aus Datenquellen auf einer Webseite anzuzeigen.

Abb. 3.13: Ausgabe der Datentabelle in einem GridView

Doch das Leistungsspektrum ist noch lange nicht ausgeschöpft. Das GridView kann nicht nur Daten übersichtlich darstellen, sondern auch Daten bearbeiten und löschen. Diese Optionen können über das Aufgaben- bzw. SmartTag-Menü (Klick auf den oberen, kleinen Pfeil oder per Rechtsklick-Menü SMARTTAG ANZEIGEN) aktiviert werden. Schon können die vorhandenen Daten bequem im Browser verwaltet werden. Natürlich kann das GridView-Element auch personalisiert werden. Auch hier stehen einige Formatvorlagen (AUTOM. FORMATIERUNG) zur Auswahl.

Express Edition

65

3 – Datenquellen

Abb. 3.14: Bearbeiten und Löschen aktivieren

Außerdem können die Spalten näher definiert werden, so zum Beispiel auch welche Spalten überhaupt dargestellt werden oder der Text der Kopfzeile einer Spalte.

Abb. 3.15: Die Anpassung der Spalten

66

Einbinden der Datenbank

Des Weiteren können weitere Zusatzoptionen wie PAGING AKTIVIEREN (übersichtliche Darstellung sortiert auf mehrere Seiten), SORTIEREN AKTIVIEREN (ermöglicht das Sortieren nach verschiedenen Spalteneinträgen) und AUSWAHL AKTIVIEREN (ermöglicht das Auswählen von einzelnen Zeilen) eingestellt werden. Selbstverständlich gibt es zur Anpassung des Rahmens und der Schrift auch noch den bereits bekannten Stil-Generator.

Abb. 3.16: Das fertige GridView im Browser

Alles in allem ist diese Variante auch schon recht umfangreich und mit Sicherheit für einige Aufgaben hervorragend geeignet. Das Beste an dieser Vorgehensweise ist der niedrige Programmier-Aufwand.

3.3.1.1 Konfiguration der Datenquelle Die Datenquelle kann natürlich auch noch genauer definiert werden. Dies ist vor allem auch dann sehr wichtig, wenn zum Beispiel ein Umstieg von einer Datenbankdatei auf einen Datenbankserver erfolgen soll. Aber natürlich kann ein solcher Umstieg auch einfach nur im Allgemeinen ein Wechsel der gleichen Art von Datenquelle auf eine andere Datei bzw. Server sein. Express Edition

67

3 – Datenquellen

Die Konfiguration der Datenquelle erfolgt auch wieder über das AufgabenMenü des Steuerelementes per Konfigurations-Assistenten.

Abb. 3.17: Der erste Schritt des Konfigurations-Assistenten

Im ersten Schritt wird die Datenverbindung konfiguriert. Es kann entweder eine vorhandene aus der DropDown-Box ausgewählt werden oder aber per NEUE VERBINDUNG … eine neue erstellt werden. In jedem Fall wird automatisch eine so genannte Verbindungszeichenfolge (auch Connectionstring genannt) generiert. Diese enthält Angaben zur Datenquelle, zur Verbindung und gegebenenfalls auch Anmeldungsdaten des Benutzers, die im Normalfall zum Beispiel für die Anmeldung an einem SQL-Server benötigt werden. Mit einem Klick auf WEITER wird der zweite Schritt geladen. In diesem wird die Select-Anweisung explizit eingestellt. Darunter wird lediglich die Auswahl der Spalten verstanden, die in dem Element angezeigt werden sollen.

68

Einbinden der Datenbank

Abb. 3.18: Der zweite Schritt des Konfigurations-Assistenten

Wenn die Datenquelle auch noch die Möglichkeit des Bearbeitens, Einfügens und Löschens bieten soll, müssen die entsprechenden Anweisungen mit erstellt werden. Mit dem Button ERWEITERT … kann festgelegt werden, dass diese mit generiert werden. Achtung: Sollten die Möglichkeiten nicht aktiviert sein, sodass keine Auswahl getroffen werden kann, dann ist in der entsprechenden Tabelle kein Primärschlüssel definiert. Diese Anweisungen können bei guten SQL-Programmierkenntnissen (siehe auch Anhang A – Crashkurs SQL) manuell eingegeben werden oder aber bequem und komfortabel über den Assistenten eingestellt werden. Die Daten können entweder aus einer Tabelle, Ansicht oder gespeicherten Prozedur bezogen werden. Auch kann bereits in diesem Schritt bestimmt werden, welche Spalten überhaupt angezeigt werden sollen.

Express Edition

69

3 – Datenquellen

Abb. 3.19: Erweiterte SQL-Generierungseinstellungen

Sofern die Select-Anweisung manuell eingegeben werden soll, gibt es noch einen Zwischenschritt beim Assistenten.

Abb. 3.20: Zwischenschritt: Manuelle Eingabe der Anweisung

70

Einbinden der Datenbank

Dort kann dann die Art der Anweisung (Select [Auswahl], Update [Aktualisierung], Insert [Einfügen] oder Delete [Löschen]) bestimmt werden. Allerdings ist dies nicht so einfach wie es dort dargelegt wird, da nicht jedes Steuerelement alle Anweisungen unterstützt. So unterstützt das GridView-Element nur Selectund Update-Anweisungen.

Abb. 3.21: Fast fertig: Der letzte Schritt

Im letzten Schritt erfolgt dann die Validierung der Abfrage. Sie kann sofort getestet werden und auf ihre korrekte Arbeitsweise hin überprüft werden. Ist dies der Fall, so wird direkt das Ergebnis angezeigt und der Assistent kann beendet werden. Das SqlDataSource-Element wird automatisch aktualisiert.

Weitere Steuerelemente Allerdings gibt es für Datenbankabfragen nicht nur das GridView-Element. In der Gruppe DATEN in der Toolbox befinden sich zu diesem Zweck noch die Elemente DetailsView, FormView, DataList und Repeater.

Express Edition

71

3 – Datenquellen

Aber nicht nur diese Elemente unterstützen die Verwendung von Datenquellen. Das DropDown-Steuerelement zum Beispiel kann auch fest an eine Datenquelle gebunden werden. Dies ist sehr sinnvoll, wenn es beispielsweise darum geht, bei einem Formular vorgefertigte, in der Datenbank hinterlegte, Optionen auszuwählen. So weit, so gut. Die bisher beschriebenen Elemente dienen allerdings nicht nur der Ausgabe. Jedes Element unterstützt verschiedene Datenbank-Aktionen (siehe Tabelle 3.3). Steuerelement Beschreibung

Datenbank-Aktionen

GridView

Anzeige einer Datentablle in einem Tabellenformat.

Aktualisieren, Löschen

DetailsView

Anzeige einer einzelnen Tabellenzeile (Datensatz).

Aktualisieren, Löschen, Einfügen

FormView

Anzeige einer einzelnen Tabellenzeile (Datensatz).

Aktualisieren, Löschen, Einfügen

DataList

Anzeige einer Datentabelle in einem selbst-definierbaren HTML-Format.

Aktualisieren, Löschen, Einfügen

Repeater

Anzeige einer Datentabelle in Aktualisieren, Löschen, einem selbst-definierbaren For- Einfügen mat (nicht HTML).

Tabelle 3.3: Unterstützte Datenbankaktionen der einzelnen Daten-Steuerelemente

Die komplette Pflege einer Datenbank kann dank dem Visual Web Developer folglich bequem und ohne großen Programmieraufwand erledigt werden.

3.3.2

Variante 2: Per Quellcode

Um nun eine Datenbank aus dem Quellcode der Seite anzusprechen, wird der System.Data.SqlClient-Namespace verwendet. Dieser Namespace ist der .NET Framework Daten Provider für Microsoft SQL Server. Er enthält alle benötigten Klassen, um eine SQL Server Datenbank anzusprechen und zu modifizieren. Für die Webseite werden allerdings nur die Klassen SqlConnection, SqlCommand und SqlDataReader benötigt. Mit SqlConnection wird eine Verbindung zu einem SQL Server aufgebaut. Per SqlCommand wird eine SQL-Abfrage 72

Einbinden der Datenbank

(Query) an den Server übermittelt und per SqlDataReader wird die AbfrageAntwort (Query Response) eingelesen. Funktion

Beschreibung

SqlConnection Open

Öffnet eine Verbindung zum SQL Server.

Close

Beendet die Verbindung zum SQL Server.

SqlCommand ExecuteReader

Führt eine Abfrage aus, die ein Ergebnis zurückliefert, das mit dem SqlDataReader ausgewertet werden kann.

ExecuteNonQuery

Führt eine Abfrage lediglich aus, ohne ein Ergebnis zurückzuliefern. Diese Funktion lohnt sich nur bei Aktionsabfragen (INSERT, DELETE, UPDATE, SET), bei denen keine Daten zurückgeliefert werden müssen.

ExecuteScalar

ExecuteScalar wird nur bei Abfragen benötigt, bei denen lediglich ein einziger numerische Wert (wie z.B. eine ID) zurückgeliefert werden soll.

ExecuteXmlReader

Soll die Abfragen-Antwort als XmlReader-Object zurückgeliefert werden, so muss die ExecuteXmlReader Funktion verwendet werden.

SqlDataReader HasRows

Ermittelt, ob Daten in der Abfrage enthalten sind.

Tabelle 3.4: Benötigte Funktionen für Sql-Interaktionen

Um also vernünftig mit der Datenbank zu arbeiten, werden auch Grundkenntnisse im Bereich SQL-Abfragen benötigt. Sofern noch keine vorhanden sind, empfiehlt es sich an dieser Stelle kurz auszusetzen und sich den Sql-Crashkurs im Anhang A zu verinnerlichen. Um nun im Quellcode mit diesen Klassen und Funktionen arbeiten zu können, muss zunächst an erster Stelle der Namespace System.Data.SqlClient importiert werden. Als Datenbank wird die oben erstellte Webseiten-Datenbank verwendet und Inhalte aus der Inhalts-Tabelle ausgelesen.

Express Edition

73

3 – Datenquellen

Dazu wird im nächsten Schritt per SqlConnection die Verbindung zum SQL Server initiiert. Dazu muss eine so genannte Verbindungszeichenfolge (Connectionstring) übergeben werden, die Angaben zum Server, zur Authentifizierung und zur verwendeten Datenbank beinhaltet. Listing 3.2: Beispiel für einen Connectionstring "SERVER=Servername;" + _ "PWD=Passwort;" + _

"UID=Benutzername;" + _ "DATABASE=Webseite"

Natürlich kann der Connectionstring auch durchgehend in einer Zeile geschrieben werden. Allerdings ist die Variante mit den Zeilenumbrüchen ein wenig übersichtlicher. Im Anschluss daran müssen dann die SqlCommand- und SqlDataReader-Klassen eingebunden werden. Die Verbindung zum Server kann nun per OpenFunktion der SqlConnection-Klasse hergestellt und die Abfrage der Datenbank durchgeführt werden. In diesem Fall wird der Eintrag aus der Tabelle TestTabelle herausgesucht, dessen Feld text den Wert „Der erste Eintrag“ aufweist. Das Ergebnis wird dann per ExecuteReader-Funktion der SqlDataReaderKlasse ausgewertet. Dabei wird ein Array zurückgeliefert, dessen Felder mit denen der Tabelle übereinstimmen. Wenn die Tabelle der Datenbank nun zwei Spalten aufweist, so sind diese auch durchnummeriert im Array zu finden. Zum Beispiel:

Tabelle TestTabelle Spalte 0: id Spalte 1: text Array TestTabelle Array-Feld[0]: id Array-Feld[1]: text Zuletzt müssen nur noch Verbindung und DataReader geschlossen und eventuell auftretende Fehler abgefangen werden. Dies ist sehr wichtig, damit bei dem Besucher keine unverständlichen Fehlerinformationen des Servers angezeigt werden. Weiterhin hat dies den Vorteil, dass man direkt auf Fehler reagieren kann, indem man Skriptseitig darauf eingeht und bei einem Datenbankfehler

74

Einbinden der Datenbank

zum Beispiel direkt eine E-Mail an den Webmaster samt Fehlerbeschreibung gesendet wird, damit dieser so schnell wie möglich reagieren kann. Listing 3.3: Die Datenbank über die Webseite auslesen 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient Partial Class _Default Inherits System.Web.UI.Page 'Strings für Abfragen Antworten Dim strReturnTitel, strReturnInhalt As String Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'SqlConnection-Klasse einbinden und definieren Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden Dim dbCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader Try 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Select * from TestTabelle Where id='1';", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Zurückgelieferte Daten aus dem SqlDataReader einlesen...

Express Edition

75

3 – Datenquellen Listing 3.3: Die Datenbank über die Webseite auslesen (Forts.) While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strReturnTitel = "Inhalt" strReturnInhalt = dbDataReader(1).ToString End While 'DataReader und Verbindung schliessen dbDataReader.Close() dbConnection.Close() Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. strReturnTitel = "FEHLER" strReturnInhalt = ex.Message.ToString End Try 'Ausgelesene Daten per MsgBox ausgeben. MsgBox(strReturnInhalt, _ MsgBoxStyle.OkOnly, _ strReturnTitel) End Sub End Class

In diesem Beispiel wird allerdings nur eine MsgBox mit dem zurückgelieferten Ergebnis angezeigt. Allerdings erfolgt hier auch schon eine Fehlerbehandlung: Tritt ein Fehler auf, so erscheint dieser in der MsgBox.

Tipp Der SQL Server bietet allerdings wesentlich mehr als nur Datenbanken zu verwalten und auszuwerten. In der gleichen Reihe wie dieses Buch gibt es ein hervorragendes Werk. Es ist auf jeden Fall ein Muss für all diejenigen, die mehr mit dem SQL Server arbeiten wollen und den kompletten Funktionsumfang ausnutzen möchten. SQL Server 2005 Express Edition (von Andreas Kosch) ISBN: 3-935042-85-x

76

Einbinden der Datenbank

Abb. 3.22: Das Endergebnis im Browser

Express Edition

77

4

Navigation und Siteübersicht

Für die Navigation einer Webseite gibt es verschiedene Möglichkeiten. Doch das Wichtigste ist, dass es für diesen Zweck bereits vorgefertigte Elemente gibt. Zur Realisierung der Navigation wird das Menü-Element aus der Gruppe NAVIGATION der Toolbox verwendet. Es bietet mehrere Möglichkeiten, um seine Daten, also die eigentlichen Navigations-Links, zu beziehen. In diesem Kapitel erfahren Sie mehr über die Verwendung dieses Elementes und wie Siteübersicht-Dateien sinnvoll eingesetzt werden können. Auf einen Blick: 쐌 Ein Menü mit dem Menü-Element erstellen 쐌 Eine Siteübersicht-Datei anlegen 쐌 Menü und Siteübersicht verbinden 쐌 Siteübersicht generieren

4.1 Das Menü-Steuerelement Das Menü-Steuerelement sieht auf den ersten Blick recht simpel und unspektakulär aus. Allerdings steckt dahinter wesentlich mehr, als es der erste Blick preisgibt. Das Element befindet sich in der Toolbox unter der Gruppierung NAVIGATION.

Abb. 4.1: Das Menüelement aus der Toolbox einfügen

Um nun die einzelnen Einträge des Menüs anzupassen, muss nur der AufgabenDialog über den rechten, oberen kleinen Pfeil geöffnet werden und auf den EinExpress Edition

79

4 – Navigation und Siteübersicht

trag MENÜELEMENTE BEARBEITEN… geklickt werden. Es öffnet sich dann der Menüelement-Editor, in dem die Einträge bearbeitet oder hinzugefügt werden können und weitere Eigenschaften, wie zum Beispiel die Ziele der Links festgelegt werden können.

Abb. 4.2: Der Menüelement-Editor

Über den oberen linken Button können neue Einträge angelegt werden. Diese werden dann über das rechte Eigenschaften-Fenster näher definiert, hierfür sind die wichtigsten Eigenschaften NavigateUrl, Enabled, Selected, Text und ToolTip. Mit NavigateUrl wird der Link, also das Ziel, das angesurft werden soll, wenn dieser angeklickt wird, definiert. Dies kann eine neue ASP-Seite (.aspx), eine HTML-Seite (.htm/.html) oder aber auch ein Bild (.jpg/.gif/.png/…) oder Download (.exe/.zip/…) sein. Wenn mit einem Klick eine Datei heruntergeladen werden soll, so muss diese Datei als Ziel eingetragen werden. Grundsätzlich kann hier auf alle Dateien verlinkt werden; wenn der Browser diese später erkennt und interpretieren kann, werden sie angezeigt, andernfalls zum Herunterladen angeboten. Wenn später ein Eintrag deaktiviert werden soll, so muss er nicht gleich entfernt werden. Dank der Enabled-Eigenschaft kann er auch hierüber deaktiviert werden (Enabled = false). Umgekehrt muss jedem Eintrag, der aktiv sein soll, der Enabled-Wert true zugewiesen werden. 80

Erstellung einer Siteübersicht-Datei

Die Selected-Eigenschaft legt den Auswahlzustand des Elementes fest. Ist es aktiviert (= true), so wird das Element später zur Laufzeit der Seite als ausgewählt angezeigt. Dies ist zum Beispiel sehr sinnvoll, wenn dem Besucher einer Seite direkt angezeigt werden soll, auf welcher Unterseite er sich befindet. Standardmäßig sind alle Elemente nicht ausgewählt (= false). Mit der Eigenschaft Text wird festgelegt, wie der Link später angezeigt werden soll, prinzipiell also der Name des Links. Ergänzend hierzu ist die ToolTipEigenschaft eine weitere Erklärung des Links. Diese Erklärung wird dann angezeigt, wenn die Maus später über dem Link bzw. dem Element pausiert. Allerdings ist dies wirklich nur die einfachste Variante, ein Menü zu erzeugen. Aber das Menü-Steuerelement kann noch mehr: Verschachtelte Menüs und Untermenüs. Dies steigert die Übersichtlichkeit und Ordentlichkeit bei komplexen Webseiten. Das Menü-Steuerelement ist folglich ein wirklich leistungsstarkes Werkzeug, wenn es darum geht, übersichtliche und ordentliche Navigationen zu erzeugen. Was allerdings noch ein wenig eleganter ist: Eine Siteübersicht-Datei. Diese ermöglicht eine komfortablere und vor allem dynamischere Verwaltung der Menüeinträge. Doch das ist noch lange nicht alles.

Abb. 4.3: Das fertige, statische Menü im Browser

4.2 Erstellung einer Siteübersicht-Datei Zuvor wurden alle Menüpunkte manuell definiert und per Menüelement-Editor eingetragen. Doch es geht auch anders: Mit einer Siteübersicht-Datei (auch Sitemap-Datei genannt). Eine Sitemap-Datei ist auf den ersten Blick nicht mehr als eine einfache XML-Datei, welche die Definition der Seitenstruktur enthält. Sämtliche Dateien der Webpräsenz werden in dieser Datei verzeichnet. Express Edition

81

4 – Navigation und Siteübersicht

Leider gibt es keine Möglichkeit, diese automatisiert zu erstellen. Aber diese Tatsache ist auch halb so wild, da der Überblick somit größer ist und die Kontrolle komplett selbst übernommen werden kann. Es mag ja durchaus Dateien geben, die nicht zwingend für alle verfügbar sein dürfen und nicht im Menü auftauchen sollen. Um eine Siteübersicht zu erstellen, wird diese als neues Element dem Projekt hinzugefügt.

Abb. 4.4: Eine Siteübersicht erstellen

Sie wird nun umgehend im Editor-Fenster des Visual Web Developers geöffnet und kann bearbeitet werden. Nun muss zu Beginn die Menüstruktur eingetragen werden. Listing 4.1: Die Struktur einer Siteübersicht-Datei <siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" > <siteMapNode url="" title="" description=""> ...

82

Erstellung einer Siteübersicht-Datei

Wie der Struktur der Siteübersicht zu entnehmen ist, wird sie zu Beginn als XML-Datei definiert. Im nächsten Schritt erfolgt die Definition eines Schemas, in diesem Fall wird das Schema direkt von http://schemas.microsoft.com/AspNet/SiteMap-File-1.0 geladen. Ein neues Element wird der Datei mit dem siteMapNode-Tag definiert. Diese können selbstverständlich auch verschachtelt und kombiniert werden, so das genau festgelegt ist, welchem Eintrag ein weiterer Eintrag untergeordnet ist, und eine ordentliche Struktur entsteht. Des Weiteren wird jedem Eintrag die genaue Url der Datei zugewiesen, ein Titel, sowie eine Beschreibung festgelegt. Wichtig ist auf jeden Fall, das alle Seiten der Startseite untergeordnet sind. Listing 4.2: Die fertige Siteübersicht <siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" > <siteMapNode url="Default.aspx" title="Home" description="Die Startseite"> <siteMapNode url="News.aspx" title="News" description="Neuigkeiten rund um Mona"> <siteMapNode url="News2006.aspx" title="2006" description="Alle News aus 2006" /> <siteMapNode url="News2005.aspx" title="2005" description="Alle News aus 2005" /> <siteMapNode url="News2004.aspx" title="2004" description="Alle News aus 2004" /> <siteMapNode url="Blog.aspx" title="Blog" description="Mein Blog"> <siteMapNode url="BlogHeute.aspx" title="Heute" description="Alle Blogeinträge von Heute" /> <siteMapNode url="BlogGestern.aspx" title="Gestern" description="Alle Blogeinträge von Gestern" /> <siteMapNode url="BlogLetzteWoche.aspx" title="Letzte Woche" description="Alle Blogeinträge der letzten Woche" /> <siteMapNode url="BlogLetzterMonat.aspx" title="Letzter Monat"

Express Edition

83

4 – Navigation und Siteübersicht Listing 4.2: Die fertige Siteübersicht (Forts.) description="Alle Blogeinträge des letzten Monats" /> <siteMapNode url="GBuch.aspx" title="Gästebuch" description="Mein Gästebuch"> <siteMapNode url="GBookAktuell.aspx" title="Aktuell" description="Aktuelle Gästebuch Einträge" /> <siteMapNode url="GBookArchiv.aspx" title="Archiv" description="Ältere Gästebuch Einträge" /> <siteMapNode url="Gallerie.aspx" title="Gallerie" description="Meine Foto Gallerie"> <siteMapNode url="GallerieStrandJan06.aspx" title="Strand Session Januar 06" description="Fotos meiner Strand Session im Januar06" /> <siteMapNode url="GallerieWeihnachten05.aspx" title="Weihnachtssession 2005" description="Fotos meiner Weihnachtsserie aus 2005" /> <siteMapNode url="Kontakt.aspx" title="Kontakt" description="Kontakt" /> <siteMapNode url="Counter.aspx" title="Besucherstatistik" description="Besucherstatistik" />

Das Menü muss nun nur noch mit der Siteübersicht-Datei verbunden werden. Dazu wird der Webseite ein SiteMapDataSource-Element aus der DATEN-Gruppierung der Toolbox hinzugefügt. Dieses Steuerelement dient als Provider für die Siteübersicht-Datei und kann vom Menü-Element abgefragt werden. Nun wird ein Menü-Element wie oben beschrieben auf die Webseite gezogen. Doch dieses Mal werden keine Einträge manuell angelegt, sondern als Datenquelle das zuvor erstellte SiteMapDataSource-Element ausgewählt. Das Menü-Element wird umgehend aktualisiert, allerdings zeigt es nur den ersten Eintrag an: die Startseite. Alle anderen Elemente sind diesem Eintrag ja logisch untergeordnet, somit arbeitet das Menü perfekt. Aber dennoch sollte es nicht so bleiben.

84

Siteübersicht generieren

Abb. 4.5: Datenquelle dem Menü-Element zuweisen

Um diesen Umstand zu beheben, muss im Eigenschaften-Fenster die Eigenschaft StaticDisplayLevels auf 2 gesetzt werden. Dies sorgt dafür, dass auch alle Einträge auf der zweiten Ebene im Menü als Elemente erster Ordnung angezeigt werden. Natürlich kann dieser Wert auch höher gewählt werden, sodass er immer alle Elemente statisch anzeigt. Dies wäre allerdings nicht Sinn der Sache und sollte bei größeren Projekten keinesfalls verwendet werden. Fertig ist das Menü mit einer eigenen Siteübersicht-Datei als Vorlage. Optisch fällt dieses neue Feature allerdings nicht auf, was auf jeden Fall auch Sinn der Sache ist. Wozu eine Siteübersicht-Datei auch noch nützlich ist und warum sie auf jeden Fall verwendet werden sollte, wird im folgenden Unterkapitel erklärt.

4.3 Siteübersicht generieren Mit der erstellten Siteübersicht-Datei kann selbstverständlich, wie es auch hier durch den Namen bereits offensichtlich ist, eine Siteübersicht in die Webseite integriert werden. Für die Siteübersicht wird eine neue ASP-Seite erstellt. Für die Darstellung wird das TreeView-Element aus der Gruppe NAVIGATION der Toolbox verwendet. Im Anschluss daran wird wieder ein SiteMapDataSourceElement aus der Daten-Gruppierung der Toolbox hinzugefügt. Mit dem Aufgaben-Menü des TreeView-Elementes wird ihm als Datenquelle das zuvor erstellte SiteMapDataSource-Element ausgewählt.

Express Edition

85

4 – Navigation und Siteübersicht

Abb. 4.6: Datenquelle dem TreeView-Element zuweisen

Fertig ist die Seitenübersicht. Ausgeführt im Browser werden alle Einträge wie Links behandelt. Des Weiteren werden Gruppierungen deutlich angezeigt und können bei Bedarf sogar als Gruppe ein- und aufgeklappt werden.

86

5

Designvorlagen und Lokalisierung

Ein weiteres interessantes Feature des Visual Web Developers ist die Funktion der Definition verschiedener Designvorlagen, auch Themes genannt. Mit solchen Designvorlagen lässt sich das komplette Aussehen einer Webseite bestimmen. Des Weiteren können mehrere verschiedene Vorlagen definiert werden. Anwendungsbeispiele hierfür sind beispielsweise Saison- oder Jahreszeitenabhängige Designs. Designvorlagen ersparen eine Menge Arbeit, auch wenn die Erstellung je nach Webseitenumfang gut und gerne aufwändig sein kann. Grundsätzlich ist es aber eine saubere Methode, den Quellcode vom Design zu trennen, von daher ist diese Vorgehensweise sehr beliebt und empfohlen. Passend dazu bietet der Visual Web Developer auch das Feature der so genannten Lokalisierung. Darunter können verschiedene Sprachen fest definiert werden, um auch ausländischen Besuchern eine perfekte Webseite in der jeweiligen Landessprache anzubieten. Auf einen Blick: 쐌 Designvorlagen erstellen 쐌 Cascading Stylesheets 쐌 Designvorlagen verwenden 쐌 Lokalisierung

5.1 Designvorlagen erstellen Eine neue Designvorlage wird wie jedes neue Element über das Menü WEBSEITE | NEUES ELEMENT HINZUFÜGEN … erstellt. Dort wird als Vorlage eine Designdatei ausgewählt. Bevor die neue Designvorlage erstellt wird, fragt der Visual Web Developer nach, sofern es in dem Projekt noch keinen ASP.NET-Ordner für die Themes (App_Themes) gibt, ob er einen erstellen soll. Dies ist auf jeden Fall ratsam, damit die Designs zum einen vernünftig in dem Projekt einsortiert sind und zum zweiten, damit diese vom gesamten Projekt verwendet werden können.

Express Edition

87

5 – Designvorlagen und Lokalisierung

Abb. 5.1: Neue Designvorlage erstellen

Im Anschluss daran wird die Vorlage erstellt und in dem Ordner App_Themes automatisch ein Unterordner für die neue Designvorlage erstellt. In diesen werden dann sämtliche designspezifische Dateien wie zum Beispiel CSS-Dateien (Cascading Style Sheets, mehr dazu später) hinterlegt. Eine Designdatei ist allerdings nur für das Erscheinungsbild von Serversteuerelementen verantwortlich. HTML-Elemente können beispielsweise so nicht angepasst werden. Für diesen Zweck muss eine CSS-Datei erzeugt werden, so wie es im nächsten Kapitel der Fall ist. Um nun zum Beispiel anhand einer solchen Designdatei das Aussehen eines Kalender-Elementes zu bestimmen, muss lediglich der entsprechende Tag eingefügt werden. Leider bietet der Visual Web Developer keine komfortable Ansicht zur Definition des Designs. Diese muss komplett manuell erfolgen, was aber durch die integrierte IntelliSense-Funktion des Editors vereinfacht wird.

88

Designvorlagen erstellen

Wichtig ist, das jeder Tag den Zusatz runat=“server“ zugewiesen bekommt. Des Weiteren können die entsprechenden Attribute zum Festlegen des Aussehens hinzugefügt werden. Da es sicherlich schwer ist, in diesem Fall direkt alles im Quellcode zu schreiben, gibt es ein kleines Workaround. Das Element kann wie gewünscht in einer normalen ASP.NET-Seite erstellt und angepasst werden. Dann kann die Ansicht vom Entwurfsmodus in die Quellansicht umgestellt werden. Somit ist leicht zu erkennen, welche Attribute in der Designdatei verwendet werden sollen. Natürlich kann das Element in der Quellansicht auch kopiert und in der Designdatei eingefügt werden. Wichtig ist es aber dann in diesem Fall, den ID-Parameter zu entfernen. Er darf auf gar keinen Fall in der Designdatei vorhanden sein. Listing 5.1: Die erste Designdatei <SelectedDayStyle BackColor="#666666" ForeColor="White" Font-Bold="True" /> <TitleStyle BackColor="#999999" BorderColor="Black" Font-Bold="True" /> <SelectorStyle BackColor="#CCCCCC" /> <WeekendDayStyle BackColor="#FFFFCC" />

Jedes Kalender-Element würde nun wie in der Designdatei definiert aussehen, sofern in der Web Form als Vorlage die entsprechende Designvorlage festgelegt ist. So weit, so gut. Was ist mit Serversteuerelementen, die mehrmals auf einer Seite vorkommen sollen, aber nicht stets gleich aussehen sollen? Dafür gibt es auch einen weiteren Parameter: SkinID.

Express Edition

89

5 – Designvorlagen und Lokalisierung

In der Designdatei legt dieser Parameter einen Namen für die Vorlage des Elementes an. Dieser muss eindeutig sein und darf kein zweites Mal in dieser Designvorlage vergeben werden. Listing 5.2: Der SkinID-Parameter in der Designdatei
In der Web Form wird das entsprechende Element durch diesen Parameter an die entsprechende Vorlage gebunden. Listing 5.3: Der SkinID-Parameter in der Web Form
Fertig ist der erste Part der Designvorlage. Da mit dieser Methode, wie bereits oben beschrieben, aber keine HTML-Elemente angepasst werden können, muss zu einer weiteren Methode gegriffen werden: Cascading Style Sheets (CSS)

5.2 Cascading Style Sheets (CSS) Unter Cascading Style Sheets versteht man eine Formatierungssprache, die der Definition der Darstellung von HTML-Inhalten dient. Diese Methode ist bereits seit langem ein fest implementierter Standard. Mit ihr kann das gesamte Erscheinungsbild einer HTML-Webseite definiert werden. Allerdings ist es nicht möglich, mit CSS ASP-Serversteuerelemente genauer zu definieren, da diese meist eine komplett andere und individuellere Attribut-Syntax aufweisen. Aus diesem Grund werden für eine Designvorlage Design- und CSS-Dateien gemeinsam verwendet. Eine neue CSS-Datei wird, wie sollte es auch anders sein, über das Menü WEBSEITE | NEUES ELEMENT HINZUFÜGEN … erstellt. Dort wird als Vorlage Stylesheet ausgewählt. In einer Stylesheet-Datei befinden sich beliebig viele Regeln. Jede dieser Regeln definiert das Aussehen eines spezifizierten Elementes oder mehrerer Elemente. Aufgrund der Komplexität des ganzen Themas, kann dieses nicht komplett abgehandelt werden. In diesem Kapitel wird lediglich die Variante behandelt, bei der einem HTML-Element viele, verschiedene Eigenschaften zugewiesen werden.

90

Cascading Style Sheets (CSS)

Abb. 5.2: Neue Designvorlage erstellen

Abb. 5.3: Die IntelliSense-Funktion des Editorfensters

Express Edition

91

5 – Designvorlagen und Lokalisierung

Dank der IntelliSense-Funktion des Editors fällt die Definition der einzelnen Elemente nicht schwer. Das komplette Stylesheet kann so einfach und schnell aufgebaut werden. Listing 5.4: Der SkinID-Parameter in der Web Form body { font-family: Verdana; font-size:small; color:Black } span#titel { font-size:larger; }

Soll nur das Aussehen eines Elementes mit einer speziellen ID verändert werden, so wird diese ID einfach in der CSS-Regel mit einer Raute dem ElementenNamen angehangen. Natürlich ist dies auch sehr sinnvoll, wenn es darum geht, für eine Überschrift einfach die Schriftgröße zu erhöhen. Wenn für das Element bereits einige Eigenschaften definiert worden sind und für einen Part mit einer eigenen ID lediglich eine Eigenschaft verändert wird, so werden die anderen Eigenschaften beibehalten. Listing 5.5: Der Quellcode-Auszug, der die CSS-Datei integriert

<span id="titel">Design Demonstration

Dank ASP.Net können für eine Webseite verschiedene Designs definiert werden. Nahezu jedes Element ist individuell anpassbar.

Im Quellcode muss die CSS-Datei nicht manuell eingebunden werden. Sämtliche in der Dokumentenvorlage vorhandene Stylesheets werden bei der Ausführung der Webseite automatisch durch den Compiler inkludiert.

92

Designvorlagen verwenden

5.3 Designvorlagen verwenden

Abb. 5.4: Designvorlage einbinden

Um eine erstellte Designvorlage zu verwenden, muss lediglich im Eigenschaftenfenster der Web Form unter den Dokumenten-Eigenschaften der Wert Theme auf das gewünschte Design eingestellt werden. Natürlich kann diese Eigenschaft auch direkt im Quellcode eingestellt werden, indem dem ASP-Directive der Parameter Theme übergeben und festgelegt wird. Listing 5.6: Änderung des ASP-Directives <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" Theme="Design2" %>

Dieser Vorgang muss für jede Seite extra eingestellt werden, die auf diese Designvorlage zurückgreifen soll. Selbstverständlich können mehrere ASP-Seiten innerhalb eines Projektes auch jeweils auf eine andere Vorlage zurückgreifen. Sollen aber alle Seiten eines Projektes das gleiche Design verwenden, so gibt es noch eine weitere Möglichkeit die Designvorlage direkt für alle Seiten festzulegen: in der Konfigurationsdatei web.config.

Express Edition

93

5 – Designvorlagen und Lokalisierung

Dazu muss innerhalb der <system.web>-Sektion der <pages>-Eintrag erweitert werden. Wird ihm der Parameter theme mit einem festen Design zugewiesen, so verwenden alle ASP-Seiten in einem Projekt diese festgelegte Designvorlage. Listing 5.7: Änderung des <page>-Eintrags in der web.config <system.web> <pages theme="Design2"> ...

Abb. 5.5: Die Seite mit verwendeter Designvorlage im Browser

94

Lokalisierung

5.4 Lokalisierung Gerade für Unternehmen ist es von großer Bedeutung, sich global zu präsentieren. Neben einer deutschen Webseite ist die Existenz mindestens einer weiteren, englischen Seite durchaus von hoher Priorität. Doch dafür muss keine eigenständige, zweite Webseite erstellt werden. Der Visual Web Developer unterstützt das Feature der Lokalisierung. Folglich können so genannte Ressourcen-Dateien angelegt werden, die sämtliche Texte und Grafiken beinhalten und dann landesspezifisch dargestellt werden. Diese vorgehensweise ist sehr dynamisch und vor allem sehr komfortabel durchzuführen. Zu Beginn wird eine neue Ressourcendatei erstellt. Dies geschieht über das Menü WEBSEITE | NEUES ELEMENT HINZUFÜGEN …. Dort wird als Vorlage Ressourcendatei ausgewählt und als Dateiname Default.aspx.resx festgelegt. Damit die automatische Lokalisierung funktioniert, müssen die Ressourcendateien den gleichen Dateinamen wie die entsprechende Web Form erhalten.

Abb. 5.6: Ressourcendatei einfügen

Der Visual Web Developer möchte nun einen extra Ordner (App_LocalResources) anlegen. Dem wird selbstverständlich zugestimmt. Express Edition

95

5 – Designvorlagen und Lokalisierung

Die neue Ressourcendatei wird umgehend geöffnet und kann bearbeitet werden. Es können verschiedene Ressourcen integriert werden: Zeichenfolgen (Texte), Bilder, Symbole, Audio und andere Dateien. Welche Ressourcen eingefügt werden sollen, wird mit dem oberen, linken DropDown-Menü bestimmt. Zu Beginn werden erst einmal Zeichenfolgen eingefügt. Für die Zeichenfolgen gibt es drei Spalten: Name, Wert und Kommentar. Unter NAME wird dem Eintrag ein eindeutiger Name zugewiesen. In das Feld WERT kommt dann der eigentliche Inhalt. Falls gewünscht kann auch noch ein KOMMENTAR erstellt werden. Für den Anfang werden zwei Einträge erstellt: lblVorname und lblNachname.

Abb. 5.7: Zeichenfolgen einfügen

Nun wird eine weitere Ressourcendatei erstellt. Diese wird Default.aspx. en.resx betitelt. Wie bereits oben beschrieben, muss für die automatische Lokalisierung der Name der entsprechenden Web Form im Dateinamen der Resourcendatei aufgefasst werden. Wird nun diese für eine andere Sprache definiert, so wird dem Dateinamen der Web Form noch das Kürzel der entsprechenden Sprache angehangen.

Abb. 5.8: Zeichenfolgen für englische Lokalisierung festlegen

96

Lokalisierung

Wichtig ist natürlich, dass der Name in beiden Ressourcendateien übereinstimmt. Ansonsten kann dieses System nicht funktionieren. Nun können zwei Label-Elemente auf die Web Form Default.aspx gezogen werden. Im Eigenschaften-Fenster wird unter dem Punkt DATEN ein Ausdruck (Expression) erzeugt. Dafür gibt es einen Ausdruck-Editor. In diesem muss als Text die Ressource definiert werden.

Abb. 5.9: Der Ausdruck-Editor

Als Ausdruckstyp wird der Eintrag Resources ausgewählt. Das Feld Classkey wird leergelassen und als ResourceKey wird der Name aus der Ressource-Datei eingetragen, dessen Wert in diesem Label angezeigt werden soll. Der Visual Web Developer weist nun automatisch dem Label diese Ressource zu. Mit dem zweiten Label wird ähnlich vorgegangen, als ResourceKey wird hier allerdings lblNachname ausgewählt. Nun müssen dem ASP-Directive noch die beiden Parameter Culture und UICulture zugewiesen werden, damit die Lokalisierung für diese Web Form aktiviert wird. Damit automatisch je nach Besucher die Ressource gewechselt wird, werden beide Parameter auf auto gesetzt. Listing 5.8: Die fertige Web Form <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" Culture="auto" UICulture="auto" %>

Express Edition

97

5 – Designvorlagen und Lokalisierung Listing 5.8: Die fertige Web Form (Forts.)

">

" >

Nun kann die Seite im Browser getestet werden.

Abb. 5.10: Die fertige Seite im Browser

98

Lokalisierung

Um nun den gewünschten Effekt der Lokalisierung zu überprüfen, wird im Internet Explorer im Menü EXTRAS | INTERNETOPTIONEN die Sprache auf Englisch (en) umgestellt.

Abb. 5.11: Sprachumstellung

Nun kann die Seite im Browser neu geladen werden. Und wenn alles funktioniert wird nun die Seite auf Englisch dargestellt.

Abb. 5.12: Die Seite mit englischer Lokalisierung

Express Edition

99

5 – Designvorlagen und Lokalisierung

Was mit Zeichenfolgen geht, geht natürlich auch mit anderen Medien. Wie wäre es testweise mal mit einer Grafik-Datei? Dazu wird die DropDown-Box oben links auf BILDER umgestellt und über das RESSOURCE HINZUFÜGEN-Menü ein vorhandenes Bild, welches der Seite hinzugefügt werden soll, eingefügt.

Abb. 5.13: Bild-Ressource einfügen

Nun wird ein Image-Element auf die Web Form gezogen. Genau wie bereits bei den Labels gibt es auch hier den Ausdrucks-Editor, womit die Ressource näher bestimmt werden kann. Listing 5.9: Image-Element mit Ressourcen-Link " />

Das Prinzip ist folglich bei allen Elementen gleich und die Vorgehensweise denkbar einfach. Die Erstellung von mehrsprachigen Webseiten ist durchaus im Trend und mit recht einfachen Mitteln realisiert.

100

6

Administration und Sicherheit

Wenn es um die Webseitenadministration geht, kommen unmittelbar die Faktoren Zugriffsschutz und Sicherheit ins Spiel. Aber auch für diese Funktion bietet der Visual Web Developer bereits vorgefertigte Funktionen. In diesem Kapitel wird der Schutz einer Webseite behandelt, damit diese nicht öffentlich zugänglich ist. Dies ist eine der wichtigsten Maßnahmen bei der Programmierung eines Administrationsinterface. Das Pflegen der Seite mit dem Visual Web Developer ist zwar sehr einfach und komfortabel, aber manchmal kann es sein, das ein Zugriff über das Internet zur Pflege unumgänglich ist. Sämtliche Anmelde-Verfahren können bequem und fast ausschließlich per Drag & Drop durchgeführt werden. Auf einen Blick: 쐌 Sicherheit mit dem Visual Web Developer 쐌 Seiten schützen

6.1 Sicherheit mit dem Visual Web Developer Wenn es darum geht, seine Webseite zu schützen und mit besonderen Zugriffsrechten zu versehen, so stellt dies mit dem Visual Web Developer kein großes Problem dar. Dank dem mitgelieferten ASP.NET-Konfigurations-Tool kann recht einfach eine umfangreiche Benutzerdatenbank angelegt werden. Unter dem Menüpunkt WEBSEITE | ASP.NET KONFIGURATION kann diese erstellt werden. Dazu wird allerdings zu Beginn der Authentifizierungstyp auf Form (nicht auf Windows, wie voreingestellt) gesetzt und mindestens ein berechtigter Benutzer angelegt. Dazu wird zu Beginn eingestellt, dass die Seite für Benutzer aus dem Internet verfügbar sein wird. Den Rest erledigt das Tool. Nun muss nur noch ein Benutzerkonto hinzugefügt werden.

Express Edition

101

6 – Administration und Sicherheit

Abb. 6.1: Die ASP.NET-Konfiguration

Die Konfiguration wird komplett im Browser durchgeführt, ist übersichtlich und komfortabel. Nach dem Anlegen eines autorisierten Benutzers wird im Datenbankexplorer direkt eine zweite Datenbank eingebunden. Diese enthält alle Konfigurationsdaten, auch die Zugangsdaten der einzelnen Benutzer. Aus Sicherheitsgründen werden Passwörter allerdings verschlüsselt hinterlegt. Natürlich können auch verschiedene Rollen erstellt werden, um verschiedene Zugriffsgruppen zu definieren. Zu guter Letzt wird noch eine Zugriffsregel erstellt, die anonymen Besuchern den Zugriff auf diese Seite verweigert.

102

Sicherheit mit dem Visual Web Developer

Abb. 6.2: Zugriffsregel erstellen

Die Abfrage dieser Daten erledigt später das Login-Element aus der Toolbox Gruppierung ANMELDEN. Es muss lediglich in die Seite eingebunden werden und kann ohne großen Programmieraufwand die benötigte Aufgabe erfüllen.

Express Edition

103

6 – Administration und Sicherheit

6.2 Seiten schützen Mit der im Kapitel 6.1 durchgeführten Konfiguration ist die Seite bereits geschützt und nicht mehr für jedermann erreichbar. Aber aktuell gäbe es auch keine Möglichkeit, selber auf diese zuzugreifen, da es keine Möglichkeit der Benutzerdateneingabe gibt. Zu Beginn muss erst einmal eine kleine Anpassung in der Konfigurationsdatei web.config vorgenommen werden. Diese Anpassung definiert lediglich, wo sich das Login-Serversteuerelement befindet und wie dieses heißt. Listing 6.1: Anpassung der web.config Vorher: Nachher:

Nun kann sich der Startseite gewidmet werden, in diesem Fall der Default.aspx. Zu Beginn wird ein Login-Element aus der ANMELDEN-Gruppe der Toolbox eingefügt. Der Stil kann nun wie bei jedem Element wie gewünscht angepasst werden, oder aber eine Formatvorlage ausgewählt werden.

Abb. 6.3: Eigenschaften anpassen

104

Seiten schützen

Nun muss noch im Eigenschaftenfenster der Wert DestinationPageUrl gesetzt werden. Hier wird die Seite festgelegt, die bei einem erfolgreichen Login aufgerufen werden soll. Fertig ist die Login-Datei. Dank der Anpassung in der web.config wird das Login stets aufgerufen, wenn irgendeine Seite des Projektes aufgerufen wird, der Benutzer aber nicht eingelogged ist. Wichtig ist nun, dass auf der geschützten Seite ein LoginView-Steuerelement dem herkömmlichen Inhalt übergeordnet wird. Dieses befindet sich auch in der ANMELDEN-Gruppe der Toolbox und hat die Aufgabe, Inhalte auch nur dann zu präsentieren, wenn der Benutzer wirklich authorisiert worden ist.

Abb. 6.4: Das LoginView-Element

Bei der aktuellen Konfiguration wäre diese Vorgehensweise allerdings nicht nötig, da automatisch die Login-Seite aufgerufen wird, wenn der Benutzer nicht eingelogged ist. Aber es kann durchaus vorkommen, das es auf einer Internetpräsenz mehrere, verschiedene Bereiche gibt: ungeschützte und geschützte. Werden Benutzer-Rollen verwendet, so können diese auch für dieses Element festgelegt werden und für jede Benutzerrolle ein eigener Inhalt definiert werden. Alles in allem bietet der Visual Web Developer einen umfangreichen Funktionsumfang, wenn es um die Benutzerverwaltung mit Zugriffsrechten für eine Webseite geht. Auch gibt es bereits vorgefertigte Elemente zur Registrierung (CreateUserWizard-Element) oder Passwortanforderung (PasswordRecoveryElement). Neben dieser Variante gibt es allerdings auch noch die Variante per Sourcecode. Sämtliche Informationen über die Authentifizierung befinden sich in dem System.Security.Principal-Namespace in der Funktion IIdentity. Sie stellt Informationen über den Authentifizierungszustand (IsAuthenticated), sowie den aktuellen Benutzernamen (Name), zur Verfügung. Somit ist es durchaus auch möglich, den Benutzer persönlich anzusprechen. Express Edition

105

6 – Administration und Sicherheit Listing 6.2: Überprüfung der Authentifizierung Dim BenutzerDaten As System.Security.Principal.IIdentity BenutzerDaten = User.Identity If BenutzerDaten.IsAuthenticated Then [Anweisungen bei erfolgreichem Login] Else [Anweisungen bei fehlgeschlagenem Login] End If

106

7

Debugging und Error-Handling

Bei der Programmierung einer Webseite ist es wichtig, diese vor dem Produktiveinsatz intensiv zu testen und auf die korreke Arbeitsweise hin zu überprüfen. In Zusammenhang mit diesem Thema fallen sehr oft die Begriffe Debugging und Error-Handling. Was genau unter diesen Begriffen verstanden wird und wie die verschiedenen Techniken angewendet werden, wird in diesem Kapitel näher erklärt. Auf einen Blick: 쐌 Debugging 쐌 Error-Handling 쐌 Eigene Fehlerseiten

7.1 Debugging Der Begriff Debug kommt vom Wort Bug. Im Bereich der Entwicklung von Computer-Hard- und -Software werden Fehler gängig als Bug bezeichnet. Unter Debug versteht sich folglich die Fehlerbereinigung bzw. -beseitigung. Debugging ist schließlich die Tätigkeit der Fehlerüberprüfung während der Entwicklung, noch bevor eine Anwendung oder Webseite produktiv eingesetzt wird. Doch nicht nur die Fehlerüberprüfung fällt unter den Begriff Debugging. Das Auffinden, Diagnostizieren und die Beseitigung dieser Fehler fallen auch unter diesen Oberbegriff. Während der Programmierung bietet jeder gute Compiler auch die Möglichkeit des Debuggens. Somit auch der Visual Web Developer. Um nun eine Webseite zu debuggen, muss das Debugging erst einmal aktiviert werden. Dies geschieht komfortabel über das Menü DEBUGGEN | DEBUGGEN STARTEN oder über die Tastatur per F5. Um die Debugging-Funktion überhaupt nutzen zu können, muss diese erst einmal in der Konfigurationsdatei web.config eingestellt werden. Ist dies nicht in der Konfiguration eingestellt, so fragt der Visual Web Developer nach, ob er dies erledigen soll. Dies ist während der Entwicklung sehr sinnvoll.

Express Edition

107

7 – Debugging und Error-Handling

Abb. 7.1: Debuggen aktivieren

Natürlich kann diese Einstellung auch manuell vorgenommen werden, indem der debug-Parameter des compilation-Abschnittes in der Konfiguration entsprechend angepasst wird. Listing 7.1: Anpassung in der web.config-Datei

Dank des aktivierten Debuggings kann nun die Anwendung bzw. Webseite analysiert werden. Bei Bedarf kann die Ausführung auch schrittweise erfolgen.

Abb. 7.2: Das Debuggen-Menü und die Debug-Möglichkeiten

Der integrierte Debugger bietet folglich eine große Vielfalt an Möglichkeiten zum Debuggen der Webseite. Tritt nun bei der Webseite ein Fehler auf, so fängt der Debugger umgehend darüber und liefert weitere Informationen zu diesem Vorfall. Zusätzlich bietet er auch eine Hilfestellung zur Problemlösung an.

108

Debugging

Am besten ist es, einen Fehler zu produzieren, um sich einmal mit der Arbeitsweise des Debuggers vertraut zu machen. Dazu wird der Webseite lediglich ein Quellcode hinzugefügt, der dafür sorgt, dass die Größe eines Arrays gesprengt wird. Listing 7.2: Fehler produzieren Partial Class _Default Inherits System.Web.UI.Page Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load Dim aryTest(1) As String Dim i As Integer For i = 0 To 2 aryTest(i) = "Eintrag " & i Next End Sub End Class

Dafür wird zu Beginn ein Array initiiert mit lediglich einem Feld. Dann wird mit einer For…Next-Schleife das Array gefüllt. Allerdings mit drei Einträgen. Das kann natürlich nicht gehen.

Abb. 7.3: Der Debug-Modus

Express Edition

109

7 – Debugging und Error-Handling

Nun kann das Debuggen gestartet werden. Der Visual Web Developer wird sich umgehend melden und die so genannte IndexOutOfRange-Exception verkünden. Klar und deutlich wird dort über den Fehler berichtet: „Der Index war außerhalb des Arraybereichs.“ Zusätzlich zeigt er einige Hinweise zur Fehlerbehebung an. Würde dieser Fehler nun nicht durch den Debugger abgefangen werden, würde dieser nur als Fehlerseite im Browser ausgegeben werden. Für den ein oder anderen erfahrenen Programmierer mag diese Art der Fehlerausgabe noch reichen. Allerdings könnte es bei komplexeren Problemen zu Unverständlichkeiten führen.

Abb. 7.4: Die Fehlerausgabe im Browser

Im Produktivbetrieb muss das Debugging in jedem Fall deaktiviert sein, da der Webseiten-Besucher nicht zwingend über einen entsprechenden Debugger verfügt. Des Weiteren muss ein Error-Handling erfolgen.

110

Error-Handling

7.2 Error-Handling Um nun Fehler grundsätzlich abzufangen und eventuell darauf zu reagieren, muss ein Error-Handling durchgeführt werden. Dieses wird mit einer Try…Catch-Anweisung (siehe auch Anhang B) realisiert. Der Vorteil dieser Vorgehensweise liegt deutlich auf der Hand. Zum einen kann der Fehler individuell ausgegeben werden oder aber direkt darauf reagiert werden, in dem beispielsweise umgehend eine E-Mail an den Webmaster mit weiteren Fehlerdetails gesendet wird. Listing 7.3: Fehler abfangen Partial Class _Default Inherits System.Web.UI.Page Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load Dim aryTest(1) As String Try Dim i As Integer For i = 0 To 2 aryTest(i) = "Eintrag " & i Next Catch ex As Exception MsgBox(ex.ToString, _ MsgBoxStyle.OkOnly, _ ex.Message & "(" & ex.Source & ")") End Try End Sub End Class

Mit der Catch-Anweisung wird der Fehler als Exception-Objekt gefangen. Dieses Objekt enthält alle Informationen zum Ausnahmefehler, so zum Beispiel auch die kurze Fehlerbeschreibung (Message) und die Fehlerquelle (Source). Mit ToString wird die genaue Fehlerbeschreibung in das Datenformat String formatiert und kann so auch per MsgBox oder in einer Mail ausgegeben werden.

Express Edition

111

7 – Debugging und Error-Handling

Wird nun diese Webseite wieder gestartet, egal ob mit aktiviertem Debugging oder ohne, der Fehler wird nur noch von der Webseite selbst gehandelt und als MsgBox ausgegeben.

Abb. 7.5: Fehlerbehandlung

Ein weiterer Vorteil der eigenen Fehlerbehandlung liegt darin, dass der Rest der Webseite, solange es sich nicht um einen kritischen Fehler (z.B. keine Verbindung zur Datenbank) handelt, weiterhin ausgeführt wird.

7.3 Fehlerseiten Jeder, der ab und zu mal im weltweiten Netz unterwegs ist, kennt sie: Fehlerseiten. Jeder Webserver antwortet auf z.B. nicht gefundene Seiten mit einem fest definierten Fehlercode. Diese Fehlercodes sind standardisiert festgelegt und werden von jedem Server gleichermaßen behandelt: Mit einer Fehlerseite.

112

Fehlerseiten Fehlercode Beschreibung 400

Bad Request: Die Anforderung wurde vom Server nicht verstanden (Anforderung syntaktisch inkorrekt)

401

Unauthorized: Zugang verweigert auf Grund fehlender Benutzerdaten.

402

Payment Required: Noch reserviert, keine genaue Bedeutung.

403

Forbidden: Ausführung vom Server verweigert.

404

Not Found: Ausführung nicht möglich, da Seite oder Ressource nicht gefunden worden ist.

405

Method Not Allowed: Angeforderte Methode unzulässig.

406

Not Acceptable: Zugriff nicht gestattet.

407

Proxy Authentification Required: Zugang verweigert auf Grund fehlender Benutzerdaten.

408

Request TimeOut: Client hat keine Anfrage in der vom Server erwarteten Zeit geliefert.

409

Conflict: Anfrage kann auf Grund von Ressourcenkonflikten nicht bearbeitet werden.

410

Gone: Ressource permanent nicht verfügbar.

411

Length Required: Anfrage mit spezifizierter Inhaltslänge erwartet.

412

Precondition Failed: Falsche Vorbedingung erkannt.

413

Request Entity Too Large: Anfragengröße überschritten.

414

Request URL Too Large: URL-Anfrage zu lang.

415

Unsupported Media Type: Anfrageformat nicht vom Server unterstützt.

416

Requested Range not Satisfiable: Range-Request Header inkorrekt.

417

Expectation Failed: Expect-Request Header inkorrekt.

500

Internal Server Error: Bei der Ausführung der Seite gab es einen internen Server-Fehler.

Tabelle 7.1: HTTP-Fehlercodes

Express Edition

113

7 – Debugging und Error-Handling

Jeder Server hat eine andere Vorgehensweise bei auftretenden Fehlern, diese bekannt zu machen. Die einen senden eine extra Fehlerseite, die anderen senden lediglich diesen Fehlercode im HTTP-Header mit. Dieser muss dann durch den Webbrowser interpretiert und dargestellt werden. Wesentlich komfortabler ist es in diesem Fall, eigene Fehlerseiten zu erstellen, die dann bei auftretenden Fehlern an den Benutzer übersendet werden. Der Vorteil dieser Vorgehensweise liegt nicht nur in der größeren Individualität, sondern auch darin, dass diese Seiten projektspezifisch gestaltet (im gleichen Design) und präsentiert werden können. Dazu wird mit dem Visual Web Developer erst einmal eine Seite für den entsprechenden Fehler erstellt, der selbst dargestellt werden soll.

Abb. 7.6: Beispiel-Fehlerseite für den 404-Fehler

Schön ist hierbei, dass automatisch die vom Besucher gesuchte Seite angezeigt werden kann. Dies ist allerdings auch von großer Wichtigkeit, wenn es darum geht, automatisiert auf diesen Fehler zu reagieren. Wenn im Fehlerfall beispielsweise eine E-Mail an den Webmaster gesendet werden soll, so sollte dieser auch wissen, um welche Seite es ging. 114

Fehlerseiten

Die vom Besucher angeforderte Seite kann innerhalb der Fehlerseite aus dem Request-Objekt bezogen werden (QueryString-Funktion). Listing 7.4: Der Quelltext der selbstdefinierten Fehlerseite <%@ Page Language="VB" AutoEventWireup="false" CodeFile="404.aspx.vb" Inherits="_Default" %>

<strong> <span style="font-size: 32pt> Fehler <span style="font-size: 72pt; color: #ff0000"> 404
<strong> <span style="font-size: 10pt"> Die von Ihnen angeforderte Seite:
<% Response.Write( Request.QueryString("aspxerrorpath") )%>
konnte leider nicht gefunden weren.

Express Edition

115

7 – Debugging und Error-Handling

Zu guter Letzt erfolgt eine Anpassung in der Konfigurationsdatei web.config. Dazu gibt es den Abschnitt customErrors. Dieser unterstützt zwei Parameter: mode und defaultRedirect. Mit mode wird die Möglichkeit der eigenen Fehlerseiten ein-(on) oder ausgeschaltet (off). Mit defaultRedirect kann eine Standardseite (z.B. allgemeine Fehlerseite) festgelegt werden, die bei nicht näher festgelegten Fehlern aufgerufen wird. Nun zum Stichwort: festgelegt. Um nun eine Fehlerseite für einen speziellen Fehlercode festzulegen, wird der error-Tag verwendet. Dieser unterstützt zwei Parameter: statusCode und redirect. Mit statusCode wird der HTTP-Status (siehe Tabelle 7.1) festgelegt, für welchen die spezielle Fehlerseite angezeigt wird, die mit redirect angegeben wird. Listing 7.5: Auszug aus der Konfigurationsdatei … <system.web> … <customErrors mode="On" defaultRedirect="fehler.aspx"> <error statusCode="401" redirect="401.aspx" /> <error statusCode="403" redirect="403.aspx" /> <error statusCode="404" redirect="404.aspx" /> …

Auf diese Art und Weise kann für jeden Fehler eine extra Fehlerseite erstellt werden. Für jede spezifizierte Fehlerseite wird lediglich ein extra error-Tag angelegt.

116

8

Anwendungsbeispiele

Im achten Kapitel wird es etwas spannender. Während es zuvor mehr um Grundlagen ging und der Umgang mit dem Visual Web Developer geschult worden ist, wird ab hier endlich richtig programmiert. Dabei sind natürlich Grundlagen im Bereich von Visual Basic erforderlich. Auch hierfür gibt es einen kurzen Crash Kurs im Anhang B. Dort werden alle Grundlagen, die zur Realisation dieser Anwendungen benötigt werden, erklärt. Sämtliche programmierte Webanwendungen werden nach und nach in der im zweiten Kapitel erstellten Masterseite integriert. Schritt für Schritt entsteht eine komplett funktionsfähige Internetpräsenz. Auf einen Blick: 쐌 Newsskript 쐌 Blog 쐌 Gästebuch 쐌 Fotogalerie 쐌 E-Mail Anwendung 쐌 Counter 쐌 Transfer ins Netz

8.1 Ein Newsskript Für das Newsskript wird erst einmal eine Datenbank benötigt. Um die Datenbank gestalten zu können, muss geklärt werden, welche Felder benötigt werden. Zu Beginn wäre das Datum wichtig. Es ist wirklich essentiell, damit die News genau zugeordnet werden und nachvollziehbar sind. Für die nähere Beschreibung der News gibt es einen Namen bzw. Titel und den eigentlichen Text. Damit nun jede Neuigkeit hundertprozentig ansprechbar ist, wird jedem Eintrag eine ID zugeordnet. Insgesamt werden also vier Felder benötigt: ID, Datum, Name und Text. Das ID-Feld wird als Identitätsfeld definiert werden, damit es in diesem Fall keine doppelten Einträge geben kann. Für den Anfang werden nun ein paar Beispieleinträge benötigt. Diese garantieren später die Korrektheit des Skriptes und sind für die Programmierung und erste Tests unabdingbar. Express Edition

117

8 – Anwendungsbeispiele

Abb. 8.1: Aufbau der News-Datenbank

Im nächsten Schritt wird dann eine neue Inhaltsseite erstellt. Natürlich soll auch hier der Code in eine eigene Datei abgelegt werden und als Dateiname wird News.aspx eingetragen. Zu Beginn wird ein SqlDataSource-Steuerelement eingefügt und eine neue Datenquelle konfiguriert. Der Verbindungsstring, der alle erforderlichen Informationen zur Verbindung zum Datenbankserver beinhaltet soll natürlich gespeichert werden. Der Name ist eigentlich zweitrangig. Des Weiteren wird die Tabelle News ausgewählt und die Sortierreihenfolge (ORDER BY) beim Auswählen der Daten auf das Datum gesetzt und der Wizard abgeschlossen. Nun kann die Newsausgabe erfolgen. Für den Inhalt wird im Content-Bereich der Inhaltsseite lediglich ein Div-Element eingefügt, in das später die News eingetragen werden. Wichtig ist hierbei, dass es scrollbar wird, wenn es überfüllt ist (overflow:auto), damit das Design nicht nach unten hin verzerrt wird. Die Ausgabe der eigentlichen News erfolgt mit dem Repeater-Element aus der Toolbox-Gruppe DATEN. Dieses wird innerhalb des Div-Elementes positioniert.

118

Ein Newsskript

Abb. 8.2: Erzeugen des Verbindungsstrings

Abb. 8.3: Auswählen der Tabelle

Express Edition

119

8 – Anwendungsbeispiele

Es gibt viele Elemente zur Ausgabe von Datensätzen. Der Vorteil des RepeaterElements liegt im Gegensatz zu den anderen Elementen im selbstdefinierbaren Design. Es gibt kein vorgefertigtes Layout, die Ausgabe muss komplett selbst definiert werden. Der Inhalt eines Datenfeldes wird im Quelltext per <%# DataBinder.Eval(Container.DataItem, "SPALTENNAME") %>

angezeigt. Die Anordnung und das Layout ist folglich dem Programmierer selbst überlassen. Listing 8.1: Die Contentseite für die News <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="News.aspx.vb" Inherits="_News" title="Mona's World - News" %>

<span style="font-weight:bold"> <%# DataBinder.Eval(Container.DataItem, "name") %> (<%# DataBinder.Eval(Container.DataItem, "datum") %>)
<%# DataBinder.Eval(Container.DataItem, "text") %>



120

Ein Newsskript Listing 8.1: Die Contentseite für die News (Forts.) " SelectCommand= _ "SELECT * FROM [News] ORDER BY [datum] DESC">

Ohne großen Programmieraufwand wurde somit ein kleines Newsskript programmiert. Dank dem Web Developer sind auch komplexe Datenbankabfragen mit ein paar wenigen Klicks realisiert.

Abb. 8.4: Das fertige Newsskript

Express Edition

121

8 – Anwendungsbeispiele

8.2 Ein Gästebuch Ein Gästebuch ist in der heutigen Zeit auf privaten Webseiten zu einem MustHave geworden. In diesem können sich Besucher verewigen, einfach mal „Hallo“ sagen, Anregungen und auch Kritik hinterlassen. Für die neue Datentabelle GBuch werden sechs Felder benötigt: id, datum, name, email, text und ip. Das ID-Feld wird wieder als Index gewählt und automatisch erhöht. Das Ip-Feld dient dazu, die Ip-Adresse des Benutzers zu speichern, der den Eintrag erstellt hat. Im Ernstfall ist dies sehr wichtig, um den Benutzer ausfindig zu machen.

Abb. 8.5: Aufbau der Gästebuch-Datenbank

Wie bereits bei den News werden wieder ein SqlDataSource- und ein RepeaterSteuerelement verwendet. Das SqlDataSource-Element muss mit den erweiterten SQL-Generierungsoptionen konfiguriert werden. Mit dem Button ERWEITERTE SQL-GENERIERUNGSOPTIONEN im zweiten Schritt des Konfigurationsassistenten wird festgelegt, dass auch INSERT-, UPDATE- und DELETE-Anweisungen generiert werden sollen.

122

Ein Gästebuch

Dies wird später für die Erstellung eines neuen Gästebuch-Eintrages durch einen Benutzer benötigt.

Abb. 8.6: Erweiterte SQL-Generierungsoptionen aktivieren

Abb. 8.7: DefaultMode auf Insert einstellen

Express Edition

123

8 – Anwendungsbeispiele

Für die Erstellung eines neuen Eintrages wird das FormView-Element verwendet. Auch dieses befindet sich in der Untergruppierung DATEN der Toolbox. Wichtig hierbei ist, dass im Eigenschaften-Fenster die Option DefaultMode auf Insert gestellt wird. Das Element soll ja keine Daten anzeigen oder löschen, sondern lediglich einen Eintrag hinzufügen. Nun kann über das Aufgaben bzw. SmartTag-Menü die Vorlage bearbeitet werden. Schließlich darf lediglich ein Name, eine E-Mail-Adressse und ein Kommentar eingegeben werden. Dazu wird das InsertItem-Template angepasst. Die restlichen Templates (Vorlagen) können getrost ignoriert werden, da sie nicht benötigt und verwendet werden.

Abb. 8.8: InsertItem Template bearbeiten Listing 8.2: Die Content-Seite für das Gästebuch <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="GBuch.aspx.vb" Inherits="_GBuch" title="Mona's World - Gästebuch" %>

124

Ein Gästebuch Listing 8.2: Die Content-Seite für das Gästebuch (Forts.)

<span style="font-weight:bold"> <%# DataBinder.Eval(Container.DataItem, "id") %>. <%# DataBinder.Eval(Container.DataItem, "name") %> (<%# DataBinder.Eval(Container.DataItem, "datum") %>)
<%# DataBinder.Eval(Container.DataItem, "text") %>

" SelectCommand="SELECT * FROM [GBuch] ORDER BY [id] DESC" ConflictDetection="CompareAllValues" InsertCommand="INSERT INTO [GBuch] ([datum], [name], " "[text], [email], [ip]) VALUES " "(GETDATE(), @name, @text, @email, @ip)" OldValuesParameterFormatString="original_{0}"> <span style="text-decoration: underline"> Eintrag hinterlassen:



Express Edition

125

8 – Anwendungsbeispiele Listing 8.2: Die Content-Seite für das Gästebuch (Forts.) Name:
Email:
Kommentar:

Nun muss noch der Programmcode erstellt werden, um die Ip-Adresse für den Datenbankeintrag zu erzeugen. Diese wird aus den Request-Daten gewonnen und ist in der Funktion UserHostAddress zu finden. 126

Ein Gästebuch

In der Entwurfsansicht wird einfach ein Doppelklick auf das SqlDataSourceElement gemacht. Im Methoden-DropDown des Editor-Fensters wird nun Load ausgewählt und dem Datenbank-Parameter ip die Ip-Adresse zugewiesen. Listing 8.3: Der Gästebuch-Quellcode Partial Class _GBuch Inherits System.Web.UI.Page Protected Sub SqlDataSource1_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles SqlDataSource1.Load SqlDataSource1.InsertParameters.Add("ip", _ Request.UserHostAddress.ToString) End Sub End Class

Abb. 8.9: Das fertige Gästebuch

Express Edition

127

8 – Anwendungsbeispiele

8.3 Ein Blog Blog ist die Kurzform für Weblog (Web Logbuch), also ein Onlinetagebuch. Darin werden Gedanken, Meinungen und aktuelle Themen niedergeschrieben und können von den Besuchern kommentiert werden. Die Einträge werden auch hier in einer Datenbank hinterlegt. Allerdings werden dieses Mal zwei Tabellen benötigt, eine für die eigentlichen Blog-Einträge sowie eine für die Kommentare. Für die Blog-Einträge werden vier Felder beansprucht: id, datum, titel und text. Für die dazugehörigen Kommentare ebenfalls vier: id, blogID, datum und text. Die BlogID wird dazu benötigt, einen oder mehrere Kommentare eindeutig einem Blog-Eintrag zuzuordnen. Das Blog-Skript ähnelt sehr dem Newsskript (Kapitel 8.1). Von daher wird es dieses mal komplett anders programmiert: Ohne die bereits vorgefertigten Serversteuerelemente. So wird ausführlich und deutlich aufgezeigt, wie die Seite komplett durch Visual Basic erzeugt (programmiert) werden kann.

Abb. 8.10: Aufbau der Blog-Datenbanken

Für die Contentseite werden zwei Div-Elemente verwendet: Eines für die BlogInhalte und eines für das Formular zum Erstellen eines neuen Kommentars.

128

Ein Blog

Standardmäßig werden beide nicht angezeigt, erst wenn vom Code entschieden worden ist, welchen Inhalt er anzeigen soll. Listing 8.4: Die Content-Seite für das Blog <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Blog.aspx.vb" Inherits="_Blog" title="Mona's World - Blog" %>

Kommentar hinzufügen:

Express Edition

129

8 – Anwendungsbeispiele

Für die Programmierung des Blog-Skriptes kommt eine Select-Case-Anweisung zum Einsatz. Sie soll das Management übernehmen und je nachdem die Blog-Einträge samt Kommentaren anzeigen oder aber ein Formular für die Erstellung eines neuen Kommentars. Bei der Datenbank-Funktion gibt es ein kleines Problem. Um dem jeweiligen Eintrag die zugehörigen Kommentare zuzuordnen, müssen zwei Datenbankabfragen realisiert werden. Leider unterstützt der SQL Server 2005 in der Express Edition jeweils nur eine aktive Abfrage (Query) pro Verbindung. Aus diesem Grund wurde ein Workaround angefertigt und eine zweite Verbindung erstellt. Diese Vorgehensweise ist nicht sonderlich komfortabel. Auf gar keinen Fall sollten mehr als zwei Verbindungen geöffnet werden. In diesem Beispiel ist dies nur ausnahmsweise gestattet, da es wirklich nur zwei Verbindungen sind. Allerdings erfordert jede weitere Verbindung mehr Zeit. Soll während einer aktiven Abfrage noch eine zweite oder sogar dritte Abfrage gestartet werden, so ist es sinnvoller, jedes Query nacheinander auszuführen und die Inhalte in ein Array zu speichern. Diese Vorgehensweise spart in jedem Fall eine zweite oder gar dritte Verbindung ein, was die Anwendung performanter gestaltet. Um das Datum in die Datenbank einzuspeichern, wird komfortabel eine integrierte Funktion des SQL-Servers verwendet: Die GETDATE-Funktion. Diese liefert passend für den Sql-Datentyp Datetime das aktuelle Datum und speichert es umgehend in das Feld Datum. Listing 8.5: Der Blog-Quellcode 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient Partial Class _Blog Inherits System.Web.UI.Page 'Variablen für Blog-Datenbankinhalte Dim strDatum As String Dim strTitel As String Dim strText As String Dim strId As String 'Variablen für Blog-Kommentar-Datenbankinhalte Dim strKDatum As String Dim strKText As String

130

Ein Blog Listing 8.5: Der Blog-Quellcode (Forts.) 'String für die Inhaltsrückgabe Dim strInhalt As String 'Strings für Url Variablen Dim strAktion As String Dim strBlogId As String 'String für Formular Daten Dim strFormKommentar As String Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'Beide Div-Elemente standardmäßig nicht anzeigen Inhalt.Visible = False Kommentar.Visible = False 'Per Url übergebene Aktionsvariable einlesen strAktion = Request.QueryString("aktion") 'SqlConnection-Klasse einbinden und definieren Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") Dim dbKConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden Dim dbCommand As SqlCommand Dim dbKCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader Dim dbKDataReader As SqlDataReader

Express Edition

131

8 – Anwendungsbeispiele Listing 8.5: Der Blog-Quellcode (Forts.) Try Select Case strAktion Case "Kommentar" 'Kommentar-Element einblenden Kommentar.Visible = True 'Kommentar und Blog_id einlesen strFormKommentar = Request.Form("kommentar") strBlogId = Request.QueryString("blog_id") If Not strFormKommentar = "" Then 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Insert Into Blog_Kommentare " + _ "(blog_id, datum, text) " + _ " Values ('" & strBlogId & "', " + _ "GETDATE(), '" + _ strFormKommentar & "');", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'DataReader und Verbindung schließen dbConnection.Close() dbDataReader.Close() 'Zur Blog-Seite wechseln um den Kommentar anzuzeigen Response.Redirect("Blog.aspx", False) Exit Try End If Case Else 'Inhalts-Element einblenden Inhalt.Visible = True 'Verbindung zum Server aufbauen dbConnection.Open()

132

Ein Blog Listing 8.5: Der Blog-Quellcode (Forts.) 'Sql-Befehl definieren ... dbCommand = New SqlCommand("Select * from Blog " + _ "ORDER BY Datum DESC;", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Zurückgelieferte Daten einlesen... While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strId = dbDataReader(0).ToString strDatum = dbDataReader(1).ToString strTitel = dbDataReader(2).ToString strText = dbDataReader(3).ToString 'Inhalt formatieren und neuen Blogeintrag hinzufügen strInhalt &= "

---

" strInhalt &= "" & strTitel & " " strInhalt &= "(" & strDatum & ") " strInhalt &= "" strInhalt &= "[Kommentieren]" strInhalt &= "
" strInhalt &= strText & "

" 'Verbindung zum Server für Kommentare aufbauen dbKConnection.Open() 'Sql-Befehl definieren ... dbKCommand = New _ SqlCommand("Select * from Blog_Kommentare " + _ "WHERE blog_id = " + strId + _ "ORDER BY Datum ASC;", _ dbKConnection) '... und die Datenbank abfragen. dbKDataReader = dbKCommand.ExecuteReader() strInhalt &= "Kommentar(e):
" 'Überprüfen, ob Daten vorliegen If dbKDataReader.HasRows Then

Express Edition

133

8 – Anwendungsbeispiele Listing 8.5: Der Blog-Quellcode (Forts.) 'Zurückgelieferte Daten einlesen... While dbKDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strKDatum = dbKDataReader(2).ToString strKText = dbKDataReader(3).ToString 'Inhalt formatieren und Kommentar hinzufügen strInhalt &= "" strInhalt &= strKDatum & ":
" strInhalt &= strKText & "

" strInhalt &= "" End While Else 'Inhalt formatieren und Info ausgeben strInhalt &= "" strInhalt &= "(Noch nicht kommentiert)

" strInhalt &= "" End If 'DataReader und Verbindung schließen dbKDataReader.Close() dbKConnection.Close() End While 'DataReader und Verbindung schließen dbDataReader.Close() dbConnection.Close() 'Ausgelesene Daten dem Div-Element Inhalt übergeben. Inhalt.InnerHTML = strInhalt End Select Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try End Sub End Class

134

Ein Blog

Mit der Redirect-Funktion aus der Response-Klasse erfolgt eine Umleitung auf eine definierte Seite. In diesem Fall soll aber lediglich die Seite neu geladen werden, damit der neue Eintrag angezeigt wird – folglich wird dort die Blog.aspx übergeben. Ihr werden zwei Parameter übergeben. Zum ersten die Seite oder Url, die in den Browser geladen werden soll und zum zweiten, ob nachfolgender Code abgebrochen werden soll. Wird der zweite Parameter nicht gesetzt, so wird dieser automatisch auf „true“ gesetzt und der Rest des Codes abrupt beendet. In diesem Fall würde diese Einstellung allerdings zu einem Ausnahmefehler führen, da die Fehlerbehandlung noch nicht abgeschlossen ist.

Abb. 8.11: Das fertige Blog

Express Edition

135

8 – Anwendungsbeispiele

8.4 Eine Fotogalerie Natürlich darf auf einer privaten Webseite auch keine Fotogalerie fehlen. In dieser können persönliche Momente oder einfach nur schöne Fotos an andere Menschen übermittelt werden. Für die Galerie sind auch wieder zwei Datentabellen nötig. Eine für die eigentlichen Bilder und eine für die Kategorien. Dank den Kategorien können die Bilder übersichtlich verwaltet und dargestellt werden. Die Tabelle für die Bilder (Galerie) bekommt fünf Felder: ID, kat_id, name, beschreibung und foto_url. In dem Feld kat_id wird später die ID der Kategorie eingetragen, der das Bild untergeordnet ist. Das Feld foto_url speichert den Dateinamen des Fotos. Die Kategorie-Tabelle (Gallerie_Kat) weist vier Felder auf: ID, name, beschreibung und foto_url.

Abb. 8.12: Aufbau der Galerie-Datentabellen

136

Eine Fotogalerie

Bei der Contentseite für die Galerie gibt es keine Besonderheit. Sie weist nur ein Div-Element für den Inhalt auf. Den Rest übernimmt später der Code im Hintergrund. Listing 8.6: Die Galerie-Contentseite <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Gallerie.aspx.vb" Inherits="_Gallerie" title="Mona's World - Gallerie" %>

Der Programmcode ähnelt ein wenig dem vorherigen. Allerdings gibt es dieses Mal mehrere Aktionen, die durchgeführt werden. Standardmäßig werden alle Kategorien angezeigt. Aber natürlich kann auch mit einem Klick direkt in eine spezielle Kategorie gewechselt werden. Bei der Bilderübersicht innerhalb einer Kategorie wird eine Tabelle generiert. Zwei Bilder werden stets nebeneinander angezeigt. Da die Bilder in dieser Ansicht recht klein sind, gibt es noch eine weitere Aktion für die Detailansicht eines Bildes. Die Aktionen werden über den Link übergeben und können so abgefragt und behandelt werden.

Express Edition

137

8 – Anwendungsbeispiele Listing 8.7: Der Quellcode für die Galerie 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient Partial Class _Gallerie Inherits System.Web.UI.Page 'Variablen für Gallerie-Datenbankinhalte Dim strId As String Dim strName As String Dim strBeschreibung As String Dim strFotoUrl As String 'String für die Inhaltszurückgabe Dim strInhalt As String 'Strings für Url Variablen Dim strAktion As String Dim strFotoId As String 'String für Gallerie-Verzeichnung Dim strFotoVerzeichnis As String Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'Per Url übergebene Aktionsvariable einlesen strAktion = Request.QueryString("aktion") 'Foto-Verzeichnis festlegen strFotoVerzeichnis = "img/gallerie/" 'SqlConnection-Klasse einbinden und definieren Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Username;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden

138

Eine Fotogalerie Listing 8.7: Der Quellcode für die Galerie (Forts.) Dim dbCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader Try Select Case strAktion Case "Detail" 'Foto_id einlesen strFotoId = Request.QueryString("id") 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New SqlCommand("Select * from Gallerie " + _ "Where id=" & strFotoId + _ "ORDER BY id DESC;", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Zurückgelieferte Daten einlesen... While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strId = dbDataReader(0).ToString strName = dbDataReader(2).ToString strBeschreibung = dbDataReader(3).ToString strFotoUrl = dbDataReader(4).ToString 'Inhalt formatieren und neue Kategorie hinzufügen strInhalt &= "" & strName & ":
" strInhalt &= "
" End While 'DataReader und Verbindung schließen dbDataReader.Close()

Express Edition

139

8 – Anwendungsbeispiele Listing 8.7: Der Quellcode für die Galerie (Forts.) dbConnection.Close() 'Ausgelesene Daten dem Div-Element Inhalt übergeben. Inhalt.InnerHTML = strInhalt Case "Inhalt" 'Foto_id einlesen strFotoId = Request.QueryString("id") 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Select * from Gallerie " + _ "Where kat_id=" & strFotoId + _ "ORDER BY id DESC;", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Überschrift ausgeben strInhalt &= "Inhalt:

" strInhalt &= "" Dim i As Integer = 1 'Zurückgelieferte Daten einlesen... While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strId = dbDataReader(0).ToString strName = dbDataReader(2).ToString strBeschreibung = dbDataReader(3).ToString strFotoUrl = dbDataReader(4).ToString 'Inhalt formatieren und neue Kategorie hinzufügen If i = 1 Then strInhalt &= "" strInhalt &= ""

If i = 2 Then strInhalt &= "" i = 1 ElseIf i = 1 Then i = 2 End If End While strInhalt &= "

" 140 Eine Fotogalerie Listing 8.7: Der Quellcode für die Galerie (Forts.) strInhalt strInhalt strInhalt strInhalt strInhalt strInhalt strInhalt strInhalt &= &= &= &= &= &= &= &= "" & strName & "" " " " " strBeschreibung & " " "

" 'DataReader und Verbindung schließen dbDataReader.Close() dbConnection.Close() 'Ausgelesene Daten dem Div-Element Inhalt übergeben. Inhalt.InnerHTML = strInhalt Case Else 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Select * from Gallerie_Kat " + _ "ORDER BY id DESC;", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Überschrift ausgeben

Express Edition

141

8 – Anwendungsbeispiele Listing 8.7: Der Quellcode für die Galerie (Forts.) strInhalt &= "Kategorien:

" strInhalt &= "" 'Zurückgelieferte Daten einlesen... While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strId = dbDataReader(0).ToString strName = dbDataReader(1).ToString strBeschreibung = dbDataReader(2).ToString strFotoUrl = dbDataReader(5).ToString 'Inhalt formatieren und neue Kategorie hinzufügen strInhalt &= "" End While strInhalt &= "

" strInhalt &= "" & strName & " " strInhalt &= "[Anzeigen]" strInhalt &= " " strInhalt &= " " strInhalt &= strBeschreibung & " " strInhalt &= "

" 'DataReader und Verbindung schließen dbDataReader.Close() dbConnection.Close() 'Ausgelesene Daten dem Div-Element Inhalt übergeben. Inhalt.InnerHTML = strInhalt End Select Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try End Sub End Class

142

Eine E-Mail-Anwendung

Mit verhältnismäßig einfachen Mitteln wurde folglich eine funktionale und übersichtliche Galerie realisiert.

Abb. 8.13: Die Fotogalerie im Browser

8.5 Eine E-Mail-Anwendung Natürlich fehlt jetzt noch eine E-Mail-Anwendung, damit Besucher ihre Nachrichten direkt auf der Webseite eingeben können und diese Mitteilung dann direkt automatisch per E-Mail übertragen wird. Dies ist sinnvoll, da es in der heutigen Zeit recht kritisch ist, seine E-Mail-Adresse öffentlich zu hinterlegen: Viele automatisierte Programme grasen Webseiten ab, um E-Mail-Adressen für Spam-Zwecke zu missbrauchen. In der Contentseite der Kontakt-Funktion wird das Formular für die E-Mail erstellt. Benötigt werden aber nur Felder für den Absendernamen, die E-MailAdresse des Senders und ein Textfeld für die eigentliche Mitteilung. Der Empfänger wird direkt im Quellcode eingegeben, da dieser nicht verändert werden soll. Express Edition

143

8 – Anwendungsbeispiele Listing 8.8: Die Content-Seite für das Kontaktformular <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Kontakt.aspx.vb" Inherits="_Kontakt" title="Mona's World - Kontakt" %>

<strong> <span style="text-decoration: underline"> Kontakt:

Hier könnt Ihr mir eine E-Mail zukommen lassen. Ich werde versuchen, diese schnellstmöglich zu beantworten und mich umgehend bei Euch melden.

Name:

eMail:



144

Eine E-Mail-Anwendung Listing 8.8: Die Content-Seite für das Kontaktformular (Forts.) Mitteilung:

Nun kommt der Code zum Versenden der Mail. Die Mail-Funktionen befinden sich im System.NET.Mail-Namespace. Dieser ermöglicht das Senden von elektronischen Nachrichten über einen Smtp-Server. Funktion

Beschreibung

SmtpClient Credentials

Legt die Smtp-Server-Authentifizierung fest.

DeliveryMethod

Legt die Übertragungsmethode fest. Zur Auswahl stehen: - SmtpDeliveryMethod.SpecifiedPickupDirectory - SmtpDeliveryMethod.PickupDirectoryFromIis - SmtpDeliveryMethod.Network

Send

Sendet eine Mail per MailMessage-Objekt (siehe unten).

MailMessage IsBodyHTML

Legt fest, ob die Mail im HTML-Format gesendet werden soll.

From

Definiert den Absender der E-Mail.

To

Definiert den Adressaten der E-Mail. Per To.Add wird ein weiterer Adressat hinzugefügt.

Tabelle 8.1: Benötigte Funktionen zum E-Mail-Senden

Express Edition

145

8 – Anwendungsbeispiele Funktion

Beschreibung

Subject

Legt den Betreff der Mail fest.

Body

Definiert den eigentlichen Mailinhalt.

Tabelle 8.1: Benötigte Funktionen zum E-Mail-Senden (Forts.)

Wichtig ist auf jeden Fall die Formularüberprüfung. Wird der Name oder die EMail-Adresse nicht angegeben, so wird nach dem Absenden des Formulars noch einmal explizit danach gefragt. Andernfalls würde es einen Laufzeitfehler geben. Listing 8.9: Der Quellcode für das Kontaktformular 'System.NET.Mail- und System.NET-Namespace einbinden Imports System.NET Imports System.NET.Mail Partial Class _Kontakt Inherits System.Web.UI.Page 'Variablen für die Formularfelder Dim strFormName As String Dim strFormEmail As String Dim strFormMitteilung As String 'Variablen zum Mail senden Dim mailClient As New SmtpClient("localhost", 25) Dim mailMitteilung As New MailMessage() Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'Formulardaten einlesen strFormName = Request.Form("name") strFormEmail = Request.Form("email") strFormMitteilung = Request.Form("mitteilung") 'Prüfen, ob eine Mitteilung eingegeben worden ist If Not strFormMitteilung = "" Then Try If strFormName = "" Then

146

Eine E-Mail-Anwendung Listing 8.9: Der Quellcode für das Kontaktformular (Forts.) strFormName = _ InputBox("Bitte Absendernamen eingeben!") End If If strFormEmail = "" Then strFormEmail = _ InputBox("Bitte E-Mail Adresse eingeben!") End If 'eMail Format festlegen mailMitteilung.IsBodyHTML = False 'Absender festlegen mailMitteilung.From = New MailAddress(strFormEmail) 'Empfänger festlegen mailMitteilung.To.Add("Empfä[email protected]") 'Betreff festlegen mailMitteilung.Subject = "eMail über Kontaktformular" 'Body festlegen mailMitteilung.Body = strFormMitteilung

'Anmeldeinformationen für den Server mailClient.Credentials = _ CredentialCache.DefaultNetworkCredentials 'Sende Methode der Mail festlegen mailClient.DeliveryMethod = SmtpDeliveryMethod.Network 'Mail senden mailClient.Send(mailMitteilung) Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try End If End Sub End Class

Express Edition

147

8 – Anwendungsbeispiele

So wurde mit einer wirklich einfachen Methode eine E-Mail-Anwendung realisiert. Natürlich können mit dem System.NET.Mail-Namespace noch komplexere Anwendungen wie z.B. komplette Mailclients erstellt werden. Der Kreativität sind hierbei kaum Grenzen gesetzt.

Abb. 8.14: Das fertige Kontaktformular

8.6 Ein Counter Worauf nur wenige private Webseiten verzichten, ist ein Besucherzähler, ein so genannter Counter. Dieser stillt die Neugierde eines jeden Webseiten-Besitzers und verrät, wie viele User sich die Webpräsenz bereits angesehen haben. Der Counter besteht aus zwei Teilen. Der erste Teil ist ein kleiner Quellcode, der in die Master-Seite integriert wird. Der zweite Teil ist eine normale ContentSeite, die die Daten übersichtlich aufbereitet und ausführlich über die Zugriffsstatistik informiert.

148

Ein Counter

Sämtliche Zählerstände werden tagesweise in einer Datenbank hinterlegt. So kann eine ausführliche Besucherstatistik generiert werden. Dazu wird eine Tabelle (Counter) mit fünf Feldern angelegt: ID, tag, monat, jahr und counter.

Abb. 8.15: Die Datentabelle des Counters

Für die Anzeige des Counters wird in der Masterseite extra ein Div-Element angelegt. Es wird dort platziert, wo später der Counter angezeigt werden soll. Der genaue Wert wird in der Quellcode-Seite (MasterPage.master.aspx) berechnet und zurückgegeben. Listing 8.10: Div-Element für die Counter-Anzeige

Express Edition

149

8 – Anwendungsbeispiele

Da jeder Tag einen eigenen Eintrag bekommen soll, ist es wichtig, vorher zu überprüfen, ob der aktuelle Tag bereits in der Datenbank hinterlegt ist. Das aktuelle Datum kann mit der Today-Funktion aus dem System.Date-Namespace ermittelt werden. Mit den Funktionen Day, Month und Year des Datum-Objektes kann das Datum dann aufgesplittet werden, so wie es für die Datenbank benötigt wird. Ist bereits ein Eintrag des aktuellen Tages erfasst, so wird lediglich der CounterWert ausgelesen und um eins hochgesetzt. Andernfalls wird der aktuelle Tag hinterlegt und ein Eintrag erstellt. Listing 8.11: Der Quellcode für die Counterverwaltung 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient Partial Class MasterPage Inherits System.Web.UI.MasterPage 'Datumsvariablen definieren Dim dtDatum As Date Dim strTag As String Dim strMonat As String Dim strJahr As String 'Counter Variable Dim intCounter As Integer 'Booleansche Variable für Countercheck Dim bolNeuerEintrag As Boolean Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'Aktuelles Datum ermitteln und aufteilen dtDatum = System.DateTime.Today strTag = dtDatum.Day.ToString strMonat = dtDatum.Month.ToString strJahr = dtDatum.Year.ToString 'SqlConnection-Klasse einbinden und definieren

150

Ein Counter Listing 8.11: Der Quellcode für die Counterverwaltung (Forts.) Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden Dim dbCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader Try 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Select counter From Counter " + _ "Where tag = '" & strTag & "' " + _ "AND monat = '" & strMonat & "' " + _ "AND jahr = '" & strJahr & "';", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() '... und in die vorbereiteten Variablen einlesen. If dbDataReader.HasRows Then While dbDataReader.Read intCounter = dbDataReader(0) End While bolNeuerEintrag = False Else bolNeuerEintrag = True End If dbDataReader.Close() If bolNeuerEintrag = True Then

Express Edition

151

8 – Anwendungsbeispiele Listing 8.11: Der Quellcode für die Counterverwaltung (Forts.) 'Counterstand einsetzen intCounter = 1 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Insert Into Counter " + _ "(tag, monat, jahr, counter) " + _ " Values ('" & strTag & "', '" + _ strMonat & "', '" + _ strJahr & "', '" + _ intCounter.ToString & "');", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() Else 'Counter hochsetzen intCounter += 1 'Sql-Befehl definieren ... dbCommand = New _ SqlCommand("Update Counter " + _ "Set counter=" & intCounter.ToString + _ "Where tag = '" & strTag & "' " + _ "AND monat = '" & strMonat & "' " + _ "AND jahr = '" & strJahr & "';", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() End If 'DataReader und Verbindung schließen dbConnection.Close() dbDataReader.Close() Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try

152

Ein Counter Listing 8.11: Der Quellcode für die Counterverwaltung (Forts.) counter.InnerHTML = "Besucher heute: " & intCounter.ToString End Sub End Class

Fertig ist der Counter. Zumindest der erste Teil. Was noch fehlt ist die Statistikfunktion, die die Besucherzahlen der einzelnen Tage auflistet. Diese kommt wieder in eine extra Inhaltsseite. Listing 8.12: Die Inhaltsseite für die Besucherstatistik <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Counter.aspx.vb" Inherits="_Counter" title="Mona's World - Besucherstatistik" %>

Da die Monate auch nur als Zahlen eingespeichert werden, wäre vor der Ausgabe eine Umwandlung in den entsprechenden Monatsnamen von Vorteil. Diese Aufgabe übernimmt ein Array, welches jeden Monatsnamen und als Index die dazugehörige Kennziffer enthält. Um nun für den numerischen Monatswert 4 den entsprechenden Monatsnamen zu erhalten wird dieser an das Array übergeben (aryMonat(4)) und liefert wie gewünscht April zurück. Der Rest wird wie gehabt realisiert.

Express Edition

153

8 – Anwendungsbeispiele Listing 8.13: Der Quellcode für die Besucherstatistik 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient Partial Class _Counter Inherits System.Web.UI.Page 'Array für Monatsnamen Dim aryMonat(12) As String 'Strings für Datenbankinhalte Dim strTag As String Dim strMonat As String Dim strJahr As String Dim strCounter As String 'String für die Inhaltszurückgabe Dim strInhalt As String Protected Sub Page_Load(ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles Me.Load 'Monatsnamen festlegen aryMonat(1) = "Januar" aryMonat(2) = "Februar" aryMonat(3) = "März" aryMonat(4) = "April" aryMonat(5) = "Mai" aryMonat(6) = "Juni" aryMonat(7) = "Juli" aryMonat(8) = "August" aryMonat(9) = "September" aryMonat(10) = "Oktober" aryMonat(11) = "November" aryMonat(12) = "Dezember" 'SqlConnection-Klasse einbinden und definieren Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _

154

Ein Counter Listing 8.13: Der Quellcode für die Besucherstatistik (Forts.) "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden Dim dbCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader Try 'Verbindung zum Server aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New SqlCommand("Select * from Counter " + _ "ORDER BY id ASC;", _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() strInhalt &= "Besucherstatistik:

" While dbDataReader.Read() strTag = dbDataReader(1).ToString strMonat = dbDataReader(2).ToString strJahr = dbDataReader(3).ToString strCounter = dbDataReader(4).ToString strInhalt strInhalt strInhalt strInhalt End While

&= &= &= &=

strTag & ". " aryMonat(strMonat) & " " strJahr & ": " strCounter & " Besucher
"

'DataReader und Verbindung schließen dbDataReader.Close() dbConnection.Close() 'Ausgelesene Daten dem Div-Element Inhalt übergeben.

Express Edition

155

8 – Anwendungsbeispiele Listing 8.13: Der Quellcode für die Besucherstatistik (Forts.) Inhalt.InnerHTML = strInhalt Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try End Sub End Class

So ist jederzeit ein Einblick in die aktuelle Besucherstatistik möglich. Ausführlich informiert diese über den Besucherandrang.

Abb. 8.16: Die Besucherstatistik im Browser

156

Der Transfer ins Netz

8.7 Der Transfer ins Netz Da nun eine komplette Webseite programmiert worden ist, soll diese natürlich auch ins Netz gestellt werden, damit diese von möglichst vielen Besuchern angesurft wird. Wie bereits erwähnt, ist der Visual Web Developer ein Multitool und auch für diese Aufgabe gibt es das passende Werkzeug: Das Webseiten-Kopier-Tool aus dem Menü WEBSEITE | WEBSEITE KOPIEREN.

Abb. 8.17: Das Webseiten-Kopier-Tool

Nach einem Klick auf den oberen, linken Button VERBINDEN werden die Zugangsdaten abgefragt und nach der Bestätigung dieser, umgehend eine Verbindung zum Server aufgebaut. Nun können alle oder auch nur einzelne Dateien hochgeladen werden. Auch das spätere Synchronisieren der Daten ist problemlos möglich.

Express Edition

157

9

Webseitenverwaltung

So schön ein Newsskript oder eine Galerie auch ist, richtig komfortabel wird es erst mit einer einfachen Administrations-Möglichkeit. Die Pflege über den Web Developer ist zwar elegant und komfortabel gelöst, aber ein wenig aufwändiger als eine selbstprogrammierte Lösung und außerdem nicht weltweit ohne Installation zusätzlicher Software möglich. In diesem Kapitel wird der Schutz einer Webseite angewendet, damit diese nicht öffentlich zugänglich ist. Dies ist eine der wichtigsten Maßnahmen bei der Programmierung eines Administrationsinterface. Außerdem wird direkt die Administrationsmöglichkeit des Newsskriptes erstellt, damit die allgemeine Vorgehensweise ersichtlicht wird. Auf einen Blick: 쐌 Administrationsoberfläche anlegen und schützen 쐌 Skript pflegen und verwalten

9.1 Administrationsoberfläche anlegen Für die Administrationsoberfläche wird die komplette, in Kapitel 8 erstellte, Webseite dupliziert und in einen Unterordner des Projektes mit dem Titel Admin kopiert. Natürlich wird der Programmcode entsprechend modifiziert, damit die Daten verändert werden können. Zu Beginn wird die Webseite wie in Kapitel 6 beschrieben konfiguriert und geschützt. Somit besteht schon ein hervorragender Schutz und mit einer einfachen Passwortabfrage kann eine Benutzerauthentifizierung durchgeführt werden. Des Weiteren wird eine neue Contentseite erstellt, die mit einem Login-Element bestückt wird. War die Benutzerauthentifizierung erfolgreich, so wird direkt die angeforderte Seite geladen. Listing 9.1: Das Login-Element <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Login" title="Mona's World - Administration" %>

Express Edition

159

9 – Webseitenverwaltung Listing 9.1: Das Login-Element (Forts.)

<TitleTextStyle BackColor="#5D7B9D" ForeColor="White" Font-Size="0.9em" Font-Bold="True">
160

Administrationsoberfläche anlegen Listing 9.1: Das Login-Element (Forts.) BorderWidth="1px" BorderColor="#CCCCCC" Font-Size="0.8em" Font-Names="Verdana">

Weiterer Programmcode, zum Beispiel zur Überprüfung der eingegebenen Daten ist nicht nötig, da alles automatisch durch die ASP.NET-Konfiguration übernommen wird.

Abb. 9.1: Die Login-Seite

Express Edition

161

9 – Webseitenverwaltung

9.2 Skript pflegen und verwalten Doch allein mit der Erstellung der Login-Funktion ist es bei weitem noch nicht getan. Jede Seite, die verwaltet werden soll, muss zum einen ein LoginView-Element erhalten, sowie ein dementsprechendes Daten-Element. In diesem Fall wird das DetailsView-Element verwendet. Dieses unterstützt das Anzeigen, Bearbeiten, Einfügen und Löschen von Daten. Folglich die perfekte Lösung für die Administration. Selbstverständlich wird dieses, wie in Kapitel 6 beschrieben, in das LoggedIn-Template des LoginView-Elementes eingebaut. Listing 9.2: Das NewsAdmin-Skript <%@ Page Language="VB" MasterPageFile="~/MasterPage.master" AutoEventWireup="false" CodeFile="News.aspx.vb" Inherits="_News" title="Mona's World – News Admin" %>

<EditRowStyle BackColor="#008A8C" Font-Bold="True" ForeColor="White" />
162

Skript pflegen und verwalten Listing 9.2: Das NewsAdmin-Skript (Forts.) ForeColor="Black" /> <PagerStyle BackColor="#999999" ForeColor="Black" HorizontalAlign="Center" />
" SelectCommand="SELECT [datum], [name], [text], [id] FROM [News]" ConflictDetection="CompareAllValues" DeleteCommand="DELETE FROM [News] WHERE [id] = @original_id" InsertCommand="INSERT INTO [News] ([datum], [name], [text]) VALUES (@datum, @name, @text)" OldValuesParameterFormatString="original_{0}" UpdateCommand="UPDATE [News] SET [datum] = @datum, [name] = @name, [text] = @text WHERE [id] = @original_id ">

Express Edition

163

9 – Webseitenverwaltung Listing 9.2: Das NewsAdmin-Skript (Forts.) <span style="font-size: 24pt; color: #ff0000"> <strong>Zugriff verweigert.

Bitte einloggen.

Der Umbau der vorhandenen Seiten ist also nicht wirklich schwer und mit einfachen Mitteln kann ein umfangreicher Schutz gewährleistet werden. Die Vorgehensweise für die Administration der anderen Bereiche ist gleich.

164

Skript pflegen und verwalten

Abb. 9.2: Das fertige Administrations-Interface

Express Edition

165

10 Webservices Unter einem Webservice versteht man einen Dienst, der mit Hilfe von XML auf der Basis von Internet-Netzwerkprotokollen erbracht wird. Ein solcher WebDienst stellt eine Schnittstelle für einen Zugang zu einer Server-Anwendung zur Verfügung. Diese Schnittstelle ist allerdings nicht für den normalen Benutzer, sondern eher für Softwarekomponenten gedacht, die einen direkten Zugriff auf den Server benötigen. Eine solche Softwarekomponente, auch Client-Anwendung genannt, sendet im Allgemeinen Anfragen an einen Webservice und dieser liefert dann die gewünschte Information. Im Großen und Ganzen ist ein Webservice für Softwarekomponenten nichts anderes als eine Webseite für den Surfer, nur, dass beide ihre Informationen anders aufbereiten. Für den Besucher einer Webseite sind diese Informationen möglichst übersichtlich und durchdacht gestaltet, bei einem Webservice wird darauf allerdings verzichtet. Dieser soll einfach nur die Information im Klartext und ohne überflüssige Formatierung zur Verfügung stellen, sodass die Client-Anwendung die Informationen direkt verarbeiten und auswerten kann. Für die Realisierung der Webservice-Anwendungen wird das SOAP-Protokoll gewählt. Es ist unter Programmierern sehr beliebt und stand ursprünglich für Simple Object Access Protocol, ist allerdings auf Grund der gewachsenen Funktionalität nicht mehr einfach (simple) und ein eigenständiger Begriff geworden. Es ermöglicht so genannte Remote Procedure Calls (RPC), um Daten zwischen zwei Rechnern auszutauschen und entfernte Funktionen auf anderen Servern aufzurufen. SOAP basiert auf XML zur Aufbereitung der Daten und benutzt das HTTP-Protokoll zum Transport der Daten. Die Beschreibung des Webservices erfolgt, wie bereits erwähnt auf XML, genauer gesagt handelt es sich aber um eine eigenständige Programmiersprache: WSDL (Web Services Description Language). Die Vorteile dieser Beschreibungssprache liegen in der Plattform-, Programmiersprachen- und Protokollunabhängigkeit. Mittlerweile gibt es einige größere Webseiten-Betreiber, die eine solche Schnittstelle für Benutzer zur Verfügung stellen. Besonders bekannt sind der Suchmaschinenbetreiber Google, der Marktplatz Amazon sowie das Auktionshaus ebay. Dank der verwendeten Schnittstellen kann das Anbieter-Angebot problemlos abgefragt und ausgewertet werden. Express Edition

167

10 – Webservices

Auf einen Blick: 쐌 Webservice erstellen 쐌 Webservice einbinden

10.1 Ein eigener Webservice Getreu dem Motto „Erst servieren, dann konsumieren“ wird nun ein eigener Webservice realisiert. Zu Beginn wird der eigentliche Webservice und im Anschluss daran ein eigener Client, zum Abfragen des Webservices erstellt. Das Einbinden der SOAP-Funktionalität wird Dank des System.Web-, System.Web.Services- und System.Web.Services.Protocols-Namespaces stark vereinfacht. Bereits bei dem Erstellen eines neuen Projektes kann eine WebserviceAnwendung erstellt werden.

Abb. 10.1: Neuen Webservice erstellen

In dem erstellten Webservice sind bereits alle benötigten Namespaces eingebunden, sowie eine Beispiel-Funktion enthalten, die bei Aufruf über den späteren Webservice ein Hallo Welt zurückgibt. Anders als bei den bisher erstellten Projekten befindet sich der Code des Webservices nun in einem Unterordner (App_Code) und die Datei heißt Service.vb. 168

Ein eigener Webservice

In diese Datei werden alle Funktionen, die später über den Webservice abrufbar sein sollen, integriert. In der Hauptdatei Service.asmx steht eine einzige Anweisung: Die Definition des Webservices, woran sich auch nichts ändern wird. Listing 10.1: Die Hauptdatei Service.asmx <%@ WebService Language="vb" CodeBehind="~/App_Code/Service.vb" Class="Service" %>

In dem Quellcode werden ein paar Beispiel-Funktionen erstellt, um die Vorgehensweise zu verdeutlichen. Zum einen Funktionen, die nur einen Wert zurückgeben, zum anderen Funktionen mit Variablenübergabe und -rückgabe. Außerdem kann über einen Webservice auch eine Datenbankabfrage erstellt werden. Grundsätzlich ist alles zu realisieren, was mit einer .NET-kompatiblen Programmiersprache (z.B. Visual Basic .NET/Visual C# .NET) umsetzbar ist. Listing 10.2: Der Quellcode des Webservices 'Webservice-Namespaces einbinden Imports System.Web Imports System.Web.Services Imports System.Web.Services.Protocols 'System.Data.SqlClient-Namespace importieren Imports System.Data.SqlClient <WebService(Namespace:="MeinWebservice")> _ <WebServiceBinding( _ ConformsTo:=WsiProfiles.BasicProfile1_1)> _ _ Public Class Service Inherits System.Web.Services.WebService <WebMethod()> _ Public Function HalloWelt() As String 'Hallo Welt zurückgeben Return "Hallo Welt :)" End Function <WebMethod()> _

Express Edition

169

10 – Webservices Listing 10.2: Der Quellcode des Webservices (Forts.) Public Function ServerDatum() As Date 'Serverzeit zurückgeben Return Now() End Function <WebMethod()> _ Public Function Begruessung( _ ByVal strName As String) As String Dim strBegruessung As String 'Begrüßung generieren und zurückgeben strBegruessung = "Hallo " & strName & ". " strBegruessung &= "Wie geht es so?" Return strBegruessung End Function <WebMethod()> _ Public Function Addieren(ByVal intZahl1 As Integer, _ ByVal intZahl2 As Integer) As Integer Dim intErgebniss As Integer 'Beide Zahlen addieren und zurückgeben intErgebniss = intZahl1 + intZahl2 Return intErgebniss End Function <WebMethod()> _ Public Function Subtrahieren(ByVal intZahl1 As Integer, _ ByVal intZahl2 As Integer) As Integer Dim intErgebnis As Integer 'Beide Zahlen subtrahieren und zurückgeben intErgebnis = intZahl1 - intZahl2 Return intErgebnis End Function <WebMethod()> _ Public Function DatenbankAbfrage(ByVal strId As String, _

170

Ein eigener Webservice Listing 10.2: Der Quellcode des Webservices (Forts.) ByVal strFeld As String) As String Dim strWert As String = "Kein Wert vorhanden" 'SqlConnection-Klasse einbinden und definieren Dim dbConnection As New _ SqlConnection("SERVER=(local);" + _ "UID=Benutzername;" + _ "PWD=Passwort;" + _ "DATABASE=Webseite") 'SqlCommand-Klasse einbinden Dim dbCommand As SqlCommand 'SqlDataReader-Klasse einbinden Dim dbDataReader As SqlDataReader 'Verbindung zum Server für Kommentare aufbauen dbConnection.Open() 'Sql-Befehl definieren ... dbCommand = New SqlCommand("Select " & strFeld + _ " from Blog" + _ " Where id=" & strId, _ dbConnection) '... und die Datenbank abfragen. dbDataReader = dbCommand.ExecuteReader() 'Zurückgelieferte Daten einlesen... While dbDataReader.Read() '... und in die vorbereiteten Variablen einlesen. strWert = dbDataReader(0).ToString End While 'DataReader und Verbindung schließen dbDataReader.Close() dbConnection.Close() Return strWert End Function End Class

Express Edition

171

10 – Webservices

Zu Beginn wird dem Webservice ein expliziter Namespace zugewiesen. Jeder Webservice braucht einen eigenen und eindeutigen Namensraum. Dies kann ein Name sein oder aber auch die Internet-Adresse des Webservices. Im Gegensatz zu normalen Funktionen muss den Funktionen, die über den Webservice ansprechbar sind, ein <WebMethod()> vorangestellt werden. Natürlich sind auch interne Funktionen möglich, die nicht öffentlich zugänglich sind, dann muss eine normale Funktion ohne diesen Vorsatz erstellt werden. Wird nun der Webservice kompiliert und im Browser angezeigt, so kann er direkt auf seine Funktionsweise getestet werden. Außerdem werden alle Informationen zu den integrierten und angebotenen Funktionen übersichtlich dargestellt.

Abb. 10.2: Die Webservice-Beschreibung im Browser

172

Ein eigener Webservice

Nun ist serviert worden und der Konsum der bereitgestellten Daten kann beginnen. Die Oberfläche der Webseite zur Webservice-Kommunikation wird wieder mit ASP-Standardelementen realisiert. Listing 10.3: Die Webseite für die Webservice-Kommunikation <%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb" Inherits="_Default" %>

Express Edition

173

10 – Webservices Listing 10.3: Die Webseite für die Webservice-Kommunikation (Forts.) Style="position: absolute; top: 42px; left: 12px; background-color: transparent" Font-Names="Tahoma" Font-Bold="True" Font-Size="X-Small"> Name:



174

Ein eigener Webservice Listing 10.3: Die Webseite für die Webservice-Kommunikation (Forts.) Height="20px" Style="position: absolute; left: 12px; top: 21px" Font-Names="Tahoma" Font-Bold="True" Font-Size="X-Small" Text="Hallo Welt" />


Zahl1:             Zahl2:


Express Edition

175

10 – Webservices Listing 10.3: Die Webseite für die Webservice-Kommunikation (Forts.) Font-Size="X-Small">

176

Ein eigener Webservice Listing 10.3: Die Webseite für die Webservice-Kommunikation (Forts.) id:                        Feld:



Express Edition

177

10 – Webservices Listing 10.3: Die Webseite für die Webservice-Kommunikation (Forts.) background-color: transparent" Font-Names="Tahoma" Font-Bold="True" Font-Size="X-Small">

Nun wird zu Beginn der programmierte Webservice per Menü WEBSEITE | WEBVERWEIS HINZUFÜGEN … eingebunden. Die genaue Adresse hängt natürlich vom Projektnamen ab. In diesem Fall befindet sich der Webservice unter der Adresse http://localhost:2369/WebSite9/Service.asmx?WSDL. Indem man dem selbstprogrammierten Webservice den WSDL-Parameter anhängt, generiert dieser das benötigte XML bzw. WSDL-Objekt. Dieses wird zwingend für die Ansprechung des Webservices benötigt. Zu Beginn der Programmierung wird der Webservice deklariert und eingebunden. Je nachdem welcher Button auf der Oberfläche geklickt worden ist, wird die entsprechende Webservice Funktion aufgerufen. Benötigte Parameter können durch entsprechende Textfelder übergeben werden.

178

Ein eigener Webservice

Abb. 10.3: Webservice integrieren.

Die Rückgabe bzw. Antwort des Services wird dann in ein speziell präpariertes Textfeld ausgegeben. Listing 10.4: Der Quellcode zur Webservice-Kommunikation Partial Class _Default Inherits System.Web.UI.Page Dim wbsWebservice As _ MeinWebservice.Service = New MeinWebservice.Service Protected Sub btnHalloWelt_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnHalloWelt.Click txtAntwort.Text = "Webserviceantwort: " txtAntwort.Text &= wbsWebservice.HalloWelt End Sub

Express Edition

179

10 – Webservices Listing 10.4: Der Quellcode zur Webservice-Kommunikation (Forts.) Protected Sub btnServerDatum_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnServerDatum.Click txtAntwort.Text = "Webserviceantwort: " txtAntwort.Text &= wbsWebservice.ServerDatum End Sub Protected Sub btnBegruessung_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnBegruessung.Click txtAntwort.Text = "Webserviceantwort: " txtAntwort.Text &= wbsWebservice.Begruessung(txtName.Text) End Sub Protected Sub btnAddieren_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnAddieren.Click Dim intZahl1 As Integer = txtZahl1.Text Dim intZahl2 As Integer = txtZahl2.Text txtAntwort.Text = "Ergebniss Addieren von " txtAntwort.Text &= intZahl1 & " und " & intZahl2 & " = " txtAntwort.Text &= wbsWebservice.Addieren(intZahl1, _ intZahl2) End Sub Protected Sub btnSubtrahieren_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnSubtrahieren.Click Dim intZahl1 As Integer = txtZahl1.Text Dim intZahl2 As Integer = txtZahl2.Text

180

Ein eigener Webservice Listing 10.4: Der Quellcode zur Webservice-Kommunikation (Forts.) txtAntwort.Text = "Ergebniss Subtrahieren von " txtAntwort.Text &= intZahl1 & " und " & intZahl2 & " = " txtAntwort.Text &= wbsWebservice.Subtrahieren(intZahl1, _ intZahl2) End Sub Protected Sub btnDatenbankAbfrage_Click( _ ByVal sender As Object, _ ByVal e As System.EventArgs) _ Handles btnDatenbankAbfrage.Click Dim strId As String = txtId.Text Dim strFeld As String = txtFeld.Text txtAntwort.Text = "Rückgabe der Datenbank zu id " txtAntwort.Text &= strId & " und Feld " & strFeld & ": " txtAntwort.Text &= wbsWebservice.DatenbankAbfrage(strId, _ strFeld) End Sub End Class

Natürlich handelt es sich bei dem hier programmierten Webservice und der Beispielanwendung um eine sehr simple Anwendung. Grundsätzlich ist mit einem Webservice sehr viel mehr und vor allem enorm komplexeres möglich. Das hier dargestellte Beispiel soll nur den Zweck der Vorgehensweise und Veranschaulichung erfüllen.

Express Edition

181

10 – Webservices

Abb. 10.4: Die fertige Beispiel-Anwendung

182

A

Crashkurs „SQL“

Im Umgang mit Datenbanken ist das Thema SQL sehr wichtig, Kenntnisse also dringend erforderlich. In diesem Anhang werden sämtliche Basics kurz und prägnant erläutert, so dass einfache Datenbankanwendungen kein Problem darstellen. Auf einen Blick: 쐌 Was ist SQL? 쐌 Abfragearten (Auswahl- und Aktionsabfragen) 쐌 Auswahlabfragen 쐌 Vergleichsoperatoren 쐌 Aktionsabfragen

A.1 Was ist SQL? SQL steht für Structured Query Language, ist allerdings laut ANSI-Standard ein komplett eigenständiger Name. Es ist eine Art Programmiersprache mit einer relativ einfachen Syntax, um Abfragen auf Datenbank-Servern auszuführen. Dank ihr können Tabellen angelegt, editiert und gelöscht, sowie Datensätze eingefügt, bearbeitet und gelöscht werden. Die gängigsten Datenbanksysteme wie zum Beispiel Microsoft SQL Server, MySQL, PostgreSQL, Oracle und SQLite unterstützen diese Art von Abfragen. Viele Programmiersprachen bieten die hierfür benötigten Schnittstellen bereits im Lieferumfang und ermöglichen somit einen einfachen Zugang zu den oben aufgeführten Datenbanksystemen. Dank SQL sind Datenbankabfragen also nicht systembedingt und folglich eine Portierung auf ein neues Datenbanksystem seitens der Anwendung recht einfach zu realisieren.

A.2 Abfragearten Grundsätzlich unterscheidet man zwischen zwei Abfragearten: Auswahl(Select) und Aktionsabfragen (Insert, Update, Delete). Erstere Art dient lediglich der reinen Abfrage von Datensätzen, während die zweite Art das Einfügen, Bearbeiten und Löschen von Datensätzen ermöglicht.

Express Edition

183

A – Crashkurs „SQL“

A.2.1 Auswahlabfragen Allgemeine Syntax: SELECT [Feldname] FROM [Tabelle] {WHERE [Bedingung] ORDER BY [Feldname] [Optionen]};

Jede SQL-Klausel erfordert noch einen weiteren Parameter. Hinter SELECT muss der Feldname angegeben werden, der von der Datenbank eingelesen werden soll. Der Feldname ist der Name einer Spalte aus einer Tabelle. Allerdings können auch mehrere Feldnamen auf einmal eingelesen werden, indem diese als kommagetrennte Auflistung der SELECT-Klausel angehangen werden. Sollen alle Feldnamen aus der Tabelle zurückgeliefert werden, so kann anstelle eines oder mehrerer Feldnamen auch ein so genanntes Asterisk (Sternchen, *) als Platzhalter verwendet werden. Der FROM-Klausel muss der Name der Tabelle, von welcher die unter SELECT angegebenen Feldnamen eingelesen werden sollen, angehangen werden. Auch hier können mehrere Tabellen in einer kommagetrennten Auflistung übergeben werden, wenn in einer einzelnen Abfrage mehrere Felder verschiedener Tabellen abgefragt werden sollen. Allerdings müssen bei einer solchen Abfrage die Feldnamen hinter der SELECT-Klausel modifiziert werden, indem die jeweilige Tabelle mit einem Punkt dem Feldnamen vorangestellt wird (zum Beispiel „SELECT tabelle1.id, tabelle2.id FROM tabelle1, tabelle2 ...“) Die WHERE-Klausel ist optional. Sie gibt eine Bedingung an, nach welcher die Datensätze ausgelesen werden. Wird sie weggelassen werden alle Felder (definiert per SELECT-Klausel) eines Datensatzes zurückgeliefert. Dank dieser Bedingungsabfrage können zum Beispiel nur alle Felder ausgewählt werden, die in einem bestimmten Feld die Zeichenfolge (String) „Hallo“ enthalten. Die WHERE-Klausel unterstützt des Weiteren viele Operatoren zum Vergleichen von Bedingungen. Unterstützte Vergleichsoperatoren: 쐌 gleich (=) 쐌 ungleich (<>) 쐌 größer (>) 쐌 kleiner (<) 184

Abfragearten

쐌 größer-gleich (>=) 쐌 kleiner-gleich (<=) 쐌 BETWEEN [Wert1] AND [Wert2] 쐌 IN [Wert1], [Wert2], [Wert3], ... 쐌 LIKE [Zeichenfolge (String)] 쐌 IS NULL [Feldname] Mathematische Operatoren (nur für numerische Daten): 쐌 Addition (+) 쐌 Subtraktion (-) 쐌 Multiplikation (*) 쐌 Division (/) Erweiterte Operatoren: 쐌 AND 쐌 OR 쐌 NOT BETWEEN wird verwendet, um sämtliche Datensätze herauszufiltern, dessen Vergleichswerte explizit zwischen zwei vordefinierten Werten liegen. IN filtert lediglich die Datensätze heraus, die den Werten aus der nachgestellten Werteliste entsprechen. LIKE ist der beliebteste Operator, wenn es um Suchfunktionen geht. Er sucht sämtliche Datensätze heraus, die der angehangenen Zeichenfolge ähneln. Als Platzhalter wird bei den Vergleichsoperatoren ein Prozentzeichen (%) verwendet. Ein LIKE %mam% findet auch Datensätze mit Werten „Mammut“ oder „Mama“. Der optimale Operator für eine Suchfunktion also. IS NULL liefert nur die Datensätze zurück, die einen NULL-Wert aufweisen (also keine Daten enthalten). Mit den erweiterten Operatoren AND, OR und NOT können die Vergleichsoperatoren verknüpft werden (z.B. LIKE %ma% AND IS NULL text). Die mathematischen Operatoren können nur bei numerischen Daten angewendet werden. Bei den Auswahlbedingungen gibt es dann auch noch die ORDER BY-Klausel. Diese sortiert alle der Abfrage entsprechenden Datensätze nach einem oder mehreren Feldern. Wird kein weiterer Parameter übergeben, so erfolgt die Sortierung aufsteigend (ASC – ascending). Sollen die Datensätze absteigend sortiert werde, so muss als weiterer Parameter DESC (descending) übergeben werden.

Express Edition

185

A – Crashkurs „SQL“

Grundsätzlich müssen SQL-Anweisungen mit einem Semikolon enden. Listing A.1: Beispiele für SELECT-Anweisungen // Wählt alle Felder der Tabelle Webseite aus SELECT * FROM Webseite; // Wählt nur die Felder aus, dessen Feld text ein // 'lich' beinhaltet, z.B. herzlich, Licht SELECT * FROM Webseite WHERE text LIKE '%lich%'; // Wählt alle Felder der Tabelle Webseite aus, dessen Feld // id = 1 ist. SELECT name FROM Webseite WHERE id= '1'; // Wählt alle Felder der Tabelle Webseite aus und sortiert // diese absteigend nach dem Feld name SELECT * FROM Webseite ORDER BY name DESC; // Wählt alle Felder der Tabelle Webseite aus, wo im Feld // name ein 'about' oder 'home' vorkommt. SELECT name FROM Webseite WHERE name IN 'about', 'home';

A.2.2 Aktionsabfragen Allgemeine Syntax: Einfügen: INSERT INTO [Tabelle] ([Feld1], [Feld2],…) VALUES ([Wert1], [Wert2],…); oder: INSERT INTO [Tabelle] VALUES ([Wert1], [Wert2],…); Aktualisieren: UPDATE [Tabelle] SET [Feld1] = [Wert1], [Feld2] = [Wert2] WHERE [Bedingung]; Löschen: DELETE FROM [Tabelle] WHERE [Bedingung];

186

Abfragearten

Zum Anlegen bzw. Einfügen eines Datensatzes wird die INSERT INTO-Klausel verwendet. Ihr muss der Tabellenname angehängt werden, in welcher der Datensatz eingefügt werden soll, sowie Felder, die mit Daten gefüllt werden sollen. Mit der VALUES-Klausel werden dann die eigentlichen Daten eingetragen. Die Angabe der Felder, die mit Daten gefüllt werden sollen, ist optional. Allerdings muss die Reihenfolge der per VALUE angegebenen Werte dann mit der Tabellenstruktur übereinstimmen. Zum Aktualisieren eines Datensatzes dient die UPDATE-Klausel. Auch ihr wird wieder der Tabellenname angehangen, in welcher sich die zu verändernden Daten befinden. Mit der SET-Klausel erfolgt die eigentliche Veränderung der Datensätze und mit der WHERE-Klausel erfolgt auch hier wieder die Bedingung die festlegt, welche Datensätze aktualisiert werden sollen. Ein Datensatz wird mit der DELETE FROM-Klausel gelöscht. Als Anhang erwartet diese selbstverständlich auch wieder den Tabellennamen und zusätzlich eine WHERE-Klausel, mit welcher die Bedingung der zu löschenden Datensätze beschrieben wird. Listing A.2: Beispiele für Aktionsabfragen // Erstellt einen neuen Datensatz in der Tabelle Webseite. // Dabei werden nur die Felder name und text gefüllt. // Dies ist möglich, da die id automatisch generiert wird. INSERT INTO Webseite (name, text) VALUES ('Neu', 'Test'); // Erstellt einen neuen Datensatz in der Tabelle Webseite // und füllt den Datensatz der Reihe nach mit neuen Werten. INSERT INTO Webseite VALUES ('NULL', 'Neu', 'Test');

// Aktualisiert alle Datensätze der Tabelle Webseite, die // eine id = 1 aufweisen und setzt das Feld counter auf 10. UPDATE Webseite SET counter='10' WHERE id='1'; // Aktualisiert alle Datensätze der Tabelle Webseite, die // eine id = 2 aufweisen und setzt das Feld counter auf 10 // und das Feld aktiv auf 0. UPDATE Webseite SET counter='10', aktiv='0' WHERE id='2';

// Löscht alle Datensätze der Tabelle Webseite, dessen Feld

Express Edition

187

A – Crashkurs „SQL“ Listing A.2: Beispiele für Aktionsabfragen (Forts.) // counter größer oder gleich 99 ist. DELETE FROM Webseite WHERE counter>='99'; // Löscht alle Datensätze der Tabelle Webseite, dessen Feld // name den Inhalt 'home' aufweist. DELETE FROM Webseite WHERE name='Home';

Tipp Für SQL gibt es im Internet ein sehr gutes Referenz- und Nachschlagwerk. Das Beste an diesem Werk ist, dass es komplett Datenbanksystem-unabhängig ist. Auch hier lohnt sich in jeden Fall ein Blick. Link: http://www.sqlreference.de

188

B

Crashkurs „Visual Basic .NET“

Da ASP.NET-Seiten aus einer Kombination von HTML und Visual Basic .NET bestehen können, kann eine grobe Einführung in dieses Thema auch nur von Vorteil sein. Allerdings bleibt es bei der groben Einführung, die aber für Beispiele aus diesem Buch durchaus ausreichend sind. Auf einen Blick: 쐌 Was ist Visual Basic? 쐌 Variablen, Konstanten und Datentypen 쐌 Mathematische Operatoren 쐌 Abfragen und Vergleichsoperatoren 쐌 Schleifen 쐌 Funktionen und Klassen 쐌 Namensräume

B.1 Was ist Visual Basic? Visual Basic (oft als VB abgekürzt) ist eine Weiterentwicklung der Programmiersprache BASIC (Beginner's All-purpose Symbolic Instruction Code). Im Gegensatz zu BASIC, welches mit DOS eingeführt worden ist, ist Visual Basic auf sämtlichen Windows-Betriebssystemen lauffähig und wird seinem Namen mit einer einfach zu verwendenden Entwicklungsumgebung gerecht. Gerade bei Anfängern ist diese Programmiersprache sehr beliebt, da sie wirklich leicht zu erlernen ist und Erfolge folglich wesentlich schneller zu verzeichnen sind. Visual Basic .NET (VB.NET) bzw. Visual Basic 2005 (VB 2005), auch Visual Basic .NET2 genannt, sind auch wieder Weiterentwicklungen, die allerdings einen neuen, wesentlichen Vorteil bieten. Sie basieren auf dem so genannten .NET Framework, welches von allen .NET-Versionen sämtlicher Programmiersprachen verwendet werden kann (z.B. Visual C# .NET und Visual J# .NET) und einen hohen, unter Namensräumen einsortierten, Klassenumfang bietet. Damit sind von Grund auf sehr viele Anwendungen problemlos realisierbar. Visual Basic 2005 ist zu einer großen und umfangreichen Entwicklungsumgebung herangewachsen.

Express Edition

189

B – Crashkurs „Visual Basic .NET“

B.2 Variablen, Konstanten und Datentypen Variablen sind, wie in jeder anderen Programmiersprache auch, grundlegende Elemente. In diesen können Werte und Zustände zur Laufzeit hinterlegt und verändert werden, um diese auf Grund verschiedener Funktionen weiter zu verarbeiten. Variablen werden über ihren Namen angesprochen. Doch bei der Benutzung von Variablen gibt es verschiedene Restriktionen. So muss ein Variablenname mit einem Buchstaben anfangen und darf keine Leerund Sonderzeichen beinhalten. Auch zu Beachten ist, dass ein Variablenname nicht in Konflikt mit einem reservierten Schlüsselwort (z.B. Namen von Systemvariablen, Namensräumen oder Systemklassen) treten darf. Vor der Benutzung einer Variablen muss diese erstellt, also deklariert, werden. Dies geschieht mit der Dim-Funktion. Ihr muss auf jeden Fall der Variablenname angehangen werden, optional kann danach auch noch der Datentyp der Variable folgen. Mehrere Variable des gleichen Datentypes können auch per Komma getrennt aufgelistet werden. Listing B.1: Beispiele für die Variablendeklaration Dim Variable1 Dim Variable1, Variable2 Dim Variable1 As String Dim Variable1, Variable2 As String Dim Variable1 As Integer Dim Variable2 As Boolean Dim Variable1 As New Klasse1(…) Dim Variable2 As Funktion1

Wie bereits am Listing B.1 zu erkennen ist, gibt es verschiedene Datentypen. Ein Datentyp definiert eine Variable genauer. Es gibt eine Menge davon, die Wichtigsten im Zusammenhang mit den Beispielen sind Boolean, Short, Integer, Long, Single, Double, Decimal und String.

190

Variablen, Konstanten und Datentypen Datentyp

Größe in Bytes

Beschreibung

Boolean

1

Kann lediglich zwei Werte annehmen: 1 und 0 (True oder False – Ja oder Nein).

Short

2

Kleiner Integer-Typ, unterstützt nur ganze Zahlen.

Integer

4

Unterstützt nur ganze Zahlen.

Long

8

Großer Integer-Typ, unterstützt nur ganze Zahlen.

Single

4

Unterstützt Kommazahlen.

Double

8

Unterstützt Kommazahlen.

Decimal

12

Allrounder: Unterstützt ganze Zahlen und Kommazahlen mit bis zu 28 Nachkommastellen.

String

10 + doppelte Länge des Strings

Speichert Zeichenfolgen (Strings) mit einer beliebigen Länge.

Tabelle B.1: Übersicht Datentypen

Allerdings können einer Variablen auch so genannte Objekte (z.B. Klassen und Funktionen) zugewiesen werden. Diese sind dann über den Variablennamen ansprechbar. Gerade bei der objektorientierten Programmierung wird damit gearbeitet. Auch Funktionen können solche Datentypen zurückliefern. Neben Variablen gibt es auch Konstanten. Der Unterschied im Gegensatz zu Variablen liegt darin, dass Konstanten direkt bei der Deklarierung definiert werden und zur Laufzeit nicht mehr verändert werden können. Konstanten werden für statische Werte verwendet, wie zum Beispiel die berühmte Mehrwertsteuer. Für die Deklaration einer Konstanten wird die Const-Funktion verwendet. Konstanten können die gleichen Datentypen wie Variablen zugewiesen werden. Listing B.2: Beispiele für die Konstantendeklaration Const Mehrwertsteuer = 16 Const Mehrwertsteuer As Short = 16 Const Begruessung = "Hallo und Willkommen" Const Begruessung As String = "Hallo und Willkommen"

Express Edition

191

B – Crashkurs „Visual Basic .NET“

B.2.1 Arrays Arrays ähneln normalen Variablen, bieten aber einen entschiedenen Vorteil: Sie sind nicht auf einen einzigen Eintrag beschränkt. Ein Array kann im Groben auch mit einer Tabelle verglichen werden. Arrays werden ähnlich wie normale Variable deklariert und ihnen können sämtliche Datentypen, wie bei den Variablen, zugewiesen werden. Bei der Deklaration liegt der Unterschied zu Variablen in den runden Klammern ( ) hinter dem Arraynamen. Innerhalb dieser Klammern wird dann die Anzahl der zur Verfügung stehenden Felder eingetragen. Später während der Laufzeit wird innerhalb dieser Klammern das Feld festgelegt, das weiterverarbeitet werden soll. Neben den einfachen Arrays gibt es allerdings auch noch so genannte multidimensionale Arrays. Diese können beliebig viele Felder aufweisen, die auch wiederum mit Klammern festgelegt werden. Listing B.3: Beispiel für Arrays Dim Array1(2) As String Dim Array2(2)(1) As String Dim Variable1 As String Array1(0) = "Hallo" Array1(1) = "Willkommen" Array2(0)(0) = "Test1" Array2(1)(0) = "Test2" 'Weist Variable1 "Hallo und Willkommen" zu: Variable1 = Array1(0) & " und " & Array1(1) 'Weist Variable1 "Test1 und Test2" zu: Variable1 = Array2(0)(0) & " und " & Array2(1)(0)

B.2.2 Variablen und Übersichtlichkeit Um die Übersichtlichkeit bei der Verwendung von Variablen und Arrays zu steigern, ist es sinnvoll dem Variablennamen einen Vorsatz (Prefix) zu geben. Dieses Prefix dient dazu, auch in größeren Projekten direkt zu erkennen, um welchen Datentyp es sich bei der entsprechenden Variable handelt. 192

Mathematische Operatoren

Variablen vom Typ integer bekommen so den Prefix int, bei strings wird ein str vorangestellt. Aus der Variable Zahl wird so intZahl und aus Satz wird so strSatz. Einem Array kann zur direkten Erkennung ein ary vorangestellt werden: aryZahlenArray. Diese Vorgehensweise stellt keinesfalls einen festen Standard dar, ist aber sehr hilfreich. Auch gibt es keine genaue Definition für diese Prefixe. Das spielt auch keine Rolle, denn wichtig ist einzig und allein, dass der Programmierer den Überblick behält. Und es ist jedem selbst überlassen, ob und wie es realisiert wird.

B.3 Mathematische Operatoren Dank vieler mathematischer Operatoren können Variablen manipuliert werden. Additionen, Subtraktionen, Multiplikationen und Divisionen sind somit möglich. Auch Potenzierungen sind mit einem einzigen Operator durchführbar. Übersicht: 쐌 Addition (+) 쐌 Subtraktion (-) 쐌 Multiplikation (*) 쐌 Division (/) 쐌 Potenzierung (^) 쐌 Modulo (mod) Die ersten vier Operatoren implementieren die mathematischen Grundrechenarten in Visual Basic .NET. Zusätzlich gibt es noch einen Operator zum potenzieren und einen für die so genannte Modulo-Funktion. Mit dieser kann der Rest einer Division zweier Ganzzahlen ermittelt werden. Im Gegensatz zu den anderen Operatoren wird sie nicht durch ein Sonderzeichen beschrieben. Listing B.4: Beispiele für mathematische Operatoren Dim Wert1 As Integer = 3 Dim Wert2 As Integer = 4 Dim Wert3 As Decimal 'Addition Wert3 = Wert1+Wert2

Express Edition

'ergibt 7

193

B – Crashkurs „Visual Basic .NET“ Listing B.4: Beispiele für mathematische Operatoren (Forts.) 'Subtraktion Wert3 = Wert2–Wert1

'ergibt 1

'Multiplikation Wert3 = Wert1*Wert2

'ergibt 12

'Division Wert3 = Wert1/Wert2

'ergibt 0,75

'Potenzierung Wert3 = Wert1^Wert2

'ergibt 81

'Modulo Wert3 = Wert2 mod Wert1

'ergibt 1

Um nun Variablen direkt hochzurechnen, gibt es eine Vereinfachung. Bei dieser Vereinfachung wird den Standard-Operatoren einfach ein Gleichzeichen (=) vorangestellt. Dies hat in manchen Situationen einen entscheidenden Vorteil, der aus dem Listing B.5 deutlich wird. Listing B.5: Beispiele für mathematische Vereinfachungen Dim Wert1 As Integer = 3 'Addition Wert3 += 4

'ergibt 7

'Subtraktion Wert3 -= 2

'ergibt 1

'Multiplikation Wert3 *= 10

'ergibt 30

'Division Wert3 /= 3

'ergibt 1

'Potenzierung Wert3 ^= 3

'ergibt 27

194

Abfragen und Vergleichsoperatoren

B.4 Abfragen und Vergleichsoperatoren Um Bedingungen zu überprüfen, gibt es mehrere Möglichkeiten. Die bekannteste ist die If-Abfrage. Mit dieser können auch umfangreiche Bedingungen überprüft werden. Syntax: If [Bedingung] Then [Anweisung] {ElseIf [Bedingung] Then [Anweisung] … Else [Anweisung]}

Unter Bedingung kann entweder eine Variable oder Funktion vom Typ Boolean stehen, oder aber ein Abfragevergleich. Als Anweisung wird dann der Code verstanden, der ausgeführt werden soll, wenn die Variable oder Funktion true zurückliefert, oder aber der Abfragevergleich positiv ausfällt. Optional kann dann noch eine Else-Abfrage eingebaut werden. Werden mehrere Else-Abfragen benötigt, so müssen diese per ElseIf abgefragt werden. Die Anweisung nach der Else-Abfrage wird dann ausgeführt, wenn die Bedingung aus der If-Abfrage nicht zutrifft. Sofern als Bedingung ein Abfragevergleich durchgeführt werden soll, müssen Vergleichsoperatoren verwendet werden. Selbstverständlich können aber auch die bereits oben aufgeführten, mathematischen Operatoren hierfür verwendet werden. Vergleichsoperatoren: 쐌 Not (Nicht) 쐌 And (Und) 쐌 Or (Oder) 쐌 Xor (Exklusiv-Oder) 쐌 Gleich (=) 쐌 Ungleich (<>) 쐌 Größer (>) 쐌 Kleiner (<) 쐌 Größer-gleich (>=) 쐌 Kleiner-gleich (<=)

Express Edition

195

B – Crashkurs „Visual Basic .NET“

Vergleichsoperatoren werden im Übrigen auch als boolean’sche Operatoren bezeichnet. Der Not-Operator lässt die Anweisung nur dann wahr werden (true), wenn die Bedingung oder der Abfragevergleich nicht zutrifft. Der AndOperator vergleicht zwei Bedingungen oder Abfragevergleiche und lässt die Anweisung nur durchgehen, wenn beide positiv (true) sind. Der Or-Operator ähnelt dem And-Operator. Auch er vergleicht zwei Bedingungen oder Abfragevergleiche, liefert aber schon dann true zurück, wenn nur ein Fall zutrifft. Natürlich liefert er auch dann true zurück, wenn beide Fälle zustimmen. Anders als beim Xor-Operator. Dieser arbeitet ein wenig exklusiver und liefert nur dann true zurück, wenn wirklich beide Bedingungen oder Abfragevergleiche unterschiedliche Ergebnisse haben. Listing B.6: Beispiele für If-Abfragen Dim Variable1 As Boolean = False If Variable1 Then MsgBox("True") 'ist die gleiche Abfrage wie: If Variable1 = true Then MsgBox("True") If Variable1 AND Funktion1 Then MsgBox("True") If NOT Variable1 AND Funktion1 Then MsgBox("True") 'Erweiterte If-Abfrage mit Else: Dim Variable1 As Boolean = False If Variable1 Then MsgBox("True") Else MsgBox("False") 'Erweiterte If-Abfrage mit ElseIf: Dim Variable1 As Integer = 2 If Variable1 = 1 Then MsgBox("1") ElseIf Variable1 = 2 Then MsgBox("2") ElseIf Variable1 = 3 Then MsgBox("3") Else MsgBox("Undefiniert") 'If-Abfrage mit mathematischen Operatoren Dim Variable1 As Integer = 1 If Variable1 += 1 Then MsgBox("Ergebnis ist 2") ElseIf Variable1 -= 1 Then MsgBox("Ergebnis ist 0") Else MsgBox("Variable1 wahrscheinlich verändert.")

196

Abfragen und Vergleichsoperatoren

Bei Abfragen mit mehreren ElseIf-Abfragen ist es wesentlich komfortabler auf die Select-Case-Methode zurückzugreifen. Syntax: Select Case [Variable] Case [Wert] [Anweisung] … {Case Is [Wert] [Anweisung] … Case Is [Wert], Is [Wert] [Anweisung] … Case Else [Anweisung]} End Select

Bei dieser Art von Abfrage wird per Select-Case-Methode eine Variable eingelesen und die Select-Case-Anweisung initialisiert. Mit der folgenden CaseMethode wird die Variable auf einen Wert überprüft. Trifft diese Bedingung zu, so wird die folgende Anweisung ausgeführt. Andernfalls wird der nächste Fall, sofern vorhanden, überprüft. Es können beliebig viele Case-Methoden angewendet werden. Mindestens muss aber eine Abfrage durchgeführt werden. Zusätzlich gibt es noch die Case-Is-Methode. Mit dieser kann zum Beispiel ein mathematischer Operator integriert werden und die Variable auf das Ergebnis hin überprüft werden. Die Anweisung unter Case Else wird, wie bei der IfAbfrage, nur dann ausgeführt, wenn kein vorheriger Fall zutrifft. Listing B.7: Beispiele für eine Select-Case-Abfrage Dim Variable1 As Integer = 3 Select Case Variable1 Case 1 MsgBox("Variable1 hat den Wert 1.") Case 2 MsgBox("Variable1 hat den Wert 2.") Case 3 MsgBox("Variable1 hat den Wert 3.") Case 4

Express Edition

197

B – Crashkurs „Visual Basic .NET“ Listing B.7: Beispiele für eine Select-Case-Abfrage (Forts.) MsgBox("Variable1 hat den Wert Case Is <= 5 MsgBox("Der Wert von Variable1 Case Is >= 2, Is <=5 MsgBox("Der Wert von Variable1 Case Else MsgBox("Variable1 konnte nicht End Select

4.") ist kleiner als 5.") liegt zwischen 2 und 5.") ermittelt werden.")

B.5 Schleifen Schleifen gehören mitunter zu den wichtigsten Funktionen einer Programmiersprache. Sie erleichtern es beispielsweise enorm, ein Array mit mehreren Einträgen auszulesen oder zu füllen. Auch ein einfaches Hochzählen einer Zahl wird vereinfacht. Aber natürlich gibt es allgemein noch unzählige andere Anwendungsgebiete. Allgemeiner gesagt, dienen Schleifen der Vereinfachung wiederkehrender Befehlsfolgen und Anweisungen. Es gibt mehrere Arten von Schleifen: Die For...Next-Schleife und die Do...Loop-Schleife. Jede für sich hat spezielle Vorund Nachteile. Es kommt also immer auf den genauen Verwendungszweck an, wenn es um die Wahl einer Schleifen-Art geht.

B.5.1 Die For...Next-Schleife Syntax: For [Variable]=[Startwert] To [Endwert] {Step [Schrittweite]} [Anweisungen] Next [Variable]

Zu Beginn wird eine Variable vom Typ Integer mit einem Startwert initialisiert. Die Schleife wird dann bei diesem Wert starten und pro Durchgang die Anweisung ausführen und den Variablen-Wert um 1 erhöhen. Dieser Vorgang wird so oft wiederholt, bis der definierte Endwert erreicht ist und die Schleife durch diese Bedingung abgebrochen wird. Die Step-Anweisung ist optional. Wird sie weggelassen, wird pro Durchlauf die Variable um 1 hochgezählt. Mit ihr kann diese Definition aber umgangen werden und die Variable zum Beispiel pro Durchlauf um 2, 4, 0.1 oder sogar -1 (sofern der Startwert größer dem Endwert ist) erhöht bzw. heruntergesetzt werden. 198

Schleifen Listing B.8: Vereinfachung durch eine For...Next-Schleife Dim Variable1 As Integer = 0 Dim ZahlenArray(5) As Integer ZahlenArray(0) ZahlenArray(1) ZahlenArray(2) ZahlenArray(3) ZahlenArray(4)

= = = = =

1 4 7 9 2

'Umständlich: Variable1 += 1 MsgBox(Variable1) MsgBox(ZahlenArray(Variable1)) Variable1 += 1 MsgBox(Variable1) MsgBox(ZahlenArray(Variable1)) ...

'Gibt 1 aus. 'Gibt 4 aus. 'Gibt 2 aus. 'Gibt 7 aus.

'Vereinfacht: For Variable1 = 0 To 5 MsgBox(Variable1) MsgBox(ZahlenArray(Variable1)) Next Variable1

Eine For…Next-Schleife kann auch vorzeitig beendet werden. Dies ist zum Beispiel dann sinnvoll, wenn sämtliche Felder eines Arrays durchlaufen werden sollen, aber nur nach einem bestimmten Eintrag gesucht wird. Wird dieser gefunden, kann die Schleife abgebrochen werden. Dazu gibt es die Exit For-Anweisung. Listing B.9: Abbruch einer For...Next-Schleife Dim Variable1 As Integer = 0 Dim ZahlenArray(5) As Integer ZahlenArray(0) ZahlenArray(1) ZahlenArray(2) ZahlenArray(3) ZahlenArray(4)

= = = = =

Express Edition

1 4 7 9 2

199

B – Crashkurs „Visual Basic .NET“ Listing B.9: Abbruch einer For...Next-Schleife (Forts.) 'Vereinfacht: For Variable1 = 5 To 0 Step -1 MsgBox(ZahlenArray(Variable1)) 'Bricht den Durchlauf ab, wenn im Arrayfeld der Eintrag 7 'gefunden wird (ZahlenArray(2) – Also im 3. Durchlauf) If ZahlenArray(Variable1) = 7 Then Exit For Next Variable1

B.5.2 Die Do...Loop-Schleife Syntax: Typ 1: Do {While | Until} [Bedingung] [Anweisungen] Loop

Typ 2: Do [Anweisungen] Loop {While | Until} [Bedingung]

Die Do…Loop-Schleife ist wesentlich flexibler als die For…Next-Schleife. Sie zählt keinen Wert automatisiert hoch. Dafür kann allerdings der Endwert bzw. die Endbedingung genauer bestimmt werden. Dafür gibt es sogar zwei Varianten. Typ 1 prüft die Bedingung immer am Anfang eines neuen Durchlaufes, Typ 2 immer am Ende eines Durchlaufes. Auch kann bei dieser Schleifenart zwischen While und Until entschieden werden. Der Unterschied hierbei liegt darin, dass per While die Schleife so lange ausgeführt wird, bis die Bedingung nicht mehr wahr ist. Mit Until hingegen wird die Schleife direkt beendet, wenn die Bedingung wahr wird. Listing B.10: Beispiele für Do...Loop-Schleifen Dim Variable1 As Integer = 0 Do While Variable1 >= 5 MsgBox(Variable1)

200

Schleifen Listing B.10: Beispiele für Do...Loop-Schleifen (Forts.) Variable1 += 1 Loop Do Until Variable1 = 5 MsgBox(Variable1) Variable1 += 1 Loop

Do MsgBox(Variable1) Variable1 += 1 Loop While Variable1 >= 5 Do MsgBox(Variable1) Variable1 += 1 Loop Until Variable1 = 5

Natürlich gibt es auch für Do…Loop-Schleifen eine spezielle Anweisung, um die Schleife vorzeitig zu beenden: die Exit Do-Anweisung. Listing B.11: Abbruch einer Do...Loop-Schleife Dim Variable1 As Integer = 10 Do While Variable1 <= 1 MsgBox(Variable1) Variable1 -= 1 'Bricht den Durchlauf ab, wenn Variable1 den Wert 7 erreicht If Variable1 = 7 Then Exit Do Loop

B.5.3 Eine Entscheidungsfrage: For…Next oder Do…Loop? Zur Beantwortung dieser Frage gibt es kein allgemeingültiges Rezept. Es kommt immer auf den jeweiligen Verwendungszweck an. Ein einfaches Hochzählen wird natürlich am besten per For…Next durchgeführt. Diese Schleife

Express Edition

201

B – Crashkurs „Visual Basic .NET“

eignet sich auch hervorragend, wenn die Anzahl der Durchläufe bekannt ist. Für Schleifen mit komplexeren Bedingungen hingegen sollte Do…Loop vorgezogen werden. Ein weiteres Faktum für Do…Loop-Schleifen ist auch die größere Flexibiltät.

B.6 Funktionen und Klassen Funktionen dienen der Speicherung von wiederkehrenden Anweisungen. Sie enthalten Anweisungen, zum Beispiel zur Umwandlung eines Strings, die in einem Programm mehrmals verwendet werden müssen und können später vereinfacht als Funktion aufgerufen werden, ohne dass der komplette Code erneut eingegeben werden muss. Dies hat den Vorteil der Übersichtlichkeit, wie auch der Einfachheit, kann außerdem Zeit sparen und hält den Quellcode kleiner. Syntax: {Public|Private}Function [Name]({Variable1, …}) As [Datentyp] [Anweisungen] End Function

Eine Funktion kann als öffentlich (public) oder privat (private) festgelegt werden. Ist eine Funktion privat, so kann diese nur innerhalb der übergeordneten Klassen aufgerufen werden. Des Weiteren kann Ihr auch eine (oder mehrere) Variable übergeben werden, die für eine weitere Verarbeitung benötigt wird. Zusätzlich kann sie auch wieder eine Variable per Return-Anweisung zurückliefern. Listing B.12: Beispiel für Funktionen Public Function Ausgeben(ByVal strName As String) MsgBox(strName) End Function Public Function Ausgeben(ByVal strName As String) As String MsgBox(strName) Return strName End Function

Klassen, auch Objekte genannt, gruppieren mehrere Funktionen unter einem Klassennamen. Dies ist dann von Vorteil, wenn es zu einem Oberbegriff mehrere Funktionen gibt, die dann zu einem Objekt zusammengefasst werden. Ein 202

Funktionen und Klassen

Objekt mit mehreren Funktionen für Stringoperationen beinhaltet dann zum Beispiel Funktionen zur Umwandlung und Teilung eines Strings. Klassen und Funktionen stellen unter anderem die Basis der objektorientierten Programmierung dar. Unter der objektorientierten Programmierung (OOP) wird ein Verfahren zur Strukturierung von Computerprogrammen verstanden. Dabei werden zusammengehörige Daten und Anweisungen zu so genannten Objekten gruppiert – Dank dem Klassen- und Funktionsprinzip. Syntax: Class [Name] [Funktionen/Subroutinen] End Class

In eine Klasse werden dann Funktionen und/oder Subroutinen hinterlegt, die über diese Klasse verwendet werden können. Um eine Klasse verwenden zu können, wird sie lediglich einer Variablen zugewiesen und als neues Objekt definiert. Listing B.13: Beispiel für eine Klasse Class Beispiel Public Function Ausgeben(ByVal strName As String) As String MsgBox(strName) Return strName End Function Sub AusgebenSub(ByVal strName As String) MsgBox(strName) End Sub End Class

Einbinden: Dim objBeispiel As New Beispiel() Dim strName As String() strName = objBeispiel.Ausgeben("MeinName") objBeispiel.AusgebenSub("MeinName")

Express Edition

203

B – Crashkurs „Visual Basic .NET“

B.7 Namensräume Namensräume (Namespaces) spielen bei der Arbeit mit dem .NET Framework eine große Rolle. Im Groben kann darunter eine Art Ordnerstruktur verstanden werden, in welcher viele Klassen und Funktionen einsortiert sind. Anders gesagt, beschreibt ein Name ein Objekt (eine Klasse) und wird für eine eindeutige Zuordnung in den entsprechenden Namensraum einsortiert. Namensräume ersparen im Vorfeld viel Arbeit, da es zum Beispiel bereits Klassen für die Arbeit mit Dateien im Dateisystem oder auf FTP-Servern und Datenbanken bietet. Klassen für die Arbeit mit Datenbanken sind beispielsweise im System.DataNamensraum enthalten. So wird umgehend der Kontext ersichtlich und andersrum wird man beim Thema Datenbanken schneller fündig, da alle Klassen quasi ordentlich einsortiert sind. Natürlich können eigene Klassen auch in eigenen Namespaces verwaltet werden.

B.8 Kommentare Kommentare sind Informationen im Quelltext, die lediglich der Übersichtlichkeit dienen und bei der Interpretation vom Compiler ignoriert werden. Diese sind vor allem bei Projekten mit mehreren Mitarbeitern von hoher Priorität, damit auch anderen Programmierern umgehend ersichtlich ist, was bereits implementiert ist und welche Aufgaben durch verschiedene Code-Teile durchgeführt werden. Aber natürlich dienen sie auch der Übersichtlichkeit eigener Projekte, um sich schneller zu Recht zu finden. Kommentaren wird ein Anführungszeichen vorangestellt. Auch können so ganze Code-Teile auskommentiert werden, um zum Beispiel auf Fehlersuche zu gehen oder um bei Neuerungen nicht direkt löschen zu müssen und die Neuerungen erst einmal gründlich zu testen. Listing B.14: Kommentare 'Dies ist ein Kommentar ;) 'Natürlich können auch Codeteile auskommentiert werden: 'MsgBox("Test") 'Diese werden dann ignoriert, als wären sie nonexistent.

204

Fehlerbehandlung

B.9 Fehlerbehandlung Um schwere Ausnahmefehler zu vermeiden, ist es wichtig, Fehler abzufangen. Diese können dann zum Beispiel direkt per Mail dem Webmaster gemeldet werden oder lediglich als MsgBox ausgegeben werden. Für den Abfang von Fehlern gibt es so genannte Try … Catch-Anweisungen. Syntax: Try [Anweisungen] Catch ex As Exception [Anweisungen nach Fehlern] End Try

Die normalen Anweisungen, die ausgeführt werden sollen, werden in den Try … Catch-Block gestellt. Mit Catch wird der Fehler, der in diesem Block auftritt, abgefangen und als Ausnahmefehler (Exception) eingelesen. Im Anschluss daran kann eine Anweisung erfolgen, die der Fehlerbeschreibung oder -meldung dient. Diese Anweisung wird nur dann ausgeführt, wenn ein Fehler auftritt. Mit End Try wird die Fehlerbehandlung beendet. Listing B.15: Fehlerbehandlung Try Dim ZahlenArray(1) As Integer 'Führt zu einem Fehler, da es die Größe des 'Arrays sprengt. ZahlenArray(0) = 1 ZahlenArray(1) = 4 ZahlenArray(2) = 7 Catch ex As Exception 'Tritt ein Fehler auf, wird dieser ausgegeben. MsgBox(ex.Message, MsgBoxStyle.OkOnly, "Fehler!") End Try

Express Edition

205

B – Crashkurs „Visual Basic .NET“

Tipp Mehr und ausführlichere Informationen zu diesem Thema sind auch in Form eines Buches derselbigen Reihe zu finden. Visual Basic 2005 Express Edition (Karsten Samaschke und Christian Hoofe) ISBN: 3-935042-84-1

206

Index .ascx Datei 30 .NET Framework 23, 24 A Active Server Pages 24 Administration 101 Administrationsinterface 101 Administrationsoberfläche 159 anlegen 159 schützen 162 Aktualisierungen 12 AND-Klausel 185 André Wussow 14 Anmelden 22 Anwendungsbeispiele 117 App_Browsers-Ordner 29 App_Code-Ordner 28, 168 App_Data-Ordner 28, 32, 53 App_GlobalResources-Ordner 29 App_LocalResources-Ordner 29, 95 App_Themes-Ordner 29, 87 App_WebReferences-Ordner 29 ASP 24 ASP.NET 24 ASP.NET Konfiguration 29, 101 ASP.NET-Ordner 28 ASP.NET-Projekt 28 ASP-Datei einfach 25 ASP-Directive 24, 97 ASP-Seite erweitert 26 Assembly 30 Aufbau ASP.NET-Seite 24 Ausdruck-Editor 97 Authentication Mode 104 Authentifizierung 29, 105 Authorisierung 29

Express Edition

AutoEventWireup-Parameter 25 Autor 14 Auto-Vervollständigung 23 B Beispielanwendungen 9 Benutzerauthentifizierung 159 Benutzerdefinierte Websteuerelemente 30 Benutzerverwaltung 101 Benutzterkonto 101 Rollen 102, 105 Zugriffsgruppen 102 Zugriffsregel 102 Besucherstatistik 149 Besucherzähler 148 BETWEEN-Klausel 185 Bin-Ordner 29 Blog 128 Browserdatei 43 Buch-CD 12 Buchinhalt 11 Bug 107 C C# 25 Caching 29 Cascading Style Sheets 90 Classkey-Eigenschaft 97 Client-Anwendung 167 CLR 23 CLR-Unterstützung 62 Codebehind-Parameter 25 Code-Editor 10 Codetrennung 26 Common Language Runtime 23

207

Index Connectionstring 68, 74 Container 32 Content-Element 49 ContentPlaceHolder-Element 45, 49 Contentseite 51 Cookies 29 Counter 148 Crashkurs SQL 183 Visual Basic .NET 189 CreateUserWizard-Element 105 CSS 90 CSS-Datei 88 Culture-Parameter 97 D Danksagungen 13 DataBinder-Methode 120 DataList-Element 71 DataSet 42 Date-Funktion 150 Dateiendung 25 Daten 22 Datenbank -Ansicht 57, 62, 64 -Datei 53 einbinden 64 einbinden (per Control) 64 einbinden (per Quellcode) 72 einrichten 55 -Explorer 23 -gespeicherte Prozedur 60, 62, 64 -Tabelle 64 -Trigger 62 -Verbindung aufbauen 62 Datenbankabfragen beschleunigen 57 reduzieren 57 Datenbankaktionen zusammenfassen 60 Datenbanklösung dateibasiert 53 208

Daten-Provider 72 Datenquelle 53 Datenquellen-Treiber 63 Datetime-Datentyp 130 Debugging 107 Default.aspx 32 DELETE FROM-Klausel 187 Delete-Klausel 71 Designdatei 43, 89 Designvorlage erstellen 87 verwenden 93 Designvorlagen 87 DestinationPageUrl-Parameter 105 DetailsView-Element 71 Dim-Funktion 190 Div-Element 32, 35 DropDown-Element 72 E E-Books 19 Editor 22 Eigenschaften-Fenster 23 Einführung 17 Element hinzufügen 44, 49 E-Mail-Anwendung 143 entwickler.press 13 Entwurfsmodus 22 Error-Handling 107, 111 Erscheinungsbild 23 Erweiterte Operatoren 185 Explorer 23 F Fehlerbehandlung 205 Fehlerbereinigung 107 Fehlerseiten 112 Fehlerteufel 15 Formatierungssprache 90 Formatvorlagen 35 Formularüberprüfung 146

Index FormView-Element 71, 124 Forum 12 Fotogalerie 136 FROM-Klausel 184

J J# .NET 21 JS 25 JSkript-Datei 42

G Galerie 136 Gästebuch 122 Generische Handler 43 Gestaltung 41 GETDATE-Funktion 130 Globale Anwendungsklasse 42 GridView 65 Grundlagen 23

K Kalender-Element 88 Kapitel 1 17 Klasse 43 Klassenbibliothek 24 Kommentare 204 Konfiguration 17, 104 Konfiguration der Datenquelle 67 Konfigurations-Assistent 68 Konfigurationsdatei 29 Debugging aktivieren 108 Fehlerseiten definieren 116 für mobile Webanwendungen 43 Konfigurationsprogramm 29 Kontakt 14 Kontaktformular 148 Korrekturen 14

H Handles-Methode 25 HTML 22 -Editor 22 -Element - Gruppierung 32 -Inhalt darstellen 90 -Seite 42 -Serversteuerelement 31 I Identifizierungs-ID 23 Identitätsspezifikation 56 IIdentity-Funktion 105 Informationen 14 Inhaltsseiten 41, 48 Inherits-Parameter 25 IN-Klausel 185 INSERT INTO-Klausel 187 Insert-Klausel 71 Installation 17 Installationsprogramm 17 IntelliSense 23 Internet Explorer 39 Ip-Adresse 122, 126 IS NULL-Klausel 185 IsAuthenticated-Funktion 105

Express Edition

L Landesspezifisch 95 Language-Parameter 25 Laufzeitsystem 23 LIKE-Klausel 185 Live-Version 12 Login-Element 103, 104, 159 LoginView-Element 105 Lokalisierung 87, 95 M MailMessage-Klasse 145 MasterPage.master 49 Masterseiten 41, 42, 43 verschachteln 48 Mathematische Operatoren 185 Menü 21 Menü-Element 79

209

Index Menüelement-Editor 34, 80 Microsoft Intermediate Language 23 Microsoft SQL Server 183 Microsoft SQL Server 2005 Express 61 Microsoft SQL Server Desktop Engine 61 Mobiles Web Form 42 Mobiles Web-Benutzersteuerelement 42 Month-Funktion 150 MSDE 61 MSDE-Datenbank 61 MSDN 18 MSDN-Newsflash 18 MSIL 23 Multilangual 95 MySQL 183 N Namensräume 204 NavigateUrl-Eigenschaft 35, 80 Navigation 22, 79 Newsskript 117 NOT-Klausel 185 O Objektorientierte Programmierung 203 Onlinetagebuch 128 OOP 203 Operatoren 184, 185 Oracle 183 ORDERBY-Klausel 185 OR-Klausel 185 P Page_Load-Ereignis 25 PasswordRecovery-Element 105 Performance 130 PostgreSQL 183 Programmcodetrennung 26 Programmiersprachenwahl 24

210

Programmoberfläche 21 Projekt 28 Projektmappen-Explorer 23 Provider 63, 72 Q Quellcode-Editor 23 Quellcodes 14 Quellmodus 23 Query 73 Query-Response 73 QueryString-Funktion 115 R Redirect-Funktion 135 Registrierung 19 Remote Procedure Calls 167 Repeater-Element 71, 118, 122 Request-Objekt 115 Request-Variablen 126 ResourceKey-Eigenschaft 97 Response-Klasse 135 Ressource 96 Ressource – Zeichenfolgen 96 Ressourcendatei 43, 95, 96 RPC 167 S Seiten schützen 104 Seitentitel 38 Seitenumleitung 135 Select-Case-Anweisung 130 Select-Klausel 71, 184 Serversteuerelemente 30 Sessions 29 SET-Klausel 187 Setup-Programm 17 Sicherheit 101 Simple Object Access Protocol 167 Sitemap 42, 81 SiteMapDataSource-Element 84, 85 SiteMapNode-Tag 83

Index Siteübersicht 42, 79 Siteübersicht-Datei 81, 84 SkinId-Parameter 89 SmtpClient-Klasse 145 Smtp-Server 145 SOAP-Funktionalität 168 SOAP-Protokoll 167 Spam vermeiden 143 Speicherort 20 Sprachumstellung 99 SQL 69 -Abfrage 72 Abfragearten 183 Aktionsabfragen 183, 186 AND-Klausel 185 Auswahlabfragen 183, 184 BETWEEN-Klausel 185 -Crashkurs 183 -Datenbank 42 Definition 183 DELETE FROM-Klausel 187 Erweiterte Operatoren 185 FROM-Klausel 184 IN-Klausel 185 INSERT INTO-Klausel 187 IS NULL-Klausel 185 -Klausel 184 LIKE-Klausel 185 Mathematische Operatoren 185 NOT-Klausel 185 ORDER BY-Klausel 185 OR-Klausel 185 SELECT-Klausel 184 SET-Klausel 187 UPDATE-Klausel 187 VALUES-Klausel 187 Vergleichsoperatoren 184 WHERE-Klausel 184, 187 SQL Server 2005 Express 61 SQL Server Express Manager 62 Express Edition

SqlCommand-Klasse 72, 73, 74 SqlConnection-Klasse 72, 73 SqlDataReader-Klasse 72, 73, 74 SqlDataSource 65 SqlDataSource-Element 118, 122 SQLite 183 Startbildschirm 19 Starter Kits 9 StaticDisplayLevels-Eigenschaft 85 Statistikfunktion 153 Steuerelemente 71 Stil-Generator 32 Structured Query Language 183 Stylesheet 42, 90 Stylesheet-Datei 90 Support 12 Syntax-Highlighting 23 System.Data.SqlClient-Namespace 72, 73 System.Date-Namespace 150 System.NET.Mail-Namespace 145, 148 System.Security.PrincipalNamespace 105 System.Web.Services.ProtocolsNamespace 168 System.Web.Services-Namespace 168 System.Web-Namespace 168 Systemvoraussetzungen 10 T Tabellen verlinken 57 Tabellen zusammengefasst 57 TechEd-Konferenz 9 Testen 24 Textdatei 42 Themes 87 Toolbox 22 Toolbox-Gruppen 22 Toolbox-Inhalt 22 TreeView-Element 85

211

Index U UICulture-Parameter 97 Unterstützung 12 UPDATE-Klausel 187 Update-Klausel 71 UserHostAddress-Funktion 126 V Validierung 22 VALUES-Klausel 187 VB 25 VB.NET 189 VBSkript 43 Verbindungszeichenfolge 68, 74 Vergleichsoperatoren 184 Verlinkung 35, 80 Visual Basic 189 Visual Basic .NET 21, 189 Abfragen 195 Abfragevergleich 195 And-Operator 196 Arrays 192 Bedingung 195 Case-Else-Methode 197 Case-Is-Methode 197 Case-Methode 197 Catch-Anweisung 205 -Crashkurs 189 Datentyp Boolean 190 Datentyp Decimal 190 Datentyp Double 190 Datentyp Integer 190 Datentyp Long 190 Datentyp Short 190 Datentyp Single 190 Datentyp String 190 Datentypen 190 Do...Loop-Schleife 198, 200

212

Do...Loop-Schleife abbrechen 201 Do...Loop-Schleife Until 200 Do...Loop-Schleife While 200 Else-Abfrage 195 ElseIf-Abfrage 195 End Try-Anweisung 205 Exit Do-Anweisung 201 Exit For-Anweisung 199 For...Next-Schleife 198 For...Next-Schleife abbrechen 199 Funktionen 202 If-Abfrage 195 Klassen 202 Konstanten 190 Mathematische Operatoren 193 Namensräume 204 Namespaces 204 Objekte 202 Objektorientierte Programmierung 203 Or-Operator 196 Return-Anweisung 202 Schleifen 198 Select-Case-Methode 197 Step-Anweisung 198 Try … Catch-Anweisung 205 Variablen 190, 192 Variablenmanipulation 193 Variablenprefixe 192 Vergleichsoperatoren 195 Xor-Operator 196 Visual Basic .NET Not-Operator 196 Visual Basic 2005 189 Visual C# .NET 21 Visual Web Developer Express 10 Vorlagen 41, 42

Index W Web Form hinzufügen 49 Web Logbuch 128 Web Services Description Language 167 web.config 29, 32, 93, 104 compilation-Abschnitt 108 debug-Parameter 108 customErrors-Abschnitt 116 defaultRedirect-Parameter 116 error-Tag 116 mode-Parameter 116 redirect-Parameter 116 statusCode-Parameter 116 web.config – pages-Eintrag 51, 94 Webanwendungen 117 Web-Benutzersteuerelemente 30, 43 Webcontrols 30 Webdienst 42 Web Form 42 Webkonfigurationsdatei 43 Weblog 128 WebParts 22 Webseite 12 Webseite kopieren 157 Webseitenadministration 101, 159 Webseitenelement-Vorlagen 42 Webseiten-Kopier-Tool 157 Webseiten-Transfer 157

Express Edition

Webseitenverwaltung 159 Webserversteuerelement 31 Webservice 167, 181 -Definition 169 WebMethod() 172 erstellen 168 Werkzeugleiste 22 What you see is what you get 22 WHERE-Klausel 184, 187 WSDL 167 -Objekt 178 -Parameter 178 Wussow 14 WYSIWYG-Funktion 22 X XML 167 -Datei 42, 81, 83 -Unterstützung 62 XSLT-Datei 42 Y Year-Funktion 150 Z Zielgruppe 12 Zugriffsschutz 101 Zuletzt geöffnete Projekte 19 Zusätze zum Buch 12

213