Freigeben über

PageAsyncTask Klasse

  • Referenz

Definition

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

Enthält Informationen zu einer asynchronen Aufgabe, die für eine 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 bewirkt, dass der Thread 5 Sekunden lang in den Standbymodus versetzt wird.

<%@ 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

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 während der Ausführung gebunden werden. Die asynchronen Tasks können parallel oder sequenziell ausgeführt werden.

Ein PageAsyncTask -Objekt muss über die -Methode auf der RegisterAsyncTask 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 in der Seitendirektive festlegen, und die asynchronen Aufgaben werden weiterhin asynchron verarbeitet:

<%@ Page Async="true" %>

Wenn das Async Attribut auf falsefestgelegt 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, sofern sie noch nicht ausgeführt wurden. Diese asynchronen Aufgaben, die nach dem PreRenderComplete Ereignis registriert werden, 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 Tasks auf der Seite aus, die nicht ausgeführt wurden.

Standardmäßig tritt für einen asynchronen Task ein Timeout auf, 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 Web.config-Datei enthält ein asyncTimeout -Attribut, wie unten gezeigt.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Die Seitenanweisung enthält ein AsyncTimeout -Attribut.

<%@ Page AsyncTimeout="30" %>

Konstruktoren

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse, die den Standardwert zum parallelen Ausführen verwendet.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse, die den angegebenen Wert zum parallelen Ausführen verwendet.
PageAsyncTask(Func<CancellationToken,Task>)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse unter Verwendung eines Ereignishandlers, der ermöglicht, dass die Aufgabe abgebrochen werden kann.
PageAsyncTask(Func<Task>)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse unter Verwendung eines Ereignishandlers, der ermöglicht, dass die Aufgabe verarbeitet werden kann.

Eigenschaften

BeginHandler

Ruft die Methode ab, die zu Beginn 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 die Aufgabe parallel mit anderen Aufgaben verarbeitet werden kann.
State

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

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

Methoden

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)
ToString()

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

(Geerbt von Object)

Gilt für: