DefaultHttpHandler Klasse

Definition

public ref class DefaultHttpHandler : System::Web::IHttpAsyncHandler

public class DefaultHttpHandler : System.Web.IHttpAsyncHandler

type DefaultHttpHandler = class
    interface IHttpAsyncHandler
    interface IHttpHandler

Public Class DefaultHttpHandler
Implements IHttpAsyncHandler

Vererbung

Object

DefaultHttpHandler

Implementiert

IHttpAsyncHandler IHttpHandler

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie ein angepasster HTTP-Handler implementiert wird, indem er von der DefaultHttpHandler Klasse abgeleitet wird.

public class AsyncDefaultHttpHandler : DefaultHttpHandler
{
    private HttpContext _context;

    public override IAsyncResult BeginProcessRequest(
      HttpContext context, AsyncCallback callback, object state)
    {
        AsyncResultSample ar = new AsyncResultSample(callback, state);
        _context = context;

        return ar;
    }

    public override void EndProcessRequest(IAsyncResult result)
    {
        _context.Response.Write("EndProcessRequest called.");
    }

    // This method should not be called asynchronously.
    public override void ProcessRequest(HttpContext context)
    {
        throw new InvalidOperationException(
                  "Asynchronous processing failed.");
    }

    // Enables pooling when set to true
    public override bool IsReusable
    {
        get { return true; }
    }
}

// Tracks state between the begin and end calls.
class AsyncResultSample : IAsyncResult
{
    private AsyncCallback callback = null;
    private Object asyncState;
    private Boolean isCompleted;

    internal AsyncResultSample(AsyncCallback cb, Object state)
    {
        this.callback = cb;
        asyncState = state;
        isCompleted = false;
    }

    public object AsyncState
    {
        get
        {
            return asyncState;
        }
    }

    public bool CompletedSynchronously
    {
        get
        {
            return false;
        }
    }

    public WaitHandle AsyncWaitHandle
    {
        get
        {
            throw new InvalidOperationException(
                      "ASP.NET should not use this property .");
        }
    }

    public bool IsCompleted
    {
        get
        {
            return isCompleted;
        }
    }

    internal void SetCompleted()
    {
        isCompleted = true;
        if (callback != null)
        {
            callback(this);
        }
    }
}

Public Class defaulthttpexampleVB
    Inherits DefaultHttpHandler

    Private _context As HttpContext

    Public Overrides Function BeginProcessRequest _
        (ByVal context As HttpContext, _
         ByVal callback As AsyncCallback, _
         ByVal state As Object) As IAsyncResult

        Dim ar As New AsyncResultSample(callback, state)
        _context = context

        Return (ar)
    End Function

    Public Overrides Sub EndProcessRequest(ByVal result As IAsyncResult)
        _context.Response.Write("EndProcessRequest called.")
    End Sub

    ' This method should not be called asynchronously.
    Public Overrides Sub ProcessRequest(ByVal context As HttpContext)
        Throw New InvalidOperationException _
          ("Asynchronous processing failed.")
    End Sub

    ' Enables pooling when set to true
    Public Overrides ReadOnly Property IsReusable() As Boolean
        Get
            Return True
        End Get
    End Property
End Class

' Tracks state between the begin and end calls.
Class AsyncResultSample
    Implements IAsyncResult
    Private callback As AsyncCallback = Nothing
    Private _asyncState As Object
    Private _isCompleted As Boolean

    Friend Sub New(ByVal cb As AsyncCallback, ByVal state As Object)
        Me.callback = cb
        _asyncState = state
        _isCompleted = False
    End Sub

    Public ReadOnly Property AsyncState() As Object _
      Implements IAsyncResult.AsyncState
        Get
            Return _asyncState
        End Get
    End Property

    Public ReadOnly Property CompletedSynchronously() _
      As Boolean Implements IAsyncResult.CompletedSynchronously
        Get
            Return False
        End Get
    End Property

    Public ReadOnly Property AsyncWaitHandle() _
      As WaitHandle Implements IAsyncResult.AsyncWaitHandle
        Get
            Throw New InvalidOperationException _
              ("ASP.NET should not use this property .")
        End Get
    End Property

    Public ReadOnly Property IsCompleted() _
      As Boolean Implements IAsyncResult.IsCompleted
        Get
            Return IsCompleted
        End Get
    End Property

    Friend Sub SetCompleted()
        _isCompleted = True
        If (callback <> Nothing) Then
            callback(Me)
        End If
    End Sub
End Class

Hinweise

Ein DefaultHttpHandler-Objekt fängt eingehende Anforderungen in der HTTP-Pipeline ab, wenn beide Anforderungsinterception über Internetinformationsdienste (IIS) 6.0 konfiguriert wurden und keine expliziten Bindungen für die angeforderte Erweiterung gelten.

Die Anforderungsabnahme kann über das in IIS 6.0 eingeführte Wildcard-Anwendungszuordnungsfeature eingerichtet werden.

Die DefaultHttpHandler Klasse implementiert die IHttpAsyncHandler Schnittstelle, um eine asynchrone Anforderungsverarbeitung bereitzustellen. Allgemeine Informationen zu HTTP-Handlern finden Sie in der Übersicht über HTTP-Handler und HTTP-Module. Weitere Informationen finden Sie darüber hinaus in den folgenden Themen:

• Informationen zum Erstellen asynchroner HTTP-Handler finden Sie unter Exemplarische Vorgehensweise: Erstellen eines asynchronen HTTP-Handlers.

• Informationen zum Registrieren von HTTP-Handlern finden Sie unter How to: Register HTTP Handlers.

Klassen können von der DefaultHttpHandler Klasse abgeleitet werden, um eine angepasste Behandlung von Anforderungen bereitzustellen. Ein asynchroner HTTP-Handler, der von der DefaultHttpHandler Methode abgeleitet wird, kann die BeginProcessRequest Methode überschreiben, um zu ändern, wie Anforderungen verarbeitet werden.

Ein DefaultHttpHandler verwendet keine ASP.NET Fehler. Vorhandene Inhalte, die IIS-Fehler oder einen benutzerdefinierten ISAPI-Fehlermechanismus verwenden, funktionieren unverändert.

Weitere Informationen

• Gewusst wie: Registrieren von HTTP-Handlern
• Gewusst wie: Erstellen eines asynchronen HTTP-Handlers