Registrazione di gestori HTTP
Una volta creato un gestore HTTP personalizzato, è necessario configurare ASP.NET in modo da eseguire il mapping delle richieste HTTP in entrata per URL specifici sul nuovo gestore. Nella procedura riportata di seguito sono descritti i passaggi necessari.
Per registrare un gestore HTTP
Compilare e distribuire la classe .NET per il gestore HTTP nella directory \bin nella radice virtuale dell'applicazione.
Registrare il gestore HTTP sincrono o asincrono nel file di configurazione Web.config dell'applicazione. Nell'esempio riportato di seguito viene effettuato il mapping di tutte le richieste HTTP alle classi
MyHandler.New
eMyHandler.Fin
nell'assemblyMyHandler
, che si trova nel fileMyhandler.dll
.<configuration> <system.web> <httpHandlers> <add verb="*" path="MyHandler.New" type="MyHandler.New, MyHandlerAssembly" /> <add verb="*" path="*.myNewFileNameExtension" type="MyHandler.Fin, MyHandlerAssembly" /> </httpHandlers> <system.web> </configuration>
Le voci all'interno della sezione di configurazione <httpHandlers> hanno tre attributi, come indicato nella tabella seguente.
Attributo Descrizione Path L'attributo path può contenere un singolo percorso URL o una semplice stringa con carattere jolly (ad esempio, *.aspx). Type Specifica una combinazione di classi/assembly separati da virgole. In ASP.NET, la DLL dell'assembly viene cercata innanzitutto nella directory privata \bin dell'applicazione e quindi nella cache dell'assembly del sistema. Verb L'elenco dei verbi può corrispondere a un elenco separato da virgole di metodi HTTP (ad esempio, "GET, PUT, POST") o a un mapping di script di avvio (ad esempio, il carattere jolly * [asterisco]). Assicurarsi che l'estensione del nome file del gestore HTTP sia registrata in Internet Information Services (IIS).
Esempi di gestori HTTP
In questa sezione verranno forniti i seguenti esempi di codice:
- Gestore HTTP sincrono
- Gestore HTTP asincrono
- Handler factory HTTP
Gestore HTTP sincrono
Nel codice seguente viene illustrata l'elaborazione delle richieste per l'URL MyApp.MyHello in un'applicazione ASP.NET. Vengono quindi mostrate le modifiche al file di configurazione necessarie per la registrazione del gestore HTTP.
using System.Web;
public class HelloWorldHandler : IHttpHandler {
public void ProcessRequest(HttpContext context) {
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
// A file ending in .MyHello need not exist. This handler executes
// whenever a file ending in .MyHello is requested.
Response.Write("<html>");
Response.Write("<body>");
Response.Write("<h1> Hello from Synchronous custom handler. </h1>");
Response.Write("</body>");
Response.Write("</html>");
}
public bool IsReusable {
// To enable pooling, return true here.
// This keeps the handler in memory.
get { return false; }
}
}
[Visual Basic]
Imports System.Web
Public Class HelloWorldHandler
Implements IHttpHandler
Public Sub ProcessRequest(ByVal context As System.Web.HttpContext) Implements System.Web.IHttpHandler.ProcessRequest
Dim request As HttpRequest = context.Request
Dim response As HttpResponse = context.Response
' A file named ending in .MyHello need not exist. This handler
' executes whenever a file ending in .MyHello is requested.
response.Write("<html>")
response.Write("<body>")
response.Write("<h1> Hello from Synchronous custom handler. </h1>")
response.Write("</body>")
response.Write("</html>")
End Sub
Public ReadOnly Property IsReusable() As Boolean Implements System.Web.IHttpHandler.IsReusable
Get
Return False
End Get
End Property
End Class
Registrare il gestore HTTP personalizzato creando una voce in Web.config come indicato di seguito:
<configuration>
<system.web>
<httpHandlers>
<add verb="*" path="*.MyHello"
type="HelloWorldHandler,httpruntime" />
</httpHandlers>
</system.web>
</configuration>
Gestore HTTP asincrono
Nel codice seguente viene illustrata la registrazione e l'elaborazione delle richieste per l'URL *.MyAsynch in un'applicazione ASP.NET. In questo caso, il gestore avvia un processo che richiede parecchio tempo, inviando una risposta all'utente in vari momenti per indicare lo stato di avanzamento dell'operazione. Vengono quindi mostrate le modifiche al file di configurazione necessarie per la registrazione del gestore HTTP.
using System;
using System.Web;
using System.Threading;
namespace Handlers
{
class AsynchHandler : IHttpAsyncHandler
{
private HttpContext _context;
public bool IsReusable
{
get
{
// To enable pooling, return true here.
// This keeps the handler in memory.
return false;
}
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData)
{
// Now do something that might take a while.
MyAsynchOperation asynch = new MyAsynchOperation(cb, context);
asynch.KickOffThread();
context.Response.Write("BeginProcessRequest. Just kicked off a Thread.<br>");
context.Response.Flush();
// Signal the application that asynchronous
// processing is being performed.
SomeResult asynchForBegin = new SomeResult();
// Processing is not synchronous.
asynchForBegin.SetSynch(false);
// Processing is not complete.
asynchForBegin.SetCompleted(false);
_context = context;
return new SomeResult();
}
public void EndProcessRequest(IAsyncResult result)
{
_context.Response.Write("EndProcessRequest called.<br>");
}
// This method is required but is not called.
public void ProcessRequest(HttpContext context)
{
}
}//end class
public class SomeResult : IAsyncResult
{
/*
An instance of this class is returned to the application.
This class lets the application know how the BeginEventHandler method
has been handled. The application checks the CompletedSynchronously
method.
*/
private bool _blnIsCompleted = false;
private Mutex myMutex = null;
private Object myAsynchStateObject = null;
private bool _blnCompletedSynchronously = false;
public void SetCompleted(bool blnTrueOrFalse)
{
_blnIsCompleted = blnTrueOrFalse;
}
public void SetSynch(bool blnTrueOrFalse)
{
_blnCompletedSynchronously = blnTrueOrFalse;
}
public bool IsCompleted
{
// This is not called by the application.
// However, set it to true.
get { return _blnIsCompleted; }
}
public WaitHandle AsyncWaitHandle
{
// The application does not call this method.
get { return myMutex; }
}
public Object AsyncState
{
// The application does not call this method because
// null is passed in as the last parameter to
// BeginEventHandler.
get { return myAsynchStateObject; }
}
public bool CompletedSynchronously
{
// The application wants to know if this is synchronous.
// Return true if the Begin method was called synchronously.
get { return _blnCompletedSynchronously; }
}
}
}
[Visual Basic]
Imports System
Imports System.Web
Imports System.Threading
Namespace handler
Public Class AsynchHandler
Implements IHttpAsyncHandler
Private _context As HttpContext
Public ReadOnly Property IsReusable() As Boolean Implements System.Web.IHttpAsyncHandler.IsReusable
Get
Return False
End Get
End Property
Public Function BeginProcessRequest(ByVal context As System.Web.HttpContext, ByVal cb As System.AsyncCallback, ByVal extraData As Object) As System.IAsyncResult Implements System.Web.IHttpAsyncHandler.BeginProcessRequest
Dim asynch As New MyAsynchOperation(cb, context)
asynch.KickOffThread()
context.Response.Write("BeginProcessRequest. Just kicked off a Thread.<br>")
context.Response.Flush()
' Signal the application that asynchronous
' processing is being performed.
Dim asynchForBegin As New SomeResult()
' Processing is not synchronous.
asynchForBegin.SetSynch(False)
' Processing is not complete.
asynchForBegin.SetCompleted(False)
_context = context
Return New SomeResult()
End Function
Public Sub EndProcessRequest(ByVal result As System.IAsyncResult) Implements System.Web.IHttpAsyncHandler.EndProcessRequest
_context.Response.Write("EndProcessRequest called.<br>")
End Sub
Public Sub ProcessRequest(ByVal context As System.Web.HttpContext) Implements System.Web.IHttpAsyncHandler.ProcessRequest
' Ths is required but is not called.
End Sub
End Class
Class SomeResult
Implements IAsyncResult
Private _blnIsCompleted As Boolean = False
Private myMutex As Mutex = Nothing
Private myAsynchStateObject As Object = Nothing
Private _blnCompletedSynchronously As Boolean = False
Public Sub SetCompleted(ByVal blnTrueOrFalse As Boolean)
_blnIsCompleted = blnTrueOrFalse
End Sub
Public Sub SetSynch(ByVal blnTrueOrFalse As Boolean)
_blnCompletedSynchronously = blnTrueOrFalse
End Sub
Public ReadOnly Property AsyncState() As Object Implements System.IAsyncResult.AsyncState
Get
Return myAsynchStateObject
End Get
End Property
Public ReadOnly Property AsyncWaitHandle() As System.Threading.WaitHandle Implements System.IAsyncResult.AsyncWaitHandle
Get
Return myMutex
End Get
End Property
Public ReadOnly Property CompletedSynchronously() As Boolean Implements System.IAsyncResult.CompletedSynchronously
Get
Return _blnCompletedSynchronously
End Get
End Property
Public ReadOnly Property IsCompleted() As Boolean Implements System.IAsyncResult.IsCompleted
Get
Return _blnIsCompleted
End Get
End Property
End Class
End Namespace
Registrare il gestore HTTP asincrono personalizzato creando una voce in Web.config come indicato di seguito:
<configuration>
<system.web>
<httpHandlers>
<add verb="GET,POST" path="*.MyAsynch"
type="Handlers.AsynchHandler, Handlers" />
</httpHandlers>
</system.web>
</configuration>
Vedere anche
Supporto HTTP in fase di esecuzione | Elaborazione delle richieste in ASP.NET | Creazione di gestori HTTP | Moduli HTTP | Gestione e generazione di eventi