ASP.NET

Werbung
ASP.NET
Eine kurze Praxis-Einführung
Von Markus Nienierza
Angefertigt im Rahmen des Seminars:
Komponentenorientierte Softwareentwicklung / Hypermedia
bei Prof. Dr. Frank Thiesing
Vorgetragen an der Fachhochschule Dortmund am 08.06.2004
1
Inhaltsverzeichnis
DIE THEORIE............................................................................................................. 3
ASP.NET, was ist das eigentlich? ........................................................................................................................ 3
Programmiersprache........................................................................................................................................... 3
Performance ....................................................................................................................................................... 3
.NET Framework................................................................................................................................................ 3
Common Language Runtime.............................................................................................................................. 3
.NET Framework Klassenbibliothek .................................................................................................................. 4
Die Architektur von ASP.NET........................................................................................................................... 4
DIE PRAXIS ............................................................................................................... 5
.NET Framework .................................................................................................................................................. 5
Installation.......................................................................................................................................................... 5
Internet Information Server................................................................................................................................. 5
Microsoft SQL Server........................................................................................................................................... 5
Neuen Benutzer anlegen..................................................................................................................................... 5
WebMatrix............................................................................................................................................................. 7
Installation.......................................................................................................................................................... 7
WebMatrix Hauptansicht ................................................................................................................................... 7
Erstellen einer einfachen ASP.NET Seite............................................................................................................ 8
.aspx Dateien erstellen........................................................................................................................................ 8
Steuerelemente hinzufügen .............................................................................................................................. 10
Die „Hallo Welt“ Anwendung ......................................................................................................................... 10
Addition zweier Zahlen .................................................................................................................................... 11
Erstellen einer ASP.NET Seite mit Datenbankanbindung .............................................................................. 12
Erstellung einer ASP.NET Seite mit Datenbank INSERT ............................................................................... 12
Erstellen einer Datenbank und Datenbankverbindung ..................................................................................... 13
Erstellung einer ASP.NET Seite mit Datenansicht........................................................................................... 15
Erstellen eines einfachen Webservices .............................................................................................................. 16
Anlegen einer .asmx Datei ............................................................................................................................... 16
Hinzufügen eigener WebService-Methoden .................................................................................................... 17
Testen eines Webservices................................................................................................................................. 18
Webservice konsumieren.................................................................................................................................... 21
Erstellen eines Webservice-Proxy.................................................................................................................... 21
Einbinden einer Proxy-Klasse .......................................................................................................................... 22
ANHANG.................................................................................................................. 23
Typische Fehlerquellen....................................................................................................................................... 23
Fehler in der Wiedergabe der Seiten ................................................................................................................ 23
Zur Laufzeit keine Verbindung mit der SQL Datenbank ................................................................................. 23
Verwendete Werkzeuge / Software.................................................................................................................... 24
Literaturverzeichnis / Quellenangabe ............................................................................................................... 24
2
Die Theorie
ASP.NET, was ist das eigentlich?
Fangen wir mit ASP an. ASP bedeutet Active Server Pages, was soviel bedeutet, wie Aktive
Serverseitig ausgeführte Internetseiten. Und was ist jetzt Aktiv? Aktiv ist die Erstellung des
Html-Dokuments, das an den Client weitergeleitet wird. Die Html-Nachricht wird erst zum
Zeitpunkt der Anfrage des Client aus bestimmten Elementen „zusammengebaut“. Damit ist
der Server in der Lage auf spezifische Anfragen des Client unterschiedlich zu antworten. Man
könnte sich eine Anwendung denken, die zwei Zahlen vom Client erhält, sie „on the fly“
addiert und dann zum Client zurückschickt.
Im Gegenzug bestehen einfache Websites aus statischem Html. Hier ist (außer den
Hyperlinks) keine Interaktion mit dem Benutzer vorhanden.
Und .NET (sprich: „ Dot Net“), was ist dass? .NET ist eine neue von Microsoft eingeführte
Technologie-Familie. Das Hauptelement von .NET ist das .NET Framework. Das .NET
Framework ist eine große Klassenbibliothek, die dem Softwareentwickler eine Vielzahl von
Klassen bereitstellt, die dem Entwickler Programmierarbeit abnimmt und für standardisierte
Lösungen sorgt.
Programmiersprache
ASP.NET Seiten können in allen gängigen .NET Sprachen geschrieben werden. In C#,
VB.NET, aber auch in J#, PHP.NET und Corba.NET. Aus diesen verschiedenen
Programmiersprachen wird ein Zwischencode erzeugt, der in der Intermediate Language (IL)
vorliegt.
Performance
ASP.NET bietet gegenüber klassischem ASP einen deutlichen Performancegewinn. Das liegt
daran, dass der Quellcode nicht nur interpretiert, sondern kompiliert und ausgeführt wird.
.NET Framework
Das .NET Framework besteht aus zwei Hauptkomponenten, der Common Language Runtime
und der .NET Framework Klassenbibliothek.
Common Language Runtime
Die Common Language Runtime (CLR) bietet für alle .NET Sprachen, die von den
Sprachenspezifischen Sprachcompilern in die IL überführt wurden, die Laufzeitumgebung.
Die IL wird von der CLR spätestens bei der ersten Ausführung in Binärcode konvertiert, der
ausgeführt werden kann.
3
.NET Framework Klassenbibliothek
Die .NET Framework Klassenbibliothek ist dafür ausgelegt, den Entwicklungsaufwand zu
minimieren, indem Basisklassen zur Verfügung gestellt werden, auf denen die Entwickler
aufbauen können. Es handelt sich dabei um einen hierarchischen Satz von .NET Klassen, die
Entwickler in Ihren eigenen Anwendungen nutzen können. Diese Klassen ermöglichen
sowohl eine Grund- als auch eine weiterführende Funktionalität. Diese Klassen, die in
Containern, so genannten Namensräumen (Namespaces) organisiert sind, bieten sowohl
Basisfunktionen als auch fortgeschrittenere Funktionalitäten, die durch den Entwickler leicht
wieder verwendet werden können. Darin enthalten sind Klassen, die die grundlegenden
Datentypen unterstützen, Klassen, die einen Zugriff auf Daten ermöglichen, und Klassen, die
Systemdienste wie Zeichnen oder Netzwerkfunktionen zur Verfügung stellen, sowie viele
andere. Diese Bibliothek enthält auch diejenigen Klassen, die die Grundlage für ASP.NET
bilden. Hauptsächlich die Klasse „Page“, die im Namensraum System.Web.UI zu finden ist.
Die Architektur von ASP.NET
Fragt ein Besucher Ihrer Webseite ein ASP.NET Dokument an, so wird diese Anfrage an eine
ISAPI-Erweiterung des Webservers weitergeleitet. Diese Erweiterung des Webservers
überprüft dann, ob der in der angefragten Seite enthaltenen ASP.NET Code bereits von einem
anderen Benutzer aufgerufen wurde. Hat sich der Quellcode der ASP.NET Seite im Vergleich
zum letzten Aufruf nicht verändert, so ist die bereits in der IL vorkompilierte Version des
Dokumentes noch aktuell, und sie kann erneut verwendet werden. Diese Vorgehensweise
stellt sicher, dass auf der einen Seite immer nur der aktuellste Quellcode zur Ausführung
kommt, auf der anderen Seite aber keine überflüssigen Kompilierungsvorgänge gestartet
werden. Ist der Quellcode im angeforderten Dokument nämlich nicht mit dem des letzten
Aufrufs identisch, so wird das Dokument in die IL vorkompiliert und die oder verfügbare alte
Version dieses Dokuments überschrieben. Die nun im Speicher vorhandene Version des
Dokumentes wird nun über den Just-In-Time (JIT) Compiler ausgeführt und das Ergebnis
dieses Vorganges an den Besucher der Seite zurückgesendet.
4
Die Praxis
Will man Internetseiten erstellen, so braucht man dazu eigentlich nur einen Texteditor. Will
man die Seiten im Internet veröffentlichen, so benötigt man noch einen Server. Um ASP.NET
Seiten zu veröffentlichen, so muss auf dem Server unbedingt die .NET Laufzeitumgebung
installiert sein, die die Umsetzung der .aspx Dateien vornimmt. Die Installation des Microsoft
Information Servers (IIS) sollte vor der Installation des .NET Frameworks geschehen, da das
.NET Framework sonnst nicht weis, dass es die .aspx Dateien, die Innerhalb der Virtuellen
Unterverzeichnisse des IIS liegen ausführen soll.
.NET Framework
Installation
Die Installation des .NET Frameworks geht ganz einfach. Das .NET Framework ist bei
Windows XP ganz einfach über Windows Update von Microsoft herunter zuladen.
Internet Information Server
Bei Windows 2000 und Windows XP ist der Internet Information Server (IIS) bereits
enthalten. Der IIS muss nur unter Systemsteuerung -> Software -> Windows Komponenten
ausgewählt werden. Evtl. wird die Windows Installations-CD noch mal benötigt. Installiert
man den IIS nach dem .NET Framework, so ist dem .NET Framework noch mitzuteilen, dass
es für die Ausführung der .aspx Dateien verantwortlich ist. Dazu führt man das Programm
aspnet_regiis.exe aus:
Auf der Befehlszeile:
„C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\aspnet_regiis.exe –i”
Microsoft SQL Server
Der Microsoft SQL Server, den ich auch in meinen Beispielen verwende ist normalerweise
nicht kostenlos zu haben. Man kann auf die kostenlose (zu SQL Server kompatible) MSDE
Version von Microsoft zurückgreifen, die aber leider keine grafische Benutzungsoberfläche
hat. Auf die Installation möchte ich hier nicht eingehen, da dieses den Rahmen sprengen
würde.
Neuen Benutzer anlegen
In manchen Fällen ist es nötig im SQL Server einen neuen Benutzer (ASP.NET) anzulegen.
Wenn der Server läuft aber beim Ausführen der ASP.NET Seite ein Fehler auftritt. Dazu
verfährt man wie folgt:
5
Enterprise Manager -> Datenbanken -> Eigene Datenbank -> Benutzer
rechte Maustaste -> Neuer Datenbankbenutzer…
Benutzername.DropDown auf <neu>
(neues Fenster erscheint) Name: "..." durchsuchen Knopf drücken
ASPNET (ASP.NET Machine Account for...) auswählen -> OK OK OK
Fertig.
6
WebMatrix
Zum Erstellen der .aspx Dateien verwendet man zweckmäßiger weise eine moderne
Entwicklungsumgebung. In diesem Vortrag möchte ich das Tool Microsoft WebMatrix
vorstellen. Es ist kostenlos von der Internetseite www.asp.net herunter zuladen und bietet
viele Features, die man von einem modernen Entwicklungstool erwartet.
Installation
Die Software ist auf der Internetseite www.asp.net herunter zuladen. Die Installation verläuft
problemlos.
WebMatrix Hauptansicht
Zunächst zu dem Erscheinungsbild: Auf der linken Seite ist die Toolbox, die Werkzeugleiste.
Hier befinden sich die Bausteine: Steuerelemente und Codeteile, auch „Snippets“ genannt, die
in mehrere Blöcke unterteilt angeordnet sind.
Abbildung 1: Webmatrix Hauptfenster
7
Auf der rechten Seite befindet sich im oberen Teil der „Explorer“, hier mit der Datenansicht.
Die anderen Ansichten des Explorers sind Workspace und „Open Windows“, hier sieht man
alle in WebMatrix geöffneten Dateien. Rechts unten befindet sich der Properties bereich. Hier
kann man die z.B. Eigenschaften der verwendeten Steuerelemente verändern. Weiterhin giebt
es hier einen Klassen-Browser. Mit Ihm lassen sich die einzelnen Bestandteile der Klassen
anzeigen und eine Hilfe aufrufen. Entweder die lokale Dokumentation oder die Online MSDN
Dokumentation. Der dritte Block, die Community, hält Links zu ASP.NET relevanten
Websites bereit.
In der Mitte ist der Arbeitsbereich. Hier gibt es vier verschiedene Ansichten: Design, HTML,
Code und All.
Die Designansicht zeigt das spätere Erscheinungsbild der ASP.NET Seiten. Hier lassen sich
einfach per Drag & Drop Steuerelemente aus der Werkzeugleiste einfügen.
Die HTML-Ansicht zeigt den HTML-Code der angezeigten Elemente, also den Statischen teil
der ASP.NET Seite.
Die Codeansicht zeigt den „Aktiven“ Teil der Seite; z.B. Ereignisbehandlungsroutinen wenn
ein Button gedrückt wurde.
In der Allansicht werden HTML-, und Code-Ansicht gemeinsam angezeigt.
Erstellen einer einfachen ASP.NET Seite
.aspx Dateien erstellen
Nach dem Start des Programms wird der “Add New File“ Dialog angezeigt. Hier können wir
Im linken Bereich unter Templates aussuchen, ob wir eine leere Datei (General), oder eine
vorgefertigte Datei z.B. Datenanzeige-ASP-Seiten laden wollen. Im rechten Bereich suchen
wir aus, was für eine Datei wir erstellen möchten: z.B. normale .aspx Datei für eine ASP.NET
Seite, oder .asmx Datei für einen XML Webservice, oder eine XML Datei, …
Darunter wählen wir noch den Speicherort und den Namen der Datei, sowie die Sprache, in
der die Datei geschrieben werden soll.
8
Abbildung 2: „New File“ Dialog
Wir klicken im Templates Bereich auf General und dann auf ASP.NET Page um eine leere
Datei zu erstellen. Wir wählen einen Speicherort aus und geben der Datei einen Namen.
In unserem Fall nennen wir die Datei „HalloWelt.aspx“. Als Sprache wählen wir Visual Basic
.NET. Wir bestätigen mit OK. Nun sehen wir den Arbeitsbereich in der Designansicht. Wir
können mit den unten liegenden Reitern zwischen den verschiedenen Ansichten wechseln.
Abbildung 3: „HalloWelt.aspx“ Arbeitsbereich
9
Steuerelemente hinzufügen
Um Steuerelemente hinzuzufügen müssen wir uns in der Designansicht des Arbeitsbereiches
befinden. Nun wählen wir aus der Werkzeugleiste (Toolbox) links den Block Web Controls.
Aus diesem Bereich können wir per Drag & Drop Steuerelemente zu unserer Seite
hinzufügen. Wir wählen als erstes ein Label und ziehen es mit der Maus auf unseren
Arbeitsbereich. Es erscheint der Schriftzug Label. Wenn wir auf das Label klicken, so
erscheinen kleine Kästchen rund um das Label. Das Steuerelement ist markiert.
Abbildung 4: markierte Steuerelemente
Ist ein Steuerelement markiert, so sind rechts unten im Eigenschaftenbereich (Properties) die
Eigenschaften des Steuerelementes sichtbar und können hier auch verändert werden.
Die „Hallo Welt“ Anwendung
Wir setzen die Text-Eigenschaft des Labels auf den Wert „Hallo Welt“
Abbildung 5: Eigenschaften-Fenster
Nun starten wir die ASP.NET Seite, indem wir über das Menü View -> Start gehen, oder F5
drücken. Es erscheint der Server-Auswahl-Dialog. Hier können wir zwischen dem von
WebMatrix mitgelieferten oder dem Microsoft Internet Information Server (IIS) wählen.
Zunächst benutzen wir den WebMatrix internen Server. Die Seite wird im Browser
dargestellt, daher öffnet sich dieser. Der erste Start der .aspx Seite dauert etwas länger, da der
Quellcode noch kompiliert wird. Bei den folgenden Starts ist der Seitenaufbau viel schneller.
10
Abbildung 6: „Hallo Welt“ Browserausgabe
Nun schließen wir den Browser gehen in WebMatrix auf die Detail Ansicht. Mittels Drag &
Drop ziehen wir weitere Steuerelemente auf die Designansicht. Da ASP.NET Seiten wie auch
normale HTML Seiten Zeilen-orientiert aufgebaut sind drücken wir nach dem Hinzufügen
von Stauerelementen die Return-Taste um in die nächste Zeile zu gelangen.
Addition zweier Zahlen
Wir fügen vor dem Label-Steuerelement zwei Text-Eingabefelder und einen Button hinzu.
Auf diesen Button klicken wir nun doppelt. Die Ansicht wechselt direkt zur von WebMatrix
generierten Button_Klick Ereignisbehandlungsroutine in der Code-Ansicht. Hier tragen wir
nun Code ein, der zwei in die Textfelder eingetragenen Zahlen addiert, und im Label-Feld
unterhalb des Buttons die Summe ausgibt. In unserem Fall schreiben wir
„Label1.Text = 0 + Textbox1.Text + Textbox2.Text“.
Die “Null” hat zur folge, dass die nachfolgenden Strings als Zahl interpretiert werden. Würde
man die „Null“ weglassen, so würde keine Rechenoperation ausgeführt, sondern es würden
nur die beiden Zahlen aneinandergefügt.
Abbildung 7: Quelltext zum Addieren zweier Zahlen aus Textboxen
11
Abbildung 8: ASP.NET Seite zum addieren von zwei Zahlen
Erstellen einer ASP.NET Seite mit Datenbankanbindung
Erstellung einer ASP.NET Seite mit Datenbank INSERT
Um Daten in eine Datenbank zu schreiben brauchen wir natürlich erst einmal eine Datenbank.
Ich habe hier für meine Beispiele den Microsoft SQL Server benutzt. Natürlich kann man
auch andere Datenbanken verwenden. Unsere Anwendung soll Benutzernamen in eine
Tabelle in eine Datenbank schreiben. Dafür fertigen wir uns eine Eingabemaske, die eine
Überschrift (Label) zwei Texteingabefelder (TextBox), einen Button und ein Ausgabefeld
(Label) enthält an.
12
Abbildung 9: Beispiel für eine Registrierungsseite
Erstellen einer Datenbank und Datenbankverbindung
Jetzt müssen wir noch die Verbindung mit der Datenbank herstellen. Dafür klicken wir rechts
im Workspace-Projekt-Explorer auf Data und dann auf die Schaltfläche „Add Database
Connection“.
Abbildung 10: Data-Explorer
13
Abbildung 11: Datenbank-System Auswahlfenster
Wir wählen hier SQL Server/MSDE Database aus und bestätigen mit OK. Auf dem
nachfolgenden Fenster klicken wir auf „Create a new database“. Jetzt geben wir den Namen
für unsere neue Datenbank „RegistrierteBenutzer“ ein und bestätigen wiederum mit OK. Nun
navigieren wir im Daten-Explorer auf unsere Datenbank „RegistrierteBenutzer“ und wählen
den Ordner Tabellen aus. Jetzt klicken wir auf die Schaltfläche „New Database Object“ um
eine neue Tabelle in der Datenbank anzulegen. Als Namen für die Tabelle tragen wir
„BenutzerNamen“ ein. Nach OK öffnet sich die Tabellen Design Ansicht. Hier können wir
neue Spalten in der Tabelle anlegen usw. Wir nennen die erste Spalte „Key“ und wählen für
die Attribute IsIdentity, IsPrimaryKey und IsUniqueKey jeweils true. Über die Schaltfläche
New fügen wir zwei neue Spalten hinzu. Die erste nennen wir „Vorname“, die zweite
„Nachname“. Den Datentyp der beiden neuen Spalten ändern wir in „varchar“. Nun ist unsere
Tabelle fertig und wir speichern und schließen die Tabellen Designansicht. Nun wechseln wir
in die Codeansicht. Auf der linken Seite erscheinen in der Toolbox die Code Wizards.
Hiervon wählen wir „INSERT Data Method“. Auf dem ersten Fenster des Wizards wählen
wir unsere Datenbank „(local).RegistrierteBenutzer“ aus und klicken Next. Da wir keine
Default Insert-Werte haben wollen klicken wir auf der nächsten Seite des Wizards auf Next.
Jetzt können wir einen Namen für unsere INSERT-Funktion wählen. Wir nennen sie
„BenutzerInsert“. Nach dem klick auf Finish generiert der Code Wizard den Code zum
Eintragen von neuen Benutzern in unsere BenutzerNamen-Tabelle in unserer Datenbank. Nun
wechseln wir zur Designansicht und klicken doppelt auf den Button, um eine Button_klick
Ereignisbehandlungsroutine zu generieren. In dieser Routine rufen wir nun die BenutzerInsert
Methode auf. Wir übergeben dabei die Inhalte der TextFelder. Um Fehler abzufangen und
dem Benutzer der ASP.NET Seite mitzuteilen fügen wir folgenden Code ein.
If BenutzerInsert(TextBox1.Text, TextBox2.Text) > 0
Label2.Text = "Benutzer wurde eingetragen"
Else
Label2.Text = "Ein Fehler ist aufgetreten"
End If
Jetzt starten wir das Programm. Die Seite sollte wie unten abgebildet aussehen.
14
Abbildung 12: „Benutzer in Datenbank eintragen“ Seite
Erstellung einer ASP.NET Seite mit Datenansicht
Eine Tabelle einer vorhandenen Datenbank anzuzeigen ist mit WebMatrix besonders einfach.
Als erstes erstellen wir uns eine neue leere ASP.NET Seite. Im Daten-Explorer Bereich
markieren wir die Tabelle, die wir angezeigt haben wollen und ziehen sie per Drag & Drop
auf die Designansicht der ASP.NET Seite. Dann starten wir das Programm. Wenn wir bereits
einige Einträge in der Tabelle haben, so werden diese immer in 10-er Blöcken angezeigt. Man
kann die Einträge nach jedem Attribut sortieren lassen.
15
Abbildung 13: Datenansichts-Seite mit Tabelle
Erstellen eines einfachen Webservices
Anlegen einer .asmx Datei
Um mit WebMatrix einen einfachen Webservice zu erstellen, brauchen wir nur im „DateiNeu“ Dialog aus dem Templates-Bereich „XML Web Service“ auszuwählen. Neben dem
Namen für die .asmx Datei müssen wir noch einen Klassennamen und einen Namespace
Namen angeben. Der Klassenname identifiziert später die Klasse, in der sich unsere
Webservice Methoden befinden. Der Namespace (Namensraum) Name gibt mehreren
zusammenhängenden Webservices einen Rahmen. In diesem Beispiel geben wir der Klasse
den Namen „MyMath“ und dem Namensraum den Namen „MyNamespace“.
16
Abbildung 14: Neue Datei Webservice
Nach Bestätigung mit OK legt WebMatrix die .asmx Datei an. In dieser Datei ist
standardmäßig bereits eine WebMethode vorgegeben, die als Beispiel dient.
Abbildung 15: Von WebMatrix generierter Beispielcode
Hinzufügen eigener WebService-Methoden
Per „copy and paste“ können wir nun sehr einfach eigene Funktionen hinzufügen, indem wir
nur die Funktionsnamen und die eingebaute Funktionalität ändern. Als Beispiel soll unsere
Klasse MyMath dienen. In dieser haben wir die vier Grundrechenarten implementiert.
17
Wichtig ist, dass vor den Methoden, die als Webservice zu Verfügung stehen sollen das
<WebMethod> steht, dass die Methode als Webservice-Methode deklariert.
Abbildung 16: Unsere Klasse MyMath
Testen eines Webservices
Nun wollen wir unsere Klasse MyMath testen. Dazu brauche wir nur die „Start“ Schaltfläche
anzuklicken. Wir werden nun wieder nach dem Server, den wir benutzen wollen gefragt. Wir
wählen der Einfachheit den ASP.NET WebMatrix Server. Es öffnet sich der Webbrowser und
zeigt die „Testansicht“ der MyMath Webservice Klasse.
18
Abbildung 17: MyMath Testansicht
Wenn wir jetzt z.B. auf Multiply klicken, so wird uns eine Testmaske für die MultiplikationsMethode angezeigt. Hier können wir beliebige Testwerte eingeben und unseren WebService,
der ja eigentlich keine Grafische Benutzungsoberfläche hat bequem testen.
19
Abbildung 18: Die Testoberfläche von Multiply
Wenn wir die Multiply-Methode mit einigen Testwerten aufrufen, so erhalten wir unser
Ergebnis Fenster, indem der Rückgabewert der Multiply Funktion in einem kleinen Stück
XML angezeigt bekommen.
Abbildung 19: Das Ergebnis des Webservices
20
Um unseren eigenen Namensraum einzubinden, müssten wir im Codefenster von WebMatrix
vor den Klassennamen
„<WebService(Namespace:="http//www.MeinNamespace.de/MeineWebservices/")>“
schreiben.
Webservice konsumieren
Erstellen eines Webservice-Proxy
Um unseren Webservice nun richtig zu nutzen müssen wir ihn in ein anderes Programm
einbinden. Dazu erstellen wir uns eine einfache ASP.NET Seite mit zwei Texteingabe
Feldern, einem Button und einem Textausgabefeld (Label). Wir klicken doppelt auf den
Button, und wechseln damit in die Codeansicht von WebMatrix. Nun gehen wir über das
Menü Tools -> Web Service Proxy Generator und rufen den Proxygenerator auf.
Abbildung 20: Webservice Proxy Generator
Wir geben die komplette URL zu unserem Webservice sowie den Namespace, in unserem
falle einmal http://localhost:8080/WebService.asmx und „MyNamespace“. Dann geben wir
noch als Output Directory den Pfad zu unserer ASP.NET Seite ein und starten die Erstellung
der Proxy Klasse.
21
Einbinden einer Proxy-Klasse
Jetzt können wir die Proxy Klasse in unsere ASP.NET Seite einbinden. Dazu schreiben wir in
der Button_Click Ereignisbehandlungsroutine Folgenden Code:
“Dim MyProxy As New MyNamespace.MyMath”
“Label1.Text = MyProxy.Multiply( Textbox1.Text, Textbox2.Text)”
Die erste Zeile Deklariert eine Variable vom Typ des Webservices. Mit dem Schlüsselwort
„New“ wird auch sogleich ein Objekt erzeugt. In der zweiten Zeile benutzen wir die Multiply
Web Methode der MyMath Klasse genauso wie Methoden lokaler Klassen.
Abbildung 21: Einbindung eines Webservices in ASP.NET Seiten
Nun starten wir die ASP.NET Seite und es öffnet sich der Browser mit unserer kleinen
Eingabemaske.
Abbildung 22: Webservice via ASP.NET Seite
Nach der Eingabe von einigen Testwerten und klick auf den Button wird in dem Labelfeld das
Ergebnis angezeigt.
22
Anhang
Typische Fehlerquellen
Fehler in der Wiedergabe der Seiten
ASP.NET Seiten werden nicht richtig dargestellt. In der Quelltextansicht im Internetexplorer
sieht man den gesamten Quelltext des .aspx Dokuments:
Dem .NET Framework ist noch mitzuteilen, dass es für die Ausführung der .aspx Dateien
verantwortlich ist. Dazu führt man das Programm aspnet_regiis.exe aus:
Auf der Befehlszeile:
„C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\aspnet_regiis.exe –i”
Nun sollten die .aspx Dateien problemlos von der .NET Laufzeitumgebung ausgeführt
werden.
Zur Laufzeit keine Verbindung mit der SQL Datenbank
In manchen Fällen ist es nötig im SQL Server einen neuen Benutzer (ASP.NET) anzulegen.
Wenn der Server läuft aber beim Ausführen der ASP.NET Seite ein Fehler auftritt. Dazu
verfährt man wie folgt:
Enterprise Manager -> Datenbanken -> Eigene Datenbank -> Benutzer
rechte Maustaste -> Neuer Datenbankbenutzer…
Benutzername.DropDown auf <neu>
(neues Fenster erscheint) Name: "..." durchsuchen Knopf drücken
ASPNET (ASP.NET Machine Account for...) auswählen -> OK OK OK
Fertig.
23
Verwendete Werkzeuge / Software
Microsoft XP Version 2002 SP1
Microsoft IIS 5.1
Microsoft SQL Server 2000 Developer Edition
Microsoft Web Matrix Version 0.6.812.0
Microsoft Word 2003
Microsoft Powerpoint 2003
Literaturverzeichnis / Quellenangabe
ASP.NET Nitty-Gritty, Addison-Wesley
.NET Verstehen Einführung und Analyse, Addison-Wesley
ASP.NET Schritt für Schritt, Microsoft Press
ASP.NET Entwicklerbuch, Microsoft Press
www.asp.net
www.microsoft.com
24
Herunterladen