Entwickeln von IIS 7.0-Modulen und -Handlern mit .NET Framework

von Mike Volodarsky

Übersicht

Dieser Artikel befasst sich mit den ersten Schritten bei der Entwicklung von Webserver-Funktionen für IIS 7.0 und höher, die auf dem .NET Framework basieren. Dieser Artikel demonstriert Folgendes:

1. Wie Sie entscheiden, ob ein IIS-Modul oder ein IIS-Handler entwickelt werden soll
2. Wie Sie Ihre Entwicklungsumgebung einrichten, mit Visual Studio, Visual C# Express oder den Befehlszeilen-Tools, die mit dem .NET Framework geliefert werden
3. Wie Sie Ihr erstes Projekt erstellen
4. Wie Sie ein einfaches Modul und einen einfachen Handler entwickeln
5. Wie Sie ein einfaches Modul und einen einfachen Handler auf einem IIS-Server bereitstellen

Um einige real verwaltete IIS-Module und -Handler zu sehen und für Ihre Anwendung herunterzuladen, besuchen Sie Umleiten von Anforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, Erstellen von ansprechenden Verzeichnislisten für Ihre IIS-Website mit dem DirectoryListingModule und Anzeigen attraktiver Dateisymbole in Ihren ASP.NET-Anwendungen mit IconHandler.

Einführung: Entwickeln von IIS-Features mit ASP.NET

IIS-Versionen vor IIS 7.0 enthielten als primäre Erweiterbarkeits-API zum Erstellen von Webserverfeatures eine C-API namens ISAPI. IIS 7.0 und höher wurden von Grund auf neu entwickelt, um eine völlig neue C++-API bereitzustellen, auf der alle Standard-Features basieren, um die vollständige Runtime-Erweiterbarkeit des Webservers zu ermöglichen.

Darüber hinaus bietet IIS erstmals eine vollwertige.NET-API zum Erweitern des Webservers durch Verwendung einer engen Integration mit ASP.NET 2.0. Dies bedeutet, dass Sie IIS jetzt mit neuen Webserverfeatures erweitern können, die mit den vertrauten ASP.NET 2.0-APIs erstellt wurden. Ebenso können Sie vorhandene ASP.NET 2.0-Module und -Handler in IIS verwenden, indem Sie ASP.NET Integration nutzen, um die Leistungsfähigkeit Ihrer Anwendung zu verbessern, ohne neuen Code zu schreiben. Weitere Informationen zur ASP.NET Integration in IIS finden Sie unter ASP.NET Integration in IIS 7.

Arbeitsmittel: Wählen Sie Ihre Entwicklungsumgebung

Verwenden Sie zum Erstellen von IIS-Modulen und -Handlern eine beliebige Umgebung, in der Sie .NET-Assemblys entwickeln und kompilieren können. Einige der häufig verwendeten Optionen sind:

1. Visual Studio 2005. Alternativ können Sie auch die neueste Betaversion von Visual Studio 2008 herunterladen.
2. Visual C# 2005 Express Edition, ein kostenloser Download (oder andere Express-Tools, einschließlich Visual Basic 2005 Express).
3. Der C#-Befehlszeilencompiler (csc.exe), der in der .NET Framework-Runtime enthalten ist (für andere Sprachen müssen Sie das SDK herunterladen) sowie Ihr bevorzugter Quellcode-Editor.

In den Beispielen in diesem Artikel wird C# verwendet. Sie können IIS-Komponenten aber auch in einer anderen unterstützten .NET-Sprache (mit Ausnahme von verwaltetem C++) entwickeln. Der Artikel veranschaulicht, wie IIS-Erweiterbarkeitskomponenten mit allen drei oben genannten Umgebungen entwickelt werden.

Hinweis

Da IIS die vorhandenen ASP.NET-APIs für die .NET-Erweiterbarkeit nutzt, können Sie IIS .NET-Module und -Handler mit .NET Framework 2.0 unter Windows XP® und Windows Server® 2003 entwickeln. Wenn Sie jedoch beabsichtigen, eine der verschiedenen neuen ASP.NET-APIs zu verwenden, die zur Unterstützung neuer IIS-Features hinzugefügt wurden, müssen Sie entweder auf Windows Vista® entwickeln oder die Version von System.Web.dll aus Windows Vista oder der neuesten Version von .NET Framework 3.5 abrufen, um Ihren Code zu kompilieren.

Es gibt zwei Möglichkeiten zum Erweitern von IIS: Module oder Handler

Alle IIS-Webserverfeatures passen in zwei Kategorien: Module und Handler.

Ein Modul, ähnlich dem ISAPI-Filter in früheren IIS-Versionen, nimmt an der Anforderungsverarbeitung jeder Anforderung teil, um sie auf irgendeine Weise zu ändern oder hinzuzufügen. Beispiele für einige Standardmodule in IIS sind Authentifizierungsmodule, die den Authentifizierungsstatus der Anforderung verändern, Komprimierungsmodule, die die ausgehende Antwort komprimieren, und Protokollierungsmodule, die Informationen über die Anforderung in den Anforderungsprotokollen speichern.

Das Modul ist eine .NET-Klasse, die die ASP.NET-Schnittstelle System.Web.IHttpModule implementiert und die APIs im Namespace System.Web verwendet, um an einer oder mehreren Phasen der Verarbeitung von Anforderungen in ASP.NET teilzunehmen.

Ein Handler, ähnlich der ISAPI-Erweiterung in früheren IIS-Versionen, ist für die Verarbeitung der Anforderung und die Erstellung der Antwort für bestimmte Inhaltstypen verantwortlich. Der Hauptunterschied zwischen dem Modul und dem Handler besteht darin, dass der Handler in der Regel einem bestimmten Anforderungspfad oder einer bestimmten Erweiterung zugeordnet ist und die Verarbeitung einer bestimmten Serverressource unterstützt, der dieser Pfad oder diese Erweiterung entspricht. Beispiele für mit IIS bereitgestellte Handler sind ASP, die ASP-Skripts verarbeitet, der statische Dateihandler, der statische Dateien bereitstellt, und der PageHandler von ASP.NET, der ASPX-Seiten verarbeitet.

Der Handler ist eine .NET-Klasse, die die ASP.NET-Schnittstelle System.Web.IHttpHandler oder System.Web.IHttpAsyncHandler implementiert und die APIs im Namespace System.Web verwendet, um eine HTTP-Antwort für bestimmte von ihr unterstützte Inhalte zu erzeugen.

Wenn Sie die Entwicklung einer IIS-Funktion planen, sollten Sie sich als erstes die Frage stellen, ob diese Funktion für die Bedienung von Anforderungen an eine bestimmte URL/Erweiterung zuständig ist oder ob sie für alle/einige Anforderungen auf der Grundlage beliebiger Regeln gilt. Im ersten Fall sollte es sich um einen Handler und in letzterem Fall um ein Modul handeln.

Dieser Artikel veranschaulicht die Erstellung eines einfachen Moduls und eines einfachen Handlers, die allgemeinen Schritte bei der Projekterstellung und Kompilierung sowie die spezifischen Schritte zur Bereitstellung auf dem Server.

Hinweis

Sie müssen keinen Handler entwickeln, wenn Sie ein Modul entwickeln, und umgekehrt.

Erste Schritte: Erstellen des Visual Studio-Projekts

Zum Erstellen eines Moduls oder eines Handlers müssen Sie eine .NET-Assembly (DLL) erstellen, die die Modul-/Handlerklassen enthält. Wenn Sie Visual Studio- oder Visual Studio Express-Tools verwenden, erstellen Sie zunächst ein Klassenbibliothek-Projekt:

1. Wählen Sie im Menü „Datei“ „Neu“, „Projekt“ aus. Wählen Sie im Dialogfeld „Neues Projekt“ (unten) den Projekttyp „Visual C#“ aus, und wählen Sie rechts in der Liste der installierten Visual Studio-Vorlagen die Option „Klassenbibliothek“ aus.

   

2. Wir müssen einen Verweis auf die Assembly „System.Web.dll“ hinzufügen, die die APIs enthält, die zum Entwickeln von ASP.NET- und IIS-Modulen und -Handlern verwendet werden. Klicken Sie unter dem Projektknoten in der Strukturansicht des Projektmappen-Explorers mit der rechten Maustaste auf den Knoten „Verweise“, wählen Sie „Verweis hinzufügen…“ aus, und wählen Sie auf der Registerkarte „.NET“ die System.Web-Assembly, Version 2.0 (unten) aus.

   

Hinweis

Sie können die System.Web-Assembly, Version 2.0 unter Windows XP und Windows Server 2003 verwenden, wenn Sie nicht beabsichtigen, IIS-spezifische ASP.NET-APIs zu nutzen. Module und Handler, die mit Verweis auf diese Assembly kompiliert wurden, können problemlos auf IIS unter Windows Vista und Windows Server 2008 bereitgestellt und betrieben werden. Wenn Sie die wenigen IIS-spezifischen ASP.NET-APIs in Ihrem Modul verwenden möchten, müssen Sie entweder unter Windows Vista oder Windows Server 2008 entwickeln oder die System.Web.dll-Assembly von .NET Framework 3.5 abrufen. Zu den IIS-spezifischen APIs gehören HttpServerUtility.TransferRequest, die Sammlung HttpResponse.Headers, das Ereignis HttpApplication.LogRequest und einige andere.

Schreiben von Code: Erstellen eines einfachen Moduls

Die erste Aufgabe besteht darin, ein einfaches Modul zu erstellen. Später in diesem Artikel werden wir auch einen Beispiel-Handler erstellen.

Um ein Modul zu erstellen, definieren Sie eine Klasse, die die Schnittstelle System.Web.IHttpModule implementiert.

1. Löschen Sie die vom Projektsystem generierte Datei „class1.cs“ und fügen Sie eine neue C#-Klasse mit dem Namen MyModule hinzu, indem Sie in der Strukturansicht rechts mit der rechten Maustaste auf das Projekt MyIIS7Project klicken. Wählen Sie „Hinzufügen“, „Neues Element“ und dann „Klasse“ aus und geben Sie in das Feld Name MyModule.cs“ ein.

2. Importieren Sie den Namespace System.Web, damit wir problemlos auf die darin enthaltenen Typen zugreifen können.

3. Implementieren Sie in unserer Klasse MyModule die Schnittstelle IHttpModule und definieren Sie die Schnittstellenmitglieder Dispose() und Init(). Klicken Sie dazu mit der rechten Maustaste auf die Schnittstelle IHttpModule und wählen Sie die Option „Schnittstelle implementieren“:

   

   Die Dispose()-Methode soll alle nicht verwalteten Ressourcen deterministisch bereinigen, wenn das Modul entladen wird, damit die Ressourcen freigegeben werden können, bevor die Modulinstanz vom Garbage Collector abgeschlossen wird. Sie können diese Methode die meiste Zeit leer lassen.

   Die Methode Init(HttpApplication context) ist die wichtigste Methode. Sie initialisiert Ihr Modul und verbindet es mit einem oder mehreren Ereignissen zur Verarbeitung von Anforderungen, die in der Klasse HttpApplication verfügbar sind. Während der Verarbeitung der Anforderungen wird Ihr Modul für jedes der Ereignisse, die es abonniert hat, aufgerufen, damit es seinen Dienst durchführen und erfüllen kann. Gehen Sie dafür folgendermaßen vor:

4. Abonnieren Sie eines oder mehrere der Ereignisse zur Verarbeitung von Anforderungen, indem Sie eine Methode Ihrer Modulklasse mit einem der Ereignisse der bereitgestellten HttpApplication-Instanz verdrahten. Die Methode muss der Delegatsignatur System.EventHandler folgen. Wir definieren eine neue Methode mit dem Namen OnPreExecuteRequestHandler und verbinden sie mit dem Ereignis HttpApplication.PreRequestRequestHandlerExecute, das eintritt, kurz bevor der Server den Anforderungshandler für die Anforderung aufruft:

   public void Init(HttpApplication context) 
   { 
       context.PreRequestHandlerExecute += 
           newEventHandler(OnPreRequestHandlerExecute) 
   }
   

   

   An diesem Punkt ist unser Modul so eingerichtet, dass es bei jeder Anforderung das Ereignis PreRequestHandlerExecute empfängt. Sie können dies für alle anderen Ereignisse wiederholen, die Sie empfangen möchten.

5. Jetzt lassen wir unsere Module etwas Nützliches tun, etwas, das einige der ASP.NET-APIs, die ein Modul verwenden könnte, veranschaulicht. Überprüfen Sie, ob die Anforderung einen Referrer-Header angibt. Wenn ja, lehnen Sie sie in diesem Fall ab. Sehen Sie dies als eine alberne Möglichkeit, um zu verhindern, dass Personen von anderen Websites eine Verknüpfung mit Ihrer Website herstellen. Wir werden dies in unsere Methode OnPreRequestHandlerExecute einbauen, die direkt vor der Ausführung des Handlers für jede Anforderung aufgerufen wird:

   public void OnPreRequestHandlerExecute (
      Object source, EventArgs e) 
   { 
      HttpApplication app = (HttpApplication)source; 
      HttpRequest    request = app.Context.Request; 
   
      if (!String.IsNullOrEmpty( request.Headers["Referer"] )) 
      { 
          throw new HttpException(403, 
                                                  "Uh-uh!"); 
      } 
   }
   

   

   Hinweis

   Die HttpApplication-Instanz wird Ihrem Modul über das Argument source zur Verfügung gestellt und erfordert eine Umwandlung. Von der HttpApplication-Instanz aus können Sie auf den Rest des Anforderungsobjektmodells zugreifen, z. B. auf das Objekt HttpContext und das darin enthaltene Objekt HttpRequest, das die Anforderung darstellt.

Der Code oben prüft, ob der Referrer-Header angegeben wurde, und wenn ja, lehnt er die Anforderung mit dem Fehlercode „403 Unauthorized“ ab.

Schreiben von Code: Erstellen eines einfachen Handlers

Die nächste Aufgabe besteht darin, einen einfachen Handler zu erstellen. Weiter oben im Artikel haben wir ein Beispielmodul erstellt – gehen Sie zurück, wenn Sie stattdessen mehr über das Erstellen eines Moduls erfahren möchten.

Um einen Handler zu erstellen, müssen wir eine Klasse definieren, die die Schnittstelle System.Web.IHttpHandler implementiert (wenn die Seite asynchron ausgeführt werden soll, könne wir auch die Schnittstelle System.Web.IHttpAsyncHandler implementieren). Gehen Sie dafür folgendermaßen vor:

1. Falls Sie dies noch nicht getan haben, löschen Sie die vom Projektsystem generierte Datei „class1.cs“ und fügen Sie eine neue C#-Klasse mit dem Namen MyHandler hinzu. Dazu klicken Sie in der Strukturansicht auf der rechten Seite auf das Projekt MyIIS7Project. Wählen Sie „Hinzufügen“ und „Neues Element“ aus. Wählen Sie dann „Klasse“ aus und geben im Feld Name „MyHandler.cs“ ein.

2. Importieren Sie den Namespace System.Web, damit wir problemlos auf die darin enthaltenen Typen zugreifen können.

3. Lassen Sie unsere Klasse MyHandler die Schnittstelle IHttpHandler implementieren und definieren Sie die Schnittstellenmitglieder IsReusable und ProcessRequest(). Sie können dies schnell tun, indem Sie mit der rechten Maustaste auf die Schnittstelle IHttpHandler klicken und die Option „Schnittstelle implementieren“ auswählen:

   

   IsReusable() gibt an, ob die Handlerinstanz für nachfolgende Anforderungen erneut verwendet werden kann. In einigen Fällen befindet sich Ihr Handler nach der Verarbeitung der Anforderung möglicherweise nicht im richtigen Zustand, um eine weitere Anforderung zu verarbeiten, insbesondere wenn Sie Daten über die vorherige Anforderung in Membervariablen gespeichert haben. Beachten Sie, dass die Laufzeitumgebung niemals dieselbe Instanz Ihres Handlers verwenden wird, um zwei Anforderungen gleichzeitig zu verarbeiten, selbst wenn er als wiederverwendbar markiert ist. Wenn ihr Handler keinen Anforderungsstatus in Membervariablen speichert und seine ProcessRequest-Funktion beliebig oft aufgerufen werden kann, geben Sie „true“ zurück, um die Wiederverwendung zuzulassen.

   Die Methode ProcessRequest() ist der Standardeinstiegspunkt des Handlers. Sie verarbeitet die Anforderung, die durch die HttpRequest-Instanz, die über die bereitgestellte HttpContext-Instanz verfügbar ist, spezifiziert wird, und generiert die entsprechende Antwort mithilfe der HttpResponse-Instanz, die ebenfalls über den HttpContext verfügbar ist. Die Methode ProcessRequest() wird von der Laufzeitumgebung während der Verarbeitungsphase der ExecuteRequestHandler-Anforderung aufgerufen, und zwar NUR, WENN die Anforderung Ihrem Handler auf der Grundlage der konfigurierten Handler-Zuordnungen zugeordnet wurde. Dies ist ein Unterschied zu einem Modul, das Benachrichtigungen für alle Anforderungen an die Anwendung erhält.

4. Implementieren Sie zuerst die Eigenschaft IsReusable. Da unser Handler keine Memberzustände für die Anforderungen speichert und in der Lage sein wird, mehrere Aufrufe von ProcessRequest() mit unterschiedlichen Anforderungen zu unterstützen, markieren wir ihn als wiederverwendbar, indem wir „true“ zurückgeben.

   public bool IsReusable
   {
       get { return true; }
   

5. Zum Abschluss implementieren wir die Methode ProcessRequest(), damit unser Handler tatsächlich etwas Nützliches tut. Um die Dinge schön einfach zu halten, gibt unser Handler die aktuelle Zeit auf dem Server zurück und erlaubt optional die Angabe der Zeitzone im Abfrage-String. Unser Ziel ist es, eine URL wie http://myserver/time.tm anzufordern und die aktuelle Zeit auf dem Server abzurufen. Außerdem können wir durch die Anforderung von http://myserver/time.tm?utc=true die universelle koordinierte Zeit erhalten. Hier ist unsere Implementierung:

   public void ProcessRequest(HttpContext context) 
   { 
       DateTime dt; 
       String useUtc = context.Request.QueryString["utc"]; 
       if (!String.IsNullOrEmpty(useUtc) && 
               useUtc.Equals("true")) 
       { 
           dt = DateTime.UtcNow; 
       } 
       else 
       { 
           dt = DateTime.Now; 
       } 
       context.Response.Write( 
           String.Format( "<h1>{0}</h1>", 
                          dt.ToLongTimeString() 
                          ) ); 
   }
   

   Wir verwenden die Sammlung HttpRequest.QueryString, um eine QueryString-Variable abzurufen, und schreiben die aktuelle Zeit mit der Methode HttpResponse.Write in die Antwort. Dies ist nur ein Beispiel für die Dinge, die Sie in Ihrem Handler tun können. Die Klasse HttpRequest liefert viel mehr Informationen über die Anforderung und die Klasse HttpResponse bietet eine Reihe verschiedener Möglichkeiten, die an den Client zurückgegebene Antwort zu gestalten.

   

Der Handler ist fertig.

Code abgeschlossen: Kompilieren des Moduls/Handlers

Nachdem das Modul und der Handler implementiert wurden, können wir sie in eine Assembly kompilieren, die ASP.NET zur Runtime laden kann. Wenn Sie Visual Studio oder Visual Studio Express verwenden, kompilieren Sie das Projekt direkt aus dem Tool, indem Sie „STRG-UMSCHALT-B“ drücken oder mit der rechten Maustaste auf das Projekt klicken und „Erstellen“ auswählen.

Die .DLL-Assembly wird zusammen mit der .PDB-Symboldatei im Ordner <ProjectDirectory>\bin\debug generiert, die Sie zum Debuggen der Assembly auf dem Server verwenden können – einschließlich der Quellcodezeilen in Ausnahmen während der Debugging-Phase Ihres Projekts.

Wenn Sie Ihre Assembly auf einen Produktionsserver hochladen, müssen Sie die Konfiguration der Projektmappe in „Release“ ändern. Klicken Sie dazu mit der rechten Maustaste auf den Projektmappenknoten, wählen Sie Configuration Manager und ändern Sie den Typ in „Debug“. Laden Sie die Release-Version der Assembly hoch (lassen Sie die PDB-Datei unverändert). Dadurch werden die Debugging-Informationen aus der Assembly entfernt und sie wird optimiert, was zu schnellerem Code führt.

Wenn Sie nicht Visual Studio verwenden, kompilieren Sie das Projekt mit dem C#-Befehlszeilen-Compiler, der in der Framework-Laufzeitumgebung enthalten ist. Um Ihr Projekt zu kompilieren, öffnen Sie eine Befehlszeilen-Eingabeaufforderung (stellen Sie sicher, dass Sie die Befehlszeilen-Eingabeaufforderung mit der Option „Als Administrator ausführen“ ausführen, wenn Sie mit Windows Vista oder Windows Server 2008 arbeiten):

> %windir%\Microsoft.NET\Framework\v2.0.50727\csc.exe /t:library /out:MyIIS7Project.dll /debug \*.cs /r:System.Web.dll

Dies erzeugt die Dateien MyIIS7Project.DLL und MyIIS7Project.PDB. Wenn Sie eine Release-Version der Assembly erstellen möchten, lassen Sie die Option /debug weg und fügen die Option /o hinzu, um die Assembly zu optimieren.

Bereitstellen der Assembly auf dem Server

Nachdem wir nun das benutzerdefinierte Modul und den Handler implementiert haben, stellen wir sie in unserer Webanwendung bereit. Es gibt eine Reihe von Möglichkeiten, ein Modul oder einen Handler in der Anwendung bereitzustellen, und eine Reihe von Konfigurationsoptionen, mit denen Sie die Bereitstellung an Ihre Bedürfnisse anpassen können. Im Folgenden werden die grundlegendsten Schritte der Bereitstellung erläutert. Eine ausführliche Erläuterung der Bereitstellungs- und Konfigurationsoptionen, einschließlich der Bereitstellung eines Moduls/Handlers für den gesamten Server, finden Sie im nächsten Artikel dieser Reihe: Bereitstellung von IIS-Modulen und -Handlern (in Kürze verfügbar).

Bei den folgenden Schritten wird davon ausgegangen, dass Sie das Modul und den Handler für eine bestehende Anwendung auf Ihrem IIS-Server bereitstellen. Wenn Sie noch keine Anwendung erstellt haben, verwenden Sie die Stammanwendung der „Standardwebsite“, die sich normalerweise unter %systemdrive%\inetpub\wwwroot befindet. Im folgenden Beispiel stellen wir das Modul und den Handler für eine Anwendung mit dem Namen „myiis7project“ bereit, die sich auf der Standardwebsite befindet.

Um das Modul und den Handler bereitzustellen, stellen Sie Ihrer ASP.NET-Anwendung zunächst die Assembly zur Verfügung, die deren Implementierung enthält:

1. Kopieren Sie die zuvor kompilierte Assembly MyIIS7Project.dll in das Verzeichnis „/BIN“, das sich im Stammverzeichnis Ihrer Anwendung befindet. Wenn dieses Verzeichnis noch nicht vorhanden ist, erstellen Sie es.

2. Konfigurieren Sie das Modul und den Handler, die in der Anwendung geladen werden sollen. Öffnen Sie das IIS7-Verwaltungstool über das Startmenü, indem Sie in das Start-/Suchfeld inetmgr.exe eingeben und die Eingabetaste drücken. Doppelklicken Sie in dem Tool in der Strukturansicht links auf Ihren Serverknoten, erweitern Sie dann den Knoten „Sites“ und doppelklicken Sie auf die Site oder Anwendung, der Sie Ihr Modul und Ihren Handler hinzufügen möchten.

3. Wählen Sie das Funktionssymbol „Module“ und klicken Sie dann auf die Aktion „Verwaltetes Modul hinzufügen …“. Geben Sie in dem sich öffnenden Dialogfeld den Modulnamen (beliebig) und den vollqualifizierten Modultyp „MyIIS7Modules.MyModule“ ein. Beachten Sie, dass Sie auch den Typ im Dropdownfeld auswählen können, da das Tool die Assembly automatisch in den Container lädt und Typen erkennt, die die Schnittstelle IHttpModule implementieren. Drücken Sie OK, um das Modul hinzuzufügen.

   

4. Fügen Sie den Handler hinzu, indem Sie erneut auf den Website-/Anwendungsknoten klicken und das Featuresymbol „Handlerzuordnungen“ auswählen. Klicken Sie dann auf die Aktion „Verwalteten Handler hinzufügen“ und geben Sie im daraufhin angezeigten Dialogfeld „time.tm“ für Pfad, „MyIIS7Modules.MyHandler“ für den Typ und „MyHandler“ für den Namen (beliebig) an. Beachten Sie auch hier, dass der Typ im Dropdownmenü vorhanden ist, weil das Admin-Tool diesen Typ automatisch in Ihrer Assembly erkannt hat. Drücken Sie OK, um den Handler hinzuzufügen.

   

Die von den oben genannten Aktionen generierte Anwendungskonfiguration konfiguriert das Modul MyModule so, dass es in Ihre Anwendung geladen wird (wodurch er für alle Anforderungen ausgeführt werden kann) und ordnet den Handler MyHandler zu, um Anforderungen an die URL time.tm innerhalb der Anwendung zu verarbeiten.

Beachten Sie, dass Ihr Modul und Ihre Anwendung mit dieser Konfiguration nur in Anwendungen im integrierten IIS-Modus ausgeführt werden können. Wenn Sie möchten, dass das Modul und der Handler auch in Anwendungen im klassischen Modus auf dem IIS und auch auf früheren Versionen des IIS ausgeführt werden, müssen Sie auch die klassische ASP.NET-Konfiguration für das Modul und den Handler hinzufügen. Wenn Ihr Handler im klassischen Modus auf IIS oder auf früheren Versionen von IIS ausgeführt wird, müssen Sie außerdem eine Skript-Map erstellen, die die Erweiterung .tm in IIS-Skriptzuordnungen auf ASP.NET abbildet, und Ihr Modul wird nur für Anforderungen an Erweiterungen ausgeführt, die auf ASP.NET abgebildet sind. Weitere Informationen hierzu finden Sie unter Bereitstellen von IIS-Modulen und -Handlern (in Kürze verfügbar).

Sie können das Modul und den Handler auch mit dem IIS-Befehlszeilentool AppCmd.exe hinzufügen oder indem Sie die IIS-Konfiguration über ein Skript oder verwalteten Code bearbeiten oder die Konfiguration direkt in die Datei web.config einfügen. Diese zusätzlichen Optionen werden unter Bereitstellung von IIS-Modulen und -Handlern (in Kürze verfügbar) ausführlich behandelt.

Testen des Moduls und des Handlers

Wir haben das Modul/den Handler bereitgestellt und konfiguriert. Jetzt können Sie sie testen:

1. Testen Sie unseren Handler, indem Sie in unserer Anwendung eine Anforderung an „time.tm“ stellen. Bei erfolgreicher Ausführung wird die aktuelle Uhrzeit auf dem Server angezeigt. Senden Sie eine Anforderung an Ihre Anwendung, z. B. http://localhost/myiis7project/time.tm so wie wir den Handler für die Anwendung myiis7project in der Standardwebsite bereitgestellt haben:

   Wenn der Handler ordnungsgemäß für diese Anwendung bereitgestellt wurde, wird die aktuelle Uhrzeit auf dem Server angezeigt:

   

   Versuchen Sie auch, http://localhost/myiis7project/time.tm?utc=true anzufordern, um die Uhrzeit in UTC anzuzeigen.

2. Testen Sie das Modul. Erstellen Sie in Ihrer Anwendung eine einfache HTML-Seite mit dem Namen page.html, die eine Verknüpfung mit der URL „/time.tm“ herstellt:

   page.html

   <html>
     <body>
         <a href="time.tm">View current server time</a>
     </body>
   </html>
   

   Senden Sie dann eine Anforderung an http://localhost/myiis7project/page.html, um den Link anzuzeigen. Wenn Sie auf den Link klicken, erhalten Sie einen Fehler:

   

   Sie werden sich vielleicht wundern, dass wir gerade oben dieselbe URL angefordert haben und die Zeit erfolgreich angezeigt wurde. Das liegt daran, dass unser Modul so konfiguriert ist, dass es Anforderungen an Ihre Anwendung zurückweist, die einen Referrer-Header angeben, der vom Browser hinzugefügt wird, wenn jemand auf einen Link klickt, um zu Ihrer Website zu gelangen, anstatt die URL direkt in den Browser einzugeben. Als Sie die URL also direkt angefordert haben, konnten Sie darauf zugreifen – als Sie jedoch einem Link von einer anderen Seite gefolgt sind, wurde Ihre Anforderung von unserem Modul abgelehnt.

Zusammenfassung

In diesem Artikel haben wir die grundlegenden Schritte zum Entwickeln eines IIS-Moduls und -Handlers mit den bekannten ASP.NET-APIs und deren Bereitstellung für Ihre Anwendung erläutert. Wir haben auch besprochen, welche Entwicklungsumgebungen Ihnen zur Wahl stehen und wie Sie entscheiden, wann Sie ein Modul und wann einen Handler erstellen sollten. Mit den Informationen in diesem Artikel sollten Sie in der Lage sein, Ihre ersten Module und Handler zu erstellen, um Ihre IIS-Anwendungen zu verbessern.

Unter Entwickeln eines Moduls mit .NET finden Sie ein Beispielmodul, das die Basisauthentifizierung über ASP.NET-Mitgliedschaftsanbieter ermöglicht.

Sehen Sie sich weitere Beispiele dafür an, wie verwaltete IIS-Module und -Handler Ihre Anwendungen aufwerten können, und laden Sie sie für Ihre Anwendung herunter. Besuchen Sie dazu Umleiten von Anforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, Erstellen von ansprechenden Verzeichnislisten für Ihre IIS-Website mit dem DirectoryListingModule und Anzeigen attraktiver Dateisymbole in Ihren ASP.NET-Anwendungen mit IconHandler.