PageAsyncTask Klasse

Definition

Namespace:
System.Web.UI
Assembly:
System.Web.dll

Enthält Informationen zu einer asynchronen Aufgabe, die auf einer Seite registriert ist. Diese Klasse kann nicht vererbt werden.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Vererbung
Object
PageAsyncTask

Beispiele

Im folgenden Codebeispiel werden drei asynchrone Aufgaben auf einer Seite registriert und parallel ausgeführt. Jede Aufgabe ruft eine Methode auf, die lediglich den Thread für 5 Sekunden in den Ruhezustand bringt.

<%@ Page Language="C#" Async="true" AsyncTimeout="35"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">
    
  protected void Page_Load(object sender, EventArgs e)
  {
      
    // Define the asynchronuous task.
    Samples.AspNet.CS.Controls.SlowTask slowTask1 =    
      new Samples.AspNet.CS.Controls.SlowTask();
    Samples.AspNet.CS.Controls.SlowTask slowTask2 =
    new Samples.AspNet.CS.Controls.SlowTask();
    Samples.AspNet.CS.Controls.SlowTask slowTask3 =
    new Samples.AspNet.CS.Controls.SlowTask();
    
    // <Snippet3> 
    PageAsyncTask asyncTask1 = new PageAsyncTask(slowTask1.OnBegin, slowTask1.OnEnd, slowTask1.OnTimeout, "Async1", true);
    PageAsyncTask asyncTask2 = new PageAsyncTask(slowTask2.OnBegin, slowTask2.OnEnd, slowTask2.OnTimeout, "Async2", true);
    PageAsyncTask asyncTask3 = new PageAsyncTask(slowTask3.OnBegin, slowTask3.OnEnd, slowTask3.OnTimeout, "Async3", true);

    // Register the asynchronous task.
    Page.RegisterAsyncTask(asyncTask1);
    Page.RegisterAsyncTask(asyncTask2);
    Page.RegisterAsyncTask(asyncTask3);
    // </Snippet3>
      
    // Execute the register asynchronous task.
    Page.ExecuteRegisteredAsyncTasks();

    TaskMessage.InnerHtml = slowTask1.GetAsyncTaskProgress()+ "<br />" + slowTask2.GetAsyncTaskProgress() + "<br />" + slowTask3.GetAsyncTaskProgress();

  }
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    <title>Asynchronous Task Example</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
      <span id="TaskMessage" runat="server">
      </span>
    </div>
    </form>
</body>
</html>

<%@ Page Language="VB" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
      
        ' Define the asynchronuous task.
        Dim slowTask1 As New Samples.AspNet.VB.Controls.SlowTask()
        Dim slowTask2 As New Samples.AspNet.VB.Controls.SlowTask()
        Dim slowTask3 As New Samples.AspNet.VB.Controls.SlowTask()
     
        ' <Snippet3>
        Dim asyncTask1 As New PageAsyncTask(AddressOf slowTask1.OnBegin, AddressOf slowTask1.OnEnd, AddressOf slowTask1.OnTimeout, "Async1", True)
        Dim asyncTask2 As New PageAsyncTask(AddressOf slowTask2.OnBegin, AddressOf slowTask2.OnEnd, AddressOf slowTask2.OnTimeout, "Async2", True)
        Dim asyncTask3 As New PageAsyncTask(AddressOf slowTask3.OnBegin, AddressOf slowTask3.OnEnd, AddressOf slowTask3.OnTimeout, "Async3", True)

        ' Register the asynchronous task.
        Page.RegisterAsyncTask(asyncTask1)
        Page.RegisterAsyncTask(asyncTask2)
        Page.RegisterAsyncTask(asyncTask3)
        ' </Snippet3>
      
        ' Execute the register asynchronous task.
        Page.ExecuteRegisteredAsyncTasks()

        TaskMessage.InnerHtml = slowTask1.GetAsyncTaskProgress() + "<br />" + slowTask2.GetAsyncTaskProgress() + "<br />" + slowTask3.GetAsyncTaskProgress()

    End Sub
</script>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    <span id="TaskMessage" runat="server">
      </span>
    </div>
    </form>
</body>
</html>

using System;
using System.Web;
using System.Web.UI;
using System.Threading;

namespace Samples.AspNet.CS.Controls
{
    public class SlowTask
    {
        private String _taskprogress;
        private AsyncTaskDelegate _dlgt;

        // Create delegate.
        protected delegate void AsyncTaskDelegate();

        public String GetAsyncTaskProgress()
        {
            return _taskprogress;
        }
        public void ExecuteAsyncTask()
        {
            // Introduce an artificial delay to simulate a delayed 
            // asynchronous task.
            Thread.Sleep(TimeSpan.FromSeconds(5.0));
        }

        // Define the method that will get called to
        // start the asynchronous task.
        public IAsyncResult OnBegin(object sender, EventArgs e,
            AsyncCallback cb, object extraData)
        {
            _taskprogress = "AsyncTask started at: " + DateTime.Now + ". ";

            _dlgt = new AsyncTaskDelegate(ExecuteAsyncTask);
            IAsyncResult result = _dlgt.BeginInvoke(cb, extraData);

            return result;
        }

        // Define the method that will get called when
        // the asynchronous task is ended.
        public void OnEnd(IAsyncResult ar)
        {
            _taskprogress += "AsyncTask completed at: " + DateTime.Now;
            _dlgt.EndInvoke(ar);
        }

        // Define the method that will get called if the task
        // is not completed within the asynchronous timeout interval.
        public void OnTimeout(IAsyncResult ar)
        {
            _taskprogress += "AsyncTask failed to complete " +
                "because it exceeded the AsyncTimeout parameter.";
        }
    }
}

Imports System.Threading

Namespace Samples.AspNet.VB.Controls

    Public Class SlowTask
        Private _taskprogress As String
        Private _dlgt As AsyncTaskDelegate

        ' Create delegate.
        Protected Delegate Sub AsyncTaskDelegate()

        Public Function GetAsyncTaskProgress() As String
            Return _taskprogress
        End Function

        Public Sub ExecuteAsyncTask()
            ' Introduce an artificial delay to simulate a delayed 
            ' asynchronous task.
            Thread.Sleep(TimeSpan.FromSeconds(5.0))
        End Sub

        ' Define the method that will get called to
        ' start the asynchronous task.
        Public Function OnBegin(ByVal sender As Object, ByVal e As EventArgs, ByVal cb As AsyncCallback, ByVal extraData As Object) As IAsyncResult
            _taskprogress = "AsyncTask started at: " + DateTime.Now.ToString + ". "

            _dlgt = New AsyncTaskDelegate(AddressOf ExecuteAsyncTask)
            Dim result As IAsyncResult = _dlgt.BeginInvoke(cb, extraData)

            Return result
        End Function

        ' Define the method that will get called when
        ' the asynchronous task is ended.
        Public Sub OnEnd(ByVal ar As IAsyncResult)
            _taskprogress += "AsyncTask completed at: " + DateTime.Now.ToString
            _dlgt.EndInvoke(ar)
        End Sub


        ' Define the method that will get called if the task
        ' is not completed within the asynchronous timeout interval.
        Public Sub OnTimeout(ByVal ar As IAsyncResult)
            _taskprogress += "AsyncTask failed to complete " + _
                "because it exceeded the AsyncTimeout parameter."
        End Sub
    End Class
End Namespace

Hinweise

mit ASP.NET Version 2.0 können Sie mehrere Aufgaben auf einer Seite registrieren und vor dem Rendern der Seite asynchron ausführen. Sie können angeben, dass eine Aufgabe asynchron ausgeführt wird, wenn es sich um einen langsamen Prozess handelt und sie nicht möchten, dass andere Prozesse gebunden werden, während sie ausgeführt wird. Die asynchronen Aufgaben können parallel oder sequenziell ausgeführt werden.

Ein PageAsyncTask Objekt muss über die RegisterAsyncTask Methode auf der Seite registriert werden. Die Seite selbst muss nicht asynchron verarbeitet werden, um asynchrone Aufgaben auszuführen. Sie können das Async Attribut entweder true auf (wie im folgenden Codebeispiel gezeigt) oder false auf der Seitendirektive festlegen, und die asynchronen Aufgaben werden weiterhin asynchron verarbeitet:

<%@ Page Async="true" %>

Wenn das Async Attribut auf false festgelegt ist, wird der Thread, der die Seite ausführt, blockiert, bis alle asynchronen Aufgaben abgeschlossen sind.

Alle vor dem PreRenderComplete Ereignis registrierten asynchronen Aufgaben werden automatisch von der Seite ausgeführt, wenn sie noch nicht ausgeführt wurden. Diese asynchronen Aufgaben, die nach dem PreRenderComplete Ereignis registriert wurden, müssen explizit über die ExecuteRegisteredAsyncTasks Methode ausgeführt werden. Die ExecuteRegisteredAsyncTasks Methode kann auch verwendet werden, um Aufgaben vor dem PreRenderComplete Ereignis zu starten. Die ExecuteRegisteredAsyncTasks Methode führt alle registrierten asynchronen Aufgaben auf der Seite aus, die nicht ausgeführt wurden.

Standardmäßig wird ein asynchroner Vorgang timeout, wenn er nicht innerhalb von 45 Sekunden abgeschlossen wurde. Sie können einen anderen Timeoutwert entweder in der Web.config-Datei oder in der Seitendirektive angeben. Der <pages> Abschnitt der datei Web.config enthält ein asyncTimeout Attribut, wie unten dargestellt.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Die Seitendirektive enthält ein AsyncTimeout Attribut.

<%@ Page AsyncTimeout="30" %>

Konstruktoren

Name Beschreibung
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Initialisiert eine neue Instanz der PageAsyncTask Klasse mithilfe des angegebenen Werts für die parallele Ausführung.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Initialisiert eine neue Instanz der PageAsyncTask Klasse mithilfe des Standardwerts für die parallele Ausführung.
PageAsyncTask(Func<CancellationToken,Task>)

Initialisiert eine neue Instanz der PageAsyncTask Klasse mithilfe eines Ereignishandlers, mit dem die Aufgabe abgebrochen werden kann.
PageAsyncTask(Func<Task>)

Initialisiert eine neue Instanz der PageAsyncTask Klasse mithilfe eines Ereignishandlers, der die Verarbeitung der Aufgabe ermöglicht.

Eigenschaften

Name Beschreibung
BeginHandler

Ruft die Methode ab, die beim Starten einer asynchronen Aufgabe aufgerufen werden soll.
EndHandler

Ruft die Methode ab, die aufgerufen werden soll, wenn die Aufgabe innerhalb des Timeoutzeitraums erfolgreich abgeschlossen wird.
ExecuteInParallel

Ruft einen Wert ab, der angibt, ob der Vorgang parallel zu anderen Vorgängen verarbeitet werden kann.
State

Ruft ein Objekt ab, das den Status der Aufgabe darstellt.
TimeoutHandler

Ruft die Methode ab, die aufgerufen werden soll, wenn der Vorgang innerhalb des Timeoutzeitraums nicht erfolgreich abgeschlossen wird.

Methoden

Name Beschreibung
Equals(Object)

Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht.

(Geerbt von Object)
GetHashCode()

Dient als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft die Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie der aktuellen Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für: