DefaultHttpHandler Klasse

Definition

Namespace:

System.Web

Assembly:

System.Web.dll

Stellt die Eigenschaften und Methoden eines HTTP-Standardhandlers dar.

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 Sie einen benutzerdefinierten HTTP-Handler implementieren, indem Sie von der DefaultHttpHandler -Klasse abgeleitet werden.

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 Anforderungsüberwachungen über Internetinformationsdienste (IIS) 6.0 konfiguriert wurden und keine expliziten Bindungen für die angeforderte Erweiterung gelten.

Das Abfangen von Anforderungen kann über das in IIS 6.0 eingeführte Feature für die Zuordnung von Feldhalteranwendungen eingerichtet werden.

Die DefaultHttpHandler -Klasse implementiert die IHttpAsyncHandler Schnittstelle, um eine asynchrone Anforderungsverarbeitung bereitzustellen. Allgemeine Informationen zu HTTP-Handlern finden Sie unter Übersicht über HTTP-Handler und HTTP-Module. Weitere Informationen finden Sie außerdem in den folgenden Artikeln:

• 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 Vorgehensweise: Registrieren von HTTP-Handlern.

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

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

Konstruktoren

DefaultHttpHandler()

Initialisiert eine neue Instanz der DefaultHttpHandler-Klasse.

Eigenschaften

Context	Ruft den Kontext ab, der dem aktuellen DefaultHttpHandler-Objekt zugeordnet ist.
ExecuteUrlHeaders	Ruft eine Auflistung der Anforderungsheader und Anforderungswerte ab, die mit der Anforderung übertragen werden.
IsReusable	Ruft einen booleschen Wert ab, der angibt, dass eine andere Anforderung die aktuelle Instanz der DefaultHttpHandler-Klasse verwenden kann.

Methoden

BeginProcessRequest(HttpContext, AsyncCallback, Object)	Initialisiert einen asynchronen Aufruf des HTTP-Handlers.
EndProcessRequest(IAsyncResult)	Stellt eine Methode zum Beenden für einen asynchronen Prozess bereit.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnExecuteUrlPreconditionFailure()	Wird aufgerufen, wenn aufgrund von Vorbedingungen das DefaultHttpHandler-Objekt eine Anforderung nicht verarbeitet.
OverrideExecuteUrlPath()	Überschreibt die Ziel-URL für die aktuelle Anforderung.
ProcessRequest(HttpContext)	Aktiviert zum Verarbeiten der HTTP-Webanforderungen ein DefaultHttpHandler-Objekt.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• Vorgehensweise: Registrieren von HTTP-Handlern
• Vorgehensweise: Erstellen eines asynchronen HTTP-Handlers