PageAsyncTask Clase

  • Referencia

Definición

Espacio de nombres:
System.Web.UI
Ensamblado:
System.Web.dll

Contiene información sobre una tarea asincrónica registrada en una página. Esta clase no puede heredarse.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Herencia
Object
PageAsyncTask

Ejemplos

En el ejemplo de código siguiente se registran tres tareas asincrónicas en una página y se ejecutan en paralelo. Cada tarea llama a un método que simplemente hace que el subproceso entre en suspensión durante 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

Comentarios

ASP.NET versión 2.0 permite registrar varias tareas en una página y ejecutarlas de forma asincrónica antes de representar la página. Puede especificar que una tarea se ejecute de forma asincrónica si es un proceso lento y no desea que otros procesos estén vinculados mientras se ejecuta. Las tareas asincrónicas se pueden ejecutar en paralelo o secuencialmente.

Un PageAsyncTask objeto debe registrarse en la página a través del RegisterAsyncTask método . La propia página no tiene que procesarse de forma asincrónica para ejecutar tareas asincrónicas. Puede establecer el Async atributo true en (como se muestra en el ejemplo de código siguiente) o false en la directiva page y las tareas asincrónicas se seguirán procesando de forma asincrónica:

<%@ Page Async="true" %>

Cuando el Async atributo se establece falseen , el subproceso que ejecuta la página se bloqueará hasta que se completen todas las tareas asincrónicas.

Las tareas asincrónicas registradas antes de que el PreRenderComplete evento se ejecuten automáticamente en la página si aún no se han ejecutado. Esas tareas asincrónicas registradas después del PreRenderComplete evento se deben ejecutar explícitamente a través del ExecuteRegisteredAsyncTasks método . El ExecuteRegisteredAsyncTasks método también se puede usar para iniciar tareas antes del PreRenderComplete evento. El ExecuteRegisteredAsyncTasks método ejecuta todas las tareas asincrónicas registradas en la página que no se han ejecutado.

De forma predeterminada, una tarea asincrónica agotará el tiempo de espera si no se ha completado en un plazo de 45 segundos. Puede especificar un valor de tiempo de espera diferente en el archivo Web.config o en la directiva page. La <pages> sección del archivo Web.config contiene un asyncTimeout atributo, como se muestra a continuación.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

La directiva page contiene un AsyncTimeout atributo .

<%@ Page AsyncTimeout="30" %>

Constructores

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Inicializa una nueva instancia de la clase PageAsyncTask con el valor predeterminado para la ejecución simultánea.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Inicializa una nueva instancia de la clase PageAsyncTask con el valor especificado para la ejecución simultánea.
PageAsyncTask(Func<CancellationToken,Task>)

Inicializa una nueva instancia de la clase PageAsyncTask mediante un controlador de eventos que habilita la tarea que se va a cancelar.
PageAsyncTask(Func<Task>)

Inicializa una nueva instancia de la clase PageAsyncTask mediante un controlador de eventos que habilita la tarea que se va a controlar.

Propiedades

BeginHandler

Obtiene el método al que se debe llamar al iniciar una tarea asincrónica.
EndHandler

Obtiene el método al que se debe llamar cuando la tarea se lleva a cabo correctamente en el período del tiempo de espera.
ExecuteInParallel

Obtiene un valor que indica si la tarea se puede procesar a la vez que otras tareas o no.
State

Obtiene un objeto que representa el estado de la tarea.
TimeoutHandler

Obtiene el método al que se debe llamar cuando la tarea no se lleva a cabo correctamente en el período del tiempo de espera.

Métodos

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)

Se aplica a