PageAsyncTask Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.Web.UI

Zestaw:: System.Web.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Zawiera informacje dotyczące zadania asynchronicznego zarejestrowanego na stronie. Klasa ta nie może być dziedziczona.

public ref class PageAsyncTask sealed

public sealed class PageAsyncTask

type PageAsyncTask = class

Public NotInheritable Class PageAsyncTask

Dziedziczenie: Object
PageAsyncTask

Przykłady

Poniższy przykład kodu rejestruje trzy zadania asynchroniczne na stronie i wykonuje je równolegle. Każde zadanie wywołuje metodę, która jedynie powoduje uśpienie wątku przez 5 sekund.

<%@ 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. Można określić, że zadanie ma być uruchamiane asynchronicznie, jeśli jest to powolny proces i nie chcesz, aby inne procesy były powiązane podczas wykonywania. Zadania asynchroniczne można wykonywać równolegle lub sekwencyjnie.

Obiekt PageAsyncTask musi być zarejestrowany na stronie za pomocą RegisterAsyncTask metody . Sama strona nie musi być przetwarzana asynchronicznie w celu wykonywania zadań asynchronicznych. Można ustawić Async atrybut na true wartość (jak pokazano w poniższym przykładzie kodu) lub false w dyrektywie page, a zadania asynchroniczne będą nadal przetwarzane asynchronicznie:

<%@ Page Async="true" %>

Async Gdy atrybut jest ustawiony na falsewartość , wątek wykonujący stronę zostanie zablokowany do czasu ukończenia wszystkich zadań asynchronicznych.

Wszystkie zadania asynchroniczne zarejestrowane przed PreRenderComplete zdarzeniem zostaną wykonane automatycznie przez stronę, jeśli nie zostały jeszcze wykonane. Te asynchroniczne zadania zarejestrowane po PreRenderComplete zdarzeniu muszą być wykonywane jawnie za pośrednictwem ExecuteRegisteredAsyncTasks metody . Metody ExecuteRegisteredAsyncTasks można również użyć do uruchamiania zadań przed zdarzeniem PreRenderComplete . Metoda ExecuteRegisteredAsyncTasks wykonuje wszystkie zarejestrowane zadania asynchroniczne na stronie, które nie zostały wykonane.

Domyślnie asynchroniczne zadanie zostanie przekroczone, jeśli nie zostało ukończone w ciągu 45 sekund. Możesz określić inną wartość limitu czasu w pliku Web.config lub dyrektywie page. Sekcja <pages> pliku Web.config zawiera asyncTimeout atrybut, jak pokazano poniżej.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Dyrektywa page zawiera AsyncTimeout atrybut .

<%@ Page AsyncTimeout="30" %>

Konstruktory

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)	Inicjuje PageAsyncTask nowe wystąpienie klasy przy użyciu wartości domyślnej do równoległego wykonywania.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)	Inicjuje PageAsyncTask nowe wystąpienie klasy przy użyciu określonej wartości do równoległego wykonywania.
PageAsyncTask(Func<CancellationToken,Task>)	Inicjuje PageAsyncTask nowe wystąpienie klasy przy użyciu procedury obsługi zdarzeń, która umożliwia anulowanie zadania.
PageAsyncTask(Func<Task>)	Inicjuje PageAsyncTask nowe wystąpienie klasy przy użyciu procedury obsługi zdarzeń, która umożliwia obsługę zadania.

Właściwości

BeginHandler	Pobiera metodę do wywołania podczas rozpoczynania zadania asynchronicznego.
EndHandler	Pobiera metodę do wywołania po pomyślnym zakończeniu zadania w okresie przekroczenia limitu czasu.
ExecuteInParallel	Pobiera wartość wskazującą, czy zadanie można przetworzyć równolegle z innymi zadaniami.
State	Pobiera obiekt reprezentujący stan zadania.
TimeoutHandler	Pobiera metodę do wywołania, gdy zadanie nie zakończy się pomyślnie w okresie przekroczenia limitu czasu.

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Dotyczy

Udostępnij za pośrednictwem