PageAsyncTask Klasa

Definicja

Zawiera informacje na temat asynchronicznego zadania zarejestrowanego na stronie.Contains information about an asynchronous task registered to a page. Klasa ta nie może być dziedziczona.This class cannot be inherited.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Dziedziczenie
PageAsyncTask

Przykłady

Poniższy przykład kodu rejestruje trzy zadania asynchroniczne na stronie i wykonuje je równolegle.The following code example registers three asynchronous tasks to a page and executes them in parallel. Każde zadanie wywołuje metodę, która powoduje jedynie, że wątek przestanie być uśpiony przez 5 sekund.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

Uwagi

ASP.NET w wersji 2,0 umożliwia rejestrowanie wielu zadań na stronie i uruchamianie ich asynchronicznie przed renderowaniem strony.ASP.NET version 2.0 allows you to register multiple tasks to a page and run them asynchronously prior to rendering the page. Możesz określić, że zadanie ma być uruchamiane asynchronicznie, jeśli jest to proces powolny i nie chcesz, aby inne procesy były powiązane w trakcie jego wykonywania.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. Zadania asynchroniczne można wykonywać równolegle lub sekwencyjnie.The asynchronous tasks can be executed in parallel or sequentially.

PageAsyncTaskObiekt musi być zarejestrowany na stronie za pomocą RegisterAsyncTask metody.A PageAsyncTask object must be registered to the page through the RegisterAsyncTask method. Sama strona nie musi być przetwarzana asynchronicznie w celu wykonywania zadań asynchronicznych.The page itself does not have to be processed asynchronously to execute asynchronous tasks. Można ustawić Async atrybut na jeden true (jak pokazano w poniższym przykładzie kodu) lub false w dyrektywie page, a zadania asynchroniczne będą nadal przetwarzane asynchronicznie: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" %>

Gdy Async atrybut jest ustawiony na false , wątek wykonujący stronę będzie zablokowany do momentu ukończenia wszystkich zadań asynchronicznych.When the Async attribute is set to false, the thread that executes the page will be blocked until all asynchronous tasks are complete.

Wszystkie zadania asynchroniczne zarejestrowane przed PreRenderComplete zdarzeniem zostaną automatycznie wykonane przez stronę, jeśli nie zostały jeszcze wykonane.Any asynchronous tasks registered before the PreRenderComplete event will be executed automatically by the page if they have not already been executed. Te zadania asynchroniczne zarejestrowane po PreRenderComplete zdarzeniu muszą zostać wykonane jawnie za pomocą ExecuteRegisteredAsyncTasks metody.Those asynchronous tasks registered after the PreRenderComplete event must be executed explicitly through the ExecuteRegisteredAsyncTasks method. ExecuteRegisteredAsyncTasksMetody można również użyć do uruchomienia zadań przed PreRenderComplete zdarzeniem.The ExecuteRegisteredAsyncTasks method can also be used to start tasks before the PreRenderComplete event. ExecuteRegisteredAsyncTasksMetoda wykonuje wszystkie zarejestrowane zadania asynchroniczne na stronie, które nie zostały wykonane.The ExecuteRegisteredAsyncTasks method executes all the registered asynchronous tasks on the page that have not been executed.

Domyślnie zadanie asynchroniczne przekroczy limit czasu, jeśli nie zostało zakończone w ciągu 45 sekund.By default, an asynchronous task will time out if it has not completed within 45 seconds. Możesz określić inną wartość limitu czasu w pliku Web.config lub dyrektywie page.You can specify a different time-out value in either the Web.config file or the page directive. <pages>Sekcja pliku Web.config zawiera asyncTimeout atrybut, jak pokazano poniżej.The <pages> section of the Web.config file contains an asyncTimeout attribute, as shown below.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Dyrektywa Page zawiera AsyncTimeout atrybut.The page directive contains an AsyncTimeout attribute.

<%@ Page AsyncTimeout="30" %>

Konstruktory

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Inicjuje nowe wystąpienie PageAsyncTask klasy przy użyciu wartości domyślnej do wykonania równolegle.Initializes a new instance of the PageAsyncTask class using the default value for executing in parallel.

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

Inicjuje nowe wystąpienie PageAsyncTask klasy przy użyciu określonej wartości do wykonania równolegle.Initializes a new instance of the PageAsyncTask class using the specified value for executing in parallel.

PageAsyncTask(Func<CancellationToken,Task>)

Inicjuje nowe wystąpienie PageAsyncTask klasy za pomocą procedury obsługi zdarzeń, która umożliwia anulowanie zadania.Initializes a new instance of the PageAsyncTask class using an event handler that enables the task to be canceled.

PageAsyncTask(Func<Task>)

Inicjuje nowe wystąpienie PageAsyncTask klasy za pomocą procedury obsługi zdarzeń, która umożliwia obsługę zadania.Initializes a new instance of the PageAsyncTask class using an event handler that enables the task to be handled.

Właściwości

BeginHandler

Pobiera metodę do wywołania przy rozpoczynaniu zadania asynchronicznego.Gets the method to call when beginning an asynchronous task.

EndHandler

Pobiera metodę do wywołania, gdy zadanie zakończy się pomyślnie w określonym limicie czasu.Gets the method to call when the task completes successfully within the time-out period.

ExecuteInParallel

Pobiera wartość wskazującą, czy zadanie może być przetwarzane równolegle z innymi zadaniami.Gets a value that indicates whether the task can be processed in parallel with other tasks.

State

Pobiera obiekt, który reprezentuje stan zadania.Gets an object that represents the state of the task.

TimeoutHandler

Pobiera metodę do wywołania, gdy zadanie nie zakończy się pomyślnie w określonym limicie czasu.Gets the method to call when the task does not complete successfully within the time-out period.

Metody

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Dotyczy