PageAsyncTask PageAsyncTask PageAsyncTask PageAsyncTask Class

Definition

Enthält Informationen zu einer asynchronen Aufgabe, die für eine Seite registriert ist.Contains information about an asynchronous task registered to a page. Diese Klasse kann nicht vererbt werden.This class cannot be inherited.

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

Beispiele

Im folgenden Codebeispiel werden drei asynchrone Aufgaben für eine Seite registriert und parallel ausgeführt.The following code example registers three asynchronous tasks to a page and executes them in parallel. Jede Aufgabe ruft eine Methode auf, die lediglich bewirkt, dass der Thread 5 Sekunden in den Standbymodus wechselt.Each task calls a method that merely causes the thread to sleep for 5 seconds.

<%@ 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 Tasks auf einer Seite registrieren und vor dem Rendern der Seite asynchron ausführen.ASP.NET version 2.0 allows you to register multiple tasks to a page and run them asynchronously prior to rendering the page. Sie können angeben, dass ein Task asynchron ausgeführt werden soll, wenn es sich um einen langsamen Prozess handelt und Sie nicht möchten, dass andere Prozesse während der Ausführung gebunden werden.You might specify that a task be run asynchronously if it is a slow process and you do not want other processes to be tied up while it is executing. Die asynchronen Aufgaben können parallel oder sequenziell ausgeführt werden.The asynchronous tasks can be executed in parallel or sequentially.

Ein PageAsyncTask -Objekt muss über die RegisterAsyncTask -Methode auf der Seite registriert werden.A PageAsyncTask object must be registered to the page through the RegisterAsyncTask method. Die Seite selbst muss nicht asynchron verarbeitet werden, um asynchrone Aufgaben auszuführen.The page itself does not have to be processed asynchronously to execute asynchronous tasks. Sie können das Async -Attribut entweder true auf (wie im folgenden Codebeispiel gezeigt) oder false auf der Page-Direktive festlegen, und die asynchronen Aufgaben werden weiterhin asynchron verarbeitet:You can set the Async attribute to either true (as shown in the following code example) or false on the page directive and the asynchronous tasks will still be processed asynchronously:

<%@ Page Async="true" %>

Wenn das Async -Attribut auf falsefestgelegt ist, wird der Thread, der die Seite ausführt, blockiert, bis alle asynchronen Aufgaben vollständig sind.When the Async attribute is set to false, the thread that executes the page will be blocked until all asynchronous tasks are complete.

Alle asynchronen Tasks, die vor PreRenderComplete dem Ereignis registriert werden, werden automatisch von der Seite ausgeführt, wenn Sie noch nicht ausgeführt wurden.Any asynchronous tasks registered before the PreRenderComplete event will be executed automatically by the page if they have not already been executed. Die asynchronen Aufgaben, die nach PreRenderComplete dem Ereignis registriert werden, müssen explizit ExecuteRegisteredAsyncTasks über die-Methode ausgeführt werden.Those asynchronous tasks registered after the PreRenderComplete event must be executed explicitly through the ExecuteRegisteredAsyncTasks method. Die ExecuteRegisteredAsyncTasks -Methode kann auch zum Starten von Aufgaben vor dem PreRenderComplete -Ereignis verwendet werden.The ExecuteRegisteredAsyncTasks method can also be used to start tasks before the PreRenderComplete event. Die ExecuteRegisteredAsyncTasks -Methode führt alle registrierten asynchronen Tasks auf der Seite aus, die noch nicht ausgeführt wurden.The ExecuteRegisteredAsyncTasks method executes all the registered asynchronous tasks on the page that have not been executed.

Standardmäßig wird für eine asynchrone Aufgabe ein Timeout durchgeführt, wenn Sie nicht innerhalb von 45 Sekunden abgeschlossen wurde.By default, an asynchronous task will time out if it has not completed within 45 seconds. Sie können einen anderen Timeout Wert in der Datei Web. config oder der Page-Direktive angeben.You can specify a different time-out value in either the Web.config file or the page directive. Der <pages> -Abschnitt der Datei Web. config enthält ein asyncTimeout -Attribut, wie unten gezeigt.The <pages> section of the Web.config file contains an asyncTimeout attribute, as shown below.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Die Page-Direktive AsyncTimeout enthält ein-Attribut.The page directive contains an AsyncTimeout attribute.

<%@ Page AsyncTimeout="30" %>

Konstruktoren

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object) PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object) PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object) PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse, die den Standardwert zum parallelen Ausführen verwendet.Initializes a new instance of the PageAsyncTask class using the default value for executing in parallel.

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

Initialisiert eine neue Instanz der PageAsyncTask-Klasse, die den angegebenen Wert zum parallelen Ausführen verwendet.Initializes a new instance of the PageAsyncTask class using the specified value for executing in parallel.

PageAsyncTask(Func<CancellationToken,Task>) PageAsyncTask(Func<CancellationToken,Task>) PageAsyncTask(Func<CancellationToken,Task>) PageAsyncTask(Func<CancellationToken,Task>)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse unter Verwendung eines Ereignishandlers, der ermöglicht, dass die Aufgabe abgebrochen werden kann.Initializes a new instance of the PageAsyncTask class using an event handler that enables the task to be canceled.

PageAsyncTask(Func<Task>) PageAsyncTask(Func<Task>) PageAsyncTask(Func<Task>) PageAsyncTask(Func<Task>)

Initialisiert eine neue Instanz der PageAsyncTask-Klasse unter Verwendung eines Ereignishandlers, der ermöglicht, dass die Aufgabe verarbeitet werden kann.Initializes a new instance of the PageAsyncTask class using an event handler that enables the task to be handled.

Eigenschaften

BeginHandler BeginHandler BeginHandler BeginHandler

Ruft die Methode ab, die zu Beginn einer asynchronen Aufgabe aufgerufen werden soll.Gets the method to call when beginning an asynchronous task.

EndHandler EndHandler EndHandler EndHandler

Ruft die Methode ab, die aufgerufen werden soll, wenn die Aufgabe innerhalb des Timeoutzeitraums erfolgreich abgeschlossen wird.Gets the method to call when the task completes successfully within the time-out period.

ExecuteInParallel ExecuteInParallel ExecuteInParallel ExecuteInParallel

Ruft einen Wert ab, der angibt, ob die Aufgabe parallel mit anderen Aufgaben verarbeitet werden kann.Gets a value that indicates whether the task can be processed in parallel with other tasks.

State State State State

Ruft ein Objekt ab, das den Zustand der Aufgabe darstellt.Gets an object that represents the state of the task.

TimeoutHandler TimeoutHandler TimeoutHandler TimeoutHandler

Ruft die Methode ab, die aufgerufen werden soll, wenn die Aufgabe innerhalb des Timeoutzeitraums nicht erfolgreich abgeschlossen wird.Gets the method to call when the task does not complete successfully within the time-out period.

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Gilt für: