Sviluppo di moduli e gestori IIS 7.0 con .NET Framework

  • Articolo

di Mike Volodarsky

Panoramica

Questo articolo è incentrato sullo sviluppo di funzionalità del server Web IIS 7.0 e successive basate su .NET Framework. Questo articolo illustra:

  1. Come decidere se sviluppare un modulo IIS o un gestore IIS
  2. Come configurare l'ambiente di sviluppo con Visual Studio, Visual C# Express o strumenti da riga di comando forniti con .NET Framework
  3. Come creare il primo progetto
  4. Come sviluppare un modulo e un gestore semplici
  5. Come distribuire un modulo e un gestore semplici in un server IIS

Per visualizzare alcuni moduli e gestori IIS gestiti in un mondo reale e scaricarli per l'applicazione, visitare Reindirizzare le richieste all'applicazione con il modulo HttpRedirection, Ottenere elenchi di directory interessanti per il sito Web IIS con DirectoryListingModule e Visualizzare le icone di file nelle applicazioni ASP.NET con IconHandler.

Introduzione: Sviluppo di funzionalità IIS con ASP.NET

Le versioni di IIS precedenti a IIS 7.0 in primo piano in un'API C, denominata ISAPI, come API di estendibilità primaria per la creazione di funzionalità del server Web. IIS 7.0 e versioni successive sono stati ricompilati a livello di base per fornire una nuova API C++, in cui tutte le funzionalità in-the-box sono basate, per consentire l'estendibilità completa del runtime del server Web.

Oltre a questo, IIS per la prima volta offre anche un'API .NET completa per estendere il server Web, sfruttando una stretta integrazione con ASP.NET 2.0. A questo scopo, è ora possibile estendere IIS con nuove funzionalità del server Web compilate con le API ASP.NET 2.0 familiari. Analogamente, è possibile usare moduli e gestori esistenti ASP.NET 2.0 in IIS, sfruttando ASP.NET integrazione per migliorare la potenza dell'applicazione senza scrivere alcun nuovo codice. Per altre informazioni sull'integrazione ASP.NET in IIS, vedere Integrazione ASP.NET con IIS 7.

Strumenti del commercio: decidere l'ambiente di sviluppo

Per compilare moduli e gestori IIS, usare qualsiasi ambiente che consente di sviluppare e compilare assembly .NET. Alcune delle opzioni comuni sono:

  1. Visual Studio 2005. In alternativa, è anche possibile scaricare la versione beta più recente di Visual Studio 2008.
  2. Visual C# 2005 Express Edition, download gratuito (o altri strumenti Express, inclusi Visual Basic 2005 Express).
  3. Il compilatore della riga di comando C# (csc.exe) incluso nel runtime di .NET Framework (per altri linguaggi, sarà necessario scaricare l'SDK), oltre all'editor di origine preferito.

Gli esempi in questo articolo usano C#, anche se è possibile sviluppare componenti IIS in qualsiasi altro linguaggio .NET supportato (ad eccezione di C++gestito). L'articolo illustra come sviluppare componenti di estendibilità IIS con tutti e tre gli ambienti precedenti.

Nota

Poiché IIS sfrutta le API di ASP.NET esistenti per la relativa estendibilità .NET, è possibile sviluppare moduli e gestori IIS .NET con .NET Framework 2.0 in Windows XP® e Windows Server® 2003. Tuttavia, se si prevede di usare una delle nuove API di ASP.NET aggiunte per supportare nuove funzionalità IIS, è necessario sviluppare in Windows Vista o ottenere la versione di System.Web.dll da Windows Vista® o la versione più recente di .NET Framework 3.5 per compilare il codice.

Due modi per estendere IIS: Module vs Handler

Tutte le funzionalità del server Web IIS si adattano a due categorie: moduli e gestori.

Un modulo, simile al filtro ISAPI nelle versioni precedenti di IIS, partecipa all'elaborazione della richiesta di ogni richiesta per modificarla o aggiungerla in qualche modo. Alcuni esempi di moduli in-the-box in IIS includono moduli di autenticazione, che modificano lo stato di autenticazione della richiesta, i moduli di compressione che comprimono la risposta in uscita e registrano i moduli che registrano le informazioni sulla richiesta ai log delle richieste.

Il modulo è una classe .NET che implementa l'interfaccia ASP.NET System.Web.IHttpModule e usa le API nello spazio dei nomi System.Web per partecipare a una o più di ASP. Fasi di elaborazione delle richieste di NET.

Un gestore, simile all'estensione ISAPI nelle versioni precedenti di IIS, è responsabile della gestione della richiesta e della produzione della risposta per tipi di contenuto specifici. La differenza principale tra il modulo e il gestore è che il gestore viene in genere mappato a un determinato percorso o estensione della richiesta e supporta l'elaborazione di una risorsa server specifica a cui corrisponde il percorso o l'estensione. Esempi di gestori forniti con IIS includono ASP, che elabora script ASP, il gestore file statico, che serve file statici e ASP. PageHandler di NET che elabora pagine ASPX.

Il gestore è una classe .NET che implementa l'ASP.NET interfaccia System.Web.IHttpHandler o System.Web.IHttpAsyncHandler e usa le API nello spazio dei nomi System.Web per produrre una risposta http per il contenuto specifico supportato.

Quando si prevede di sviluppare una funzionalità IIS, la prima domanda che è necessario porre è se questa funzionalità è responsabile della gestione delle richieste a un URL/estensione specifico o si applica a tutte le/alcune richieste in base alle regole arbitrarie. Nel caso precedente, il gestore deve essere un gestore e in quest'ultimo un modulo.

Questo articolo illustra la creazione di un modulo semplice e un gestore semplice, i passaggi comuni per la creazione del progetto e la compilazione e i passaggi specifici per la distribuzione nel server.

Nota

Non è necessario sviluppare un gestore se si sta sviluppando un modulo e il visto-versa.

Introduzione: Creazione del progetto di Visual Studio

Per compilare un modulo o un gestore, è necessario produrre un assembly .NET (DLL) contenente le classi module/handler. Se si usa Visual Studio o Visual Studio Express strumenti, il primo passaggio consiste nella creazione di un progetto libreria di classi:

  1. Dal menu "File" selezionare "Nuovo", "Progetto ...". Nella finestra di dialogo Nuovo progetto (di seguito) selezionare il tipo di progetto "Visual C#" e selezionare "Libreria classi" nell'elenco a destra dei modelli installati da Visual Studio.

    Creare un modulo IIS7 e un progetto del gestore in Visual Studio

  2. È necessario aggiungere un riferimento all'assembly "System.Web.dll" che contiene le API usate per sviluppare moduli e gestori IIS ASP.NET. Fare clic con il pulsante destro del mouse sul nodo "Riferimenti" nella visualizzazione albero di Esplora soluzioni a destra, scegliere "Aggiungi riferimento ..." e nella scheda .NET selezionare l'assembly System.Web versione 2.0 (sotto).

    Aggiungere riferimento a System.Web.dllAggiungere riferimento

Nota

È possibile usare l'assembly System.Web versione 2.0 in Windows XP e Windows Server 2003 se non si prevede di sfruttare le API specifiche di IIS ASP.NET. I moduli e i gestori compilati a riferimento di questo assembly possono essere distribuiti e gestiti in IIS in Windows Vista e Windows Server 2008 senza problemi. Se si desidera usare le poche API specifiche di IIS ASP.NET nel modulo, è necessario sviluppare in Windows Vista, Windows Server 2008 o ottenere l'assembly System.Web.dll da .NET Framework 3.5. Le API specifiche di IIS includono HttpServerUtility.TransferRequest, l'insieme HttpResponse.Headers, l'evento HttpApplication.LogRequest e diversi altri.

Scrittura di codice: creazione di un modulo semplice

La prima attività consiste nel creare un modulo semplice. Più avanti nell'articolo viene compilato anche un gestore di esempio.

Per creare un modulo, definire una classe che implementa l'interfaccia System.Web.IHttpModule .

  1. Eliminare il file "class1.cs" generato dal sistema di progetto e aggiungere una nuova classe C# denominata MyModule facendo clic con il pulsante destro del mouse sul progetto MyIIS7Project nella visualizzazione albero a destra, selezionando "Aggiungi", Nuovo elemento, scegliendo "Classe" e digitando "MyModule.cs" nel campo Nome.

  2. Importare lo spazio dei nomi System.Web in modo da poter accedere facilmente ai tipi.

  3. Rendere la classe MyModule implementare l'interfaccia IHttpModule e definire i membri dell'interfaccia Dispose() e Init(). Eseguire questa operazione rapidamente facendo clic con il pulsante destro del mouse sull'interfaccia IHttpModule e scegliendo l'opzione "Implement interface" (Implement interface):

    Una semplice classe IHttpModule in Visual Studio Una semplice classe

    Il metodo Dispose() è destinato a pulire le risorse non gestite deterministicamente quando il modulo viene scaricato, in modo che le risorse possano essere rilasciate prima che l'istanza del modulo venga finalizzata dal Garbage Collector. È possibile lasciare vuoto il metodo nella maggior parte dei casi.

    Il metodo Init(HttpApplication context) è il metodo principale di interesse. Il suo ruolo consiste nell'eseguire l'inizializzazione del modulo e collegare il modulo a uno o più eventi di elaborazione delle richieste disponibili nella classe HttpApplication . Durante l'elaborazione della richiesta, il modulo verrà richiamato per ogni evento sottoscritto, consentendo l'esecuzione e l'esecuzione del servizio. A tale scopo, eseguire queste operazioni:

  4. Sottoscrivere uno o più eventi di elaborazione delle richieste tramite il collegamento di un metodo nella classe del modulo a uno degli eventi nell'istanza httpApplication fornita. Il metodo deve seguire la firma del delegato System.EventHandler . Viene definito un nuovo metodo, denominato OnPreExecuteRequestHandler, che viene eseguito fino a HttpApplication. Evento PreRequestRequestHandlerExecute , che si verifica subito prima che il server stia per richiamare il gestore delle richieste per la richiesta:

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

    Implementare IHttpModule.Init() in Visual Studio Implementare IHttpModule.Init

    A questo punto, il modulo viene configurato per ricevere l'evento PreRequestHandlerExecute in ogni richiesta. È possibile ripetere questa operazione per tutti gli altri eventi che si desidera ricevere.

  5. A questo punto, i moduli fanno qualcosa di utile, qualcosa che illustra l'uso di alcune delle API di ASP.NET che un modulo potrebbe usare. Verificare se la richiesta specifica un'intestazione di referrer e, se lo fa, rifiutarlo, come modo sciocco per impedire agli utenti di collegare il sito Web da altri siti Web. Questa operazione verrà eseguita nel metodo OnPreRequestHandlerExecute che viene richiamato direttamente prima dell'esecuzione del gestore in ogni richiesta:

    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!"); 
   } 
}

    Implementare IHttpModule Implement IHttpModule

    Nota

    L'istanza di HttpApplication viene fornita al modulo tramite l'argomento di origine e richiede il cast. È possibile accedere al resto del modello a oggetti della richiesta dall'istanza di HttpApplication, ad esempio l'oggetto HttpContext e l'oggetto HttpRequest contenuto che rappresenta la richiesta.

Il codice precedente verifica se l'intestazione Referrer è stata specificata e, in tal caso, rifiuta la richiesta con un codice di errore non autorizzato 403.

Scrittura di codice: creazione di un gestore semplice

L'attività successiva consiste nel creare un semplice gestore. In precedenza nell'articolo è stato creato un modulo di esempio: tornare se si vuole leggere la compilazione di un modulo.

Per creare un gestore, è necessario definire una classe che implementa l'interfaccia System.Web.IHttpHandler (è anche possibile implementare System.Web.IHttpAsyncHandler se si vuole che la pagina venga eseguita in modo asincrono). A tale scopo, eseguire queste operazioni:

  1. Se non è già stato fatto, eliminare il file "class1.cs" generato dal sistema di progetto e aggiungere una nuova classe C# denominata MyHandler facendo clic con il pulsante destro del mouse sul progetto MyIIS7Project nella visualizzazione albero a destra, selezionando "Aggiungi", Nuovo elemento, scegliendo "Classe" e digitando "MyHandler.cs" nel campo Nome.

  2. Importare lo spazio dei nomi System.Web in modo da poter accedere facilmente ai tipi.

  3. Rendere la classe MyHandler implementare l'interfaccia IHttpHandler e definire i membri dell'interfaccia IsReusable e ProcessRequest(). È possibile eseguire questa operazione rapidamente facendo clic con il pulsante destro del mouse sull'interfaccia IHttpHandler e scegliendo l'opzione "Implement interface" (Implement interface):

    Implementare l'interfaccia IHttpHandler in Visual Studio Implementare l'interfaccia IHttpHandler

    IsReusable () indica se l'istanza del gestore può essere usata nuovamente per le richieste successive. In alcuni casi, dopo l'elaborazione della richiesta il gestore potrebbe essere in uno stato errato per elaborare un'altra richiesta, soprattutto se sono stati archiviati dati sulla richiesta precedente nelle variabili membro. Si noti che il runtime non userà mai la stessa istanza del gestore per elaborare due richieste contemporaneamente, anche se contrassegnata come riutilizzabile. Se il gestore non archivia uno stato per richiesta nelle variabili membro e può avere la relativa funzione ProcessRequest denominata quante volte necessario, rendere questa proprietà true per consentire il riutilizzo.

    Il metodo ProcessRequest () è il punto di ingresso principale del gestore. Il suo ruolo consiste nell'elaborare la richiesta specificata dall'istanza HttpRequest disponibile dall'istanza httpContext fornita e generare la risposta appropriata usando l'istanza HttpResponse disponibile anche su HttpContext. Il metodo ProcessRequest() verrà richiamato dal runtime durante la fase di elaborazione delle richieste ExecuteRequestHandler e SOLO SE la richiesta è stata mappata al gestore in base ai mapping dei gestori configurati. Questo è diverso da un modulo che riceve notifiche per tutte le richieste all'applicazione.

  4. Implementare prima la proprietà IsReusable . Poiché il gestore non archivierà alcun stato membro per la richiesta e sarà in grado di supportare più chiamate a ProcessRequest() con richieste diverse, verrà contrassegnato come riutilizzabile restituendo true.

    public bool IsReusable
{
    get { return true; }

  5. Infine, implementiamo il metodo ProcessRequest() per rendere effettivamente utile il gestore. Per mantenere le cose belle e semplici, il gestore restituirà l'ora corrente nel server, consentendo facoltativamente di specificare il fuso orario nella stringa di query. L'obiettivo è quello di poter richiedere un URL, ad esempio http://myserver/time.tm, e ottenere l'ora corrente nel server. Inoltre, saremo in grado di eseguire il tempo coordinato universale richiedendo http://myserver/time.tm?utc=true. Ecco l'implementazione:

    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() 
                       ) ); 
}

    Si usa l'insieme HttpRequest.QueryString per recuperare una variabile QueryString e scrivere il tempo corrente per la risposta usando il metodo HttpResponse.Write . Questo è solo un esempio dei tipi di operazioni che è possibile scegliere di eseguire nel gestore: la classe HttpRequest fornisce molte altre informazioni sulla richiesta e la classe HttpResponse fornisce diversi modi per modellare la risposta restituita al client.

    Implementare IHttpHandler.ProcessRequest in Visual Studio Implementare

Il gestore viene completato.

Codice completo: compilazione del modulo/gestore

Dopo aver implementato il modulo e il gestore, è possibile compilarli in un assembly che ASP.NET può essere caricato in fase di esecuzione. Se si usa Visual Studio o Visual Studio Express, compilare il progetto direttamente dallo strumento premendo "CTRL-MAIUSC-B" o facendo clic con il pulsante destro del mouse sul progetto e scegliendo "Compila".

L'assembly .DLL verrà generato nella <cartella ProjectDirectory>\bin\debug, insieme a . File di simboli PDB che è possibile usare per il debug dell'assembly nel server/ incluse le righe del codice sorgente nelle eccezioni durante la fase di debug del progetto.

Se si carica l'assembly in un server di produzione, assicurarsi di modificare la configurazione della soluzione in "Release" facendo clic con il pulsante destro del mouse sul nodo della soluzione, scegliendo Configuration Manager e modificando il tipo in Debug. Caricare la versione di rilascio dell'assembly (lasciare il file PDB dietro) : verrà eseguito il striping delle informazioni di debug dall'assembly e ottimizzarlo con un codice più veloce.

Se non si usa Visual Studio, compilare il progetto con il compilatore della riga di comando C# incluso nel runtime di Framework. Per compilare il progetto, aprire un prompt della riga di comando (assicurarsi di eseguire il prompt della riga di comando con l'opzione "Esegui come amministratore" se si è in Windows Vista o Windows Server 2008):

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

Questo produce i file MyIIS7Project.DLL e MyIIS7Project.PDB. Se si vuole compilare una versione di rilascio dell'assembly, omettere l'opzione /debug e includere l'opzione /o per ottimizzare l'assembly.

Distribuzione dell'assembly nel server

Dopo aver implementato il modulo e il gestore personalizzati, vengono distribuiti nell'applicazione Web. Esistono diversi modi per distribuire un modulo o un gestore nell'applicazione e diverse opzioni di configurazione che è possibile usare per personalizzare la distribuzione alle proprie esigenze. Di seguito vengono illustrati i passaggi di distribuzione più di base. Per una discussione avanzata sulle opzioni di distribuzione e configurazione, tra cui come distribuire un modulo/gestore per l'intero server, vedere l'articolo successivo della serie: Distribuzione di moduli e gestori IIS (presto disponibile).

I passaggi seguenti presuppongono che si distribuisca il modulo e il gestore in un'applicazione esistente nel server IIS. Se non è stata creata un'applicazione, usare l'applicazione radice del "Sito Web predefinito" in genere disponibile in %systemdrive%\inetpub\wwwroot. Nell'esempio seguente viene distribuito il modulo e il gestore in un'applicazione denominata "myiis7project" disponibile nel sito Web predefinito.

Per distribuire il modulo e il gestore, prima di tutto rendere l'assembly contenente l'implementazione disponibile per l'applicazione ASP.NET:

  1. Copiare l'assembly MyIIS7Project.dll compilato in precedenza nella directory /BIN situata nella radice dell'applicazione. Se questa directory non esiste, crearla.

  2. Configurare il modulo e il gestore da caricare nell'applicazione. Aprire lo strumento amministrazione IIS7 tramite il menu Start, digitando inetmgr.exenella casella di avvio/ricerca e premendo INVIO. Nello strumento fare doppio clic sul nodo server nella visualizzazione albero a sinistra, quindi espandere il nodo "Siti" e fare doppio clic sul sito o sull'applicazione a cui si desidera aggiungere il modulo e il gestore.

  3. Selezionare l'icona della funzionalità "Moduli", quindi fare clic sull'azione "Aggiungi modulo gestito ..." e nella finestra di dialogo risultante digitare il nome del modulo (arbitrario) e il tipo di modulo completo "MyIIS7Modules.MyModule". Si noti che è anche possibile selezionare il tipo nella casella a discesa, poiché lo strumento caricherà automaticamente l'assembly nel bin e individua i tipi che implementano l'interfaccia IHttpModule. Premere OK per aggiungere il modulo.

    Aggiunta di un modulo IIS7 Aggiunta di un modulo IIS7

  4. Aggiungere di nuovo il gestore facendo doppio clic sul nodo del sito o dell'applicazione e selezionando l'icona della funzionalità "Mapping gestore". Fare quindi clic sull'azione "Aggiungi gestore gestito" e nella finestra di dialogo risultante specificare "time.tm" per percorso, "MyIIS7Modules.MyHandler" per il tipo e "MyHandler" per il nome (arbitrario). Si noti di nuovo che il tipo è presente nella casella di riepilogo a discesa perché lo strumento Amministrazione ha rilevato automaticamente questo tipo nell'assembly. Premere OK per aggiungere il gestore.

    Aggiunta di un gestore IIS7 Aggiunta di un gestore IIS7

La configurazione dell'applicazione generata dalle azioni precedenti configura il modulo MyModule da caricare nell'applicazione (che consente l'esecuzione per tutte le richieste) e esegue il mapping del gestore MyHandler per elaborare le richieste all'URL di time.tm all'interno dell'applicazione.

Si noti che questa configurazione consente all'applicazione e al modulo di eseguire solo nelle applicazioni in modalità integrata IIS. Se si vuole che il modulo e il gestore vengano eseguiti anche nelle applicazioni in modalità classica in IIS e anche nelle versioni precedenti di IIS, è necessario aggiungere anche la configurazione di ASP.NET classica per il modulo e il gestore. Inoltre, quando viene eseguito in modalità classica in IIS o nelle versioni precedenti di IIS, il gestore richiede di creare un mapping di script mappando l'estensione .tm a ASP.NET nelle mappe script IIS e il modulo viene eseguito solo per le richieste di estensioni mappate a ASP.NET. Per altre informazioni su questo argomento, vedere Distribuzione di moduli e gestori IIS (presto disponibile).

È anche possibile aggiungere il modulo e il gestore usando lo strumento della riga di comando IIS, AppCmd.exeo modificando la configurazione IIS dallo script o dal codice gestito oppure inserendo la configurazione direttamente nel file web.config . Queste opzioni aggiuntive sono illustrate in modo approfondito nella distribuzione di moduli e gestori IIS (presto disponibile).

Test del modulo e del gestore

Sono stati distribuiti e configurati il modulo/gestore. A questo momento per testarli:

  1. Testare il gestore eseguendo una richiesta a "time.tm" nell'applicazione. In caso di esito positivo, viene visualizzata l'ora corrente nel server. Effettuare una richiesta all'applicazione, ad esempio http://localhost/myiis7project/time.tm quando è stato distribuito il gestore nell'applicazione myiis7project nel sito Web predefinito:

    Se il gestore viene distribuito correttamente in questa applicazione, viene visualizzato l'ora corrente nel server:

    Test del gestore IIS7 Test del gestore IIS7

    Provare anche a richiedere di visualizzare http://localhost/myiis7project/time.tm?utc=true l'ora in formato UTC.

  2. Testare il modulo. Creare una pagina HTML semplice denominata page.html nell'applicazione che collega all'URL /time.tm :

    page.html

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

    Effettuare quindi una richiesta per http://localhost/myiis7project/page.html visualizzare il collegamento. Quando si fa clic sul collegamento, si osserva un errore:

    Test del modulo IIS7 Test del modulo IIS7

    È possibile chiedere se non è stato richiesto solo lo stesso URL sopra e vedere correttamente l'ora. Questo perché il modulo è configurato per rifiutare le richieste all'applicazione che specificano un'intestazione referrer, che viene aggiunta dal browser ogni volta che un utente fa clic su un collegamento per passare al sito Web anziché digitarlo direttamente nell'URL del browser. Quindi, quando hai richiesto direttamente l'URL, sei stato in grado di accedervi, ma quando hai seguito un collegamento da un'altra pagina, la richiesta è stata rifiutata dal modulo.

Riepilogo

In questo articolo sono stati illustrati i passaggi di base per lo sviluppo di un modulo e un gestore IIS con le API di ASP.NET familiari e la distribuzione nell'applicazione. Sono state illustrate anche le scelte disponibili per l'ambiente di sviluppo e come decidere quando creare un modulo e un gestore. Le informazioni contenute in questo articolo devono consentire di creare i primi moduli e gestori per consentire alle applicazioni IIS.

È anche possibile esaminare un modulo di esempio che consente l'autenticazione di base su ASP. Provider di appartenenza di NET in Sviluppo di un modulo tramite .NET.

Assicurarsi di vedere altri esempi di come i moduli e i gestori IIS gestiti possono aggiungere valore alle applicazioni e scaricarli per l'applicazione visitando Le richieste di reindirizzamento all'applicazione con il modulo HttpRedirection, Ottenere elenchi di directory interessanti per il sito Web IIS con DirectoryListingModule e Visualizzare icone di file abbastanza nelle applicazioni di ASP.NET con IconHandler.