PageAsyncTask Classe

  • Referência

Definição

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

Contém informações sobre uma tarefa assíncrona registrada em uma página. Essa classe não pode ser herdada.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Herança
Object
PageAsyncTask

Exemplos

O exemplo de código a seguir registra três tarefas assíncronas em uma página e as executa em paralelo. Cada tarefa chama um método que apenas faz com que o thread durma por 5 segundos.

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

Comentários

ASP.NET versão 2.0 permite registrar várias tarefas em uma página e executá-las de forma assíncrona antes de renderizar a página. Você pode especificar que uma tarefa seja executada de forma assíncrona se for um processo lento e não quiser que outros processos sejam vinculados enquanto ela está em execução. As tarefas assíncronas podem ser executadas em paralelo ou sequencialmente.

Um PageAsyncTask objeto deve ser registrado na página por meio do RegisterAsyncTask método . A página em si não precisa ser processada de forma assíncrona para executar tarefas assíncronas. Você pode definir o Async atributo true como (conforme mostrado no exemplo de código a seguir) ou false na diretiva page e as tarefas assíncronas ainda serão processadas de forma assíncrona:

<%@ Page Async="true" %>

Quando o Async atributo for definido falsecomo , o thread que executa a página será bloqueado até que todas as tarefas assíncronas sejam concluídas.

Todas as tarefas assíncronas registradas antes do PreRenderComplete evento serão executadas automaticamente pela página se ainda não tiverem sido executadas. Essas tarefas assíncronas registradas após o PreRenderComplete evento devem ser executadas explicitamente por meio do ExecuteRegisteredAsyncTasks método . O ExecuteRegisteredAsyncTasks método também pode ser usado para iniciar tarefas antes do PreRenderComplete evento. O ExecuteRegisteredAsyncTasks método executa todas as tarefas assíncronas registradas na página que não foram executadas.

Por padrão, uma tarefa assíncrona atingiu o tempo limite se não tiver sido concluída dentro de 45 segundos. Você pode especificar um valor de tempo limite diferente no arquivo Web.config ou na diretiva de página. A <pages> seção do arquivo Web.config contém um asyncTimeout atributo , conforme mostrado abaixo.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

A diretiva page contém um AsyncTimeout atributo .

<%@ Page AsyncTimeout="30" %>

Construtores

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Inicializa uma nova instância da classe PageAsyncTask usando o valor padrão para a execução em paralelo.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Inicializa uma nova instância da classe PageAsyncTask usando o valor especificado para a execução em paralelo.
PageAsyncTask(Func<CancellationToken,Task>)

Inicializa uma nova instância da classe PageAsyncTask usando um manipulador de eventos que permite que a tarefa seja cancelada.
PageAsyncTask(Func<Task>)

Inicializa uma nova instância da classe PageAsyncTask usando um manipulador de eventos que permite que a tarefa seja manipulada.

Propriedades

BeginHandler

Obtém o método a ser chamado ao iniciar uma tarefa assíncrona.
EndHandler

Obtém o método a ser chamado quando a tarefa for concluída com êxito dentro do período de tempo limite.
ExecuteInParallel

Obtém um valor que indica se a tarefa pode ser processada em paralelo a outras tarefas.
State

Obtém um objeto que representa o estado da tarefa.
TimeoutHandler

Obtém o método a ser chamado quando a tarefa não for concluída com êxito dentro do período de tempo limite.

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a