Erstellen einer ActiveX-DLL und ansprechen in ASP
1. Voraussetzungen:
IIS 5.x.
ASP.
VisualBasic 6.
Adminrechte auf dem Entwicklungsrechner.
einen Editor (z.B.: VisualInterDev, MS-ScriptEditor, Macromedia Dreamveaver-UltraDev, Macromedia DreamveaverMX, HomeSite).
Einen beliebigen Browser.
Lust am programmieren ;-)
2. Vorbereitungen
Richtet euch als erste einmal ein neues Verzeichnis ein, wo ist egal. Als Editor empfehle ich den Microsoft VisualInterDev (im VisualStudio6 enthalten), oder den MS-Skripteditor (in MS-Office enthalten, kann mit [shift]+[Alt]+[F11] von Frontpage aus aufgerufen werden). Die beiden Editoren sind meiner Meinung am besten geeignet um (eigene) DLLs in ASP einzubinden, da das sogenannte hilfreiche IntelliSense dann auch bei eigenen DLLs funktioniert.
3. VisualBasic 6
Startet nun VisualBasic 6 und wählt aus dem Startdialog die ActiveX-dll aus. Falls das Dialogfenster beim starten nicht aufpoppen sollte kann man es auch unter "Datei" - "Neu..." - "Projekt..." aufrufen.
Startdialog
Auf die Einzelheiten der Oberfläche von VisualBasik 6 möchte ich nicht eingehen. Einige Fenster und Menüs werde ich beschreiben, wenn sie hier im Tutorial benutzt werden.
Folgende wichtigen Elemente sind jetzt allerdings auf der Oberfläche von VB 6 zu sehen:
Links die Toolbar, welche getrost ausgeblendet werden kann, da wir sie nicht benutzen werden (was sollen Windows-Scrollbalken etc. in einer DLL, die fürs Internet gedacht ist? ;-) )
In der Mitte ist das Codefenster zu sehen, hier werden wir den größten Teil der Arbeit erledigen.
Rechts oben sollten wir den sogenannten Projektexplorer sehen (kann unter "Ansicht" in der Menüleiste angezeigt werden), hier behalten wir den Überblick über unsere Klassen und/oder öffnen sie zum bearbeiten.
Darunter befindet sich das Eigenschaftsfenster (kann unter "Ansicht" in der Menüleiste angezeigt werden), wo im Normalfall die Eigenschaften von Buttons, etc. bei Windowsanwendungen eingestellt werden. In unserem Fall werden hier nur die Eigenschaften unserer Klassen und des Projektes eingestellt.
4. Einstellungen
Fangen wir nun an unser neues Projekt so zu konfigurieren, wie wir es für eine Serverkomponente für ASP brauchen. Hierzu klicken wir im Projektexplorer auf das Projekt, so das es blau markiert ist:
Anschließend schauen wir uns das Eigenschaftsfenster an, das sich etwas verändert hat, als wir das Projekt markiert hatten. Eine Eigenschaft die wir hier ändern können ist der Projektname. Hier geben wir jetzt einen aussagekräftigen Namen, z.B. "meinProject" ;-). Den Namen sollten wir uns auf jeden fall merken, da wir ihn später benötigen, um die fertige DLL von ASP aus anzusprechen.
Ist der neue Name eingegeben, so sollte sich der Projektexplorer folgendermaßen darstellen:
Mit der Klasse sollten wir nun genauso vorgehen:
Das Eigenschaftsfenster sieht nun etwas anders aus, auch hier geben wir einen Namen ein, den wir uns merken sollten. Den Rest können wir unbeachtet lassen.
Das Ergebnis im Projektexplorer:
Anschließend können wir wieder das Projekt markieren und auf speichern klicken, jetzt werden die für das Projekt benötigten Dateien mit den von uns vergebenen Namen gespeichert.
Das Codefenster sollte jetzt in der Titelleiste den Namen des Projekts und der aktuell geöffneten Klasse haben:
Nun folgt noch eine Einstellung und wir können anfangen zu Programmieren:Damit unsere DLL ASP kann, sollten wir noch die asp.dll in unser Projekt einbinden. Dazu klicken wir im Menü "Projekt“ auf "Verweise..."
In dem sich öffnenden Fenster scrollen wir so lange nach unten bis wir auf den Eintrag "Microsoft Active Server Pages Object Library" stoßen. (bei mir sind es zwei Einträge, da die Entwicklungsumgebung scheinbar eine zweite asp.dll im Verzeichnis "Programme" registriert hat. In dem Fall wähle ich die, welche sich im "system32"-Verzeichnis befindet (zu sehen an dem Pfad, der unten eingeblendet wird), da diese asp.dll in der Regel diejenige ist, die auch vom IIS (Webserver) verwendet wird). Die Einträge bei euch sind nicht zwingend die gleichen wie bei mir, also nicht wundern, wenn die Liste bei euch etwas anders aussieht.
Setzt nun einen Haken in das Kästchen vor dem Eintrag.
So, das schlimmste hätten wir...
Jetzt kann die DLL das gleiche wie ASP. Fast...
Fast deswegen, weil die DLL noch keine Daten empfangen kann wie ASP, noch keine Daten direkt schreiben kann und noch nicht mit dem Server kommunizieren kann. auch kann die DLL noch nicht auf Sessions und Cookies zugreifen. Um das zu erreichen müssen wir noch etwas programmieren...
Fügt nun folgenden Code einfach mal so in das Codefenster:
[1] Option Explicit [2] [3] Private myScriptingContext As ScriptingContext [3] Private myRequest As Request [5] Private myResponse As Response [6] Private myApplication As Application [7] Private myServer As Server [8] Private mySession As Session [9] [10] Public Sub OnStartPage(PassedScriptingContext As ScriptingContext) [11] Set myScriptingContext = PassedScriptingContext [12] Set myApplication = myScriptingContext.Application [13] Set myRequest = myScriptingContext.Request [14] Set myResponse = myScriptingContext.Response [15] Set myServer = myScriptingContext.Server [16] Set mySession = myScriptingContext.Session [17] End Sub
(Die Zeilennummern sollten nicht kopiert werden, diese dienen hier nur der Übersicht, und erleichtern mir auch eventuelle Erklärungen)
Wer schon mit ASP zu tun hatte wird hier schon einige Objekte erkennen, wenn auch nicht in dieser Formulierung.
Zeile eins dürfte allerdings allen bekannt sein. "Option Explicit" legt fest, dass wir nun alle Variablen "explizit" deklarieren müssen. Das dient einfach dazu, Fehler zu vermeiden.
Anschließend definieren wir die Objekte (Zeile 3 bis 8).
Das Schlüsselwort "Private" dient dazu, dass die Objekte von außen (von der ASP-Seite) nicht gelesen oder geändert werden können.
Achtet darauf, dass die Objekte einen Namen bekommen der nicht zu einem Namenskonflikt führt ("Private Request as Request" könnte evtl. einen Fehler verursachen, deshalb hab ich die Silbe "my" vorne dran gehängt)
Das "ScriptingContext" ist ein Objekt, das alle benötigten Objekte (Request, Response, Application, Server und Session) beinhaltet.
In der Sub "OnStartPage" (die muss so genannt werden) wird der "ScriptingContext" dem oben definierten Objekten zugewiesen, so das damit gearbeitet werden kann.
Alle Funktionen, auf die von der ASP-Seite aus zugegriffen werden sollen, müssen mit dem Schlüsselwort "Public" deklariert werden.
Jetzt können wir die DLL testen, indem wir drei kleine Funktionen hinzufügen:
Public Function getMeText(ByVal text As String) As String
getMeText = UCase(text)
End Function
Public Sub writeMeText(ByVal text As String)
myResponse.Write (UCase(text))
End Sub
Public Sub writeMeTextFromUrl()
Dim text As String
text = myRequest.QueryString("text")
myResponse.Write (UCase(text))
End SubDie erste Funktion gibt nur einen Text zurück, der ihr vorher übergeben wurde, als kleine Spielerei lasse ich den Text in Großbuchstaben umwandeln.
Mit der zweiten Funktion teste ich das Responseobjekt "myResponse". Diese Sub muss den Text, der ihr übergeben wurde, direkt auf der ASP-Seite ausgeben.
Die dritte Funktion muss einen Text über den QueryString empfangen (myRequest.QueryString("text")) und ihn wie in der zweiten Funktion wieder ausgeben, nachdem er in Großbuchstaben umgewandelt wurde.
Um nun unsere DLL in Aktion zu sehen, müssen wir sie erst kompilieren. Hierzu klicken wir im Menü "Datei" auf "meinProject.dll erstellen...", wobei hier "meinProject" für den Namen des aktuellen Projekts steht. Falls das Projekt bisher noch nicht kompiliert wurde, wird die DLL nun sofort erstellt.
Normalerweise ist die DLL schon automatisch auf dem Rechner registriert auf dem sie entwickelt wurde, aber falls nicht, oder falls die DLL auf einem anderen Rechner zum Einsatz kommen soll muss sie dort erst registriert werden.
Klickt hierfür im Windowsstartmenü auf "Ausführen..." und gebt in dem sich öffnendem Fenster
regsvr32 D:\tuts\aspdlls\meinProject.dll
ein (eventuell müsst ihr den Pfad zur "meinProject.dll" noch anpassen, je nach dem wo ihr das Projekt abgespeichert habt).
(mein System ist auf Englisch... )
Nachdem das erledigt ist, machen wir uns an die ASP-Seite:
<%
set objDLL = server.CreateObject("meinProject.meineKlasse")
response.Write objDLL.getMeText("Das ist ein Test")
response.Write "<br />"
objDLL.writeMeText "Das ist ein Test"
response.Write "<br />"
objDLL.writeMeTextFromUrl
%>Was passiert hier?
Erst wird das Objekt erstellt, bzw. die DLL in die ASP-Seite eingebunden. Der Syntax hierfür lautet immer :
set objektName = server.CreateObject("ProjektName.KlassenName")
Anschließend wird die erste Funktion aufgerufen und ihr ein Text übergeben.
In der nächsten Zeile geben wir einen <br>-Tag aus (wegen der Übersicht nachher)
Anschließend wird die zweite Funktion aufgerufen. Ihr wird ebenfalls ein Wert übergeben, aber da diese Funktion eine Sub ist, müssen wir die Klammern weglassen.
Dann wieder ein <br> und danach die dritte Funktion, diesmal ohne Parameter. weil die letzten beiden Funktionen den Wert direkt ausgeben sollen fällt hier das "Response.Write" weg.
Starten wir nun die Seite (ich hab sie mal "dlltestseite.asp" genannt):
Irgend etwas stimmt hier noch nicht, oder? Wir bekommen nur zwei Zeilen ausgegeben, obwohl wir drei Funktionen aufgerufen haben...
Nein, es ist natürlich alles in Ordnung, wir haben nur den QueryString vergessen.
Also noch mal von vorne, diesmal mit dem Query:
Stolz können wir jetzt sagen, das wir eine eigene ActiveX-Komponente für ASP geschrieben haben :-))
Wenn wir jetzt noch etwas VB lernen, sind wir evtl. selber in der Lage, irgendwelche Upload-, Image-, oder Emailkomponenten zu schreiben.
Download: aspdlltut.zip (9 KB)
