PageAsyncTask PageAsyncTask PageAsyncTask PageAsyncTask Class

Definición

Contiene información sobre una tarea asincrónica registrada en una página.Contains information about an asynchronous task registered to a page. Esta clase no puede heredarse.This class cannot be inherited.

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

Ejemplos

El ejemplo de código siguiente registra tres tareas asincrónicas en una página y los ejecuta en paralelo.The following code example registers three asynchronous tasks to a page and executes them in parallel. Cada tarea llama a un método que simplemente hace que el subproceso entre en suspensión durante 5 segundos.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 Microsoft.VisualBasic
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

Versión de ASP.NET 2.0 permite registrar varias tareas a una página y ejecutarlas de forma asincrónica antes de representar la página.ASP.NET version 2.0 allows you to register multiple tasks to a page and run them asynchronously prior to rendering the page. Puede especificar que una tarea se ejecute de forma asincrónica si es un proceso lento y no desea que otros procesos se detengan mientras se esté ejecutando.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. Las tareas asincrónicas se pueden ejecutar en paralelo o secuencialmente.The asynchronous tasks can be executed in parallel or sequentially.

Un PageAsyncTask objeto debe estar registrado en la página a través de la RegisterAsyncTask método.A PageAsyncTask object must be registered to the page through the RegisterAsyncTask method. La propia página no tiene que procesarse de forma asincrónica para ejecutar tareas asincrónicas.The page itself does not have to be processed asynchronously to execute asynchronous tasks. Puede establecer el Async atributo como true (como se muestra en el ejemplo de código siguiente) o false en la página de directiva y las tareas asincrónicas se seguirán procesando en forma asincrónica: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" %>

Cuando el Async atributo está establecido en false, se bloqueará el subproceso que ejecuta la página hasta que se completen todas las tareas asincrónicas.When the Async attribute is set to false, the thread that executes the page will be blocked until all asynchronous tasks are complete.

Todas las tareas asincrónicas registran antes de la PreRenderComplete evento se ejecutará automáticamente por la página si ha no se ha ejecutado.Any asynchronous tasks registered before the PreRenderComplete event will be executed automatically by the page if they have not already been executed. Las tareas asincrónicas registradas después la PreRenderComplete eventos se deben ejecutar explícitamente mediante el ExecuteRegisteredAsyncTasks método.Those asynchronous tasks registered after the PreRenderComplete event must be executed explicitly through the ExecuteRegisteredAsyncTasks method. El ExecuteRegisteredAsyncTasks método también se puede utilizar para iniciar tareas antes de la PreRenderComplete eventos.The ExecuteRegisteredAsyncTasks method can also be used to start tasks before the PreRenderComplete event. El ExecuteRegisteredAsyncTasks método ejecuta todas las tareas asincrónicas registradas en la página que no se han ejecutado.The ExecuteRegisteredAsyncTasks method executes all the registered asynchronous tasks on the page that have not been executed.

De forma predeterminada, una tarea asincrónica agotará el tiempo si no se ha completado dentro de 45 segundos.By default, an asynchronous task will time out if it has not completed within 45 seconds. Puede especificar un valor de tiempo de espera diferente en el archivo Web.config o la directiva de página.You can specify a different time-out value in either the Web.config file or the page directive. El <pages> sección del archivo Web.config contiene un asyncTimeout atributo, tal como se muestra a continuación.The <pages> section of the Web.config file contains an asyncTimeout attribute, as shown below.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

La directiva de página contiene un AsyncTimeout atributo.The page directive contains an AsyncTimeout attribute.

<%@ Page AsyncTimeout="30" %>

Constructores

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

Inicializa una nueva instancia de la clase PageAsyncTask con el valor predeterminado para la ejecución simultánea.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)

Inicializa una nueva instancia de la clase PageAsyncTask con el valor especificado para la ejecución simultánea.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>)

Inicializa una nueva instancia de la clase PageAsyncTask mediante un controlador de eventos que habilita la tarea que se va a cancelar.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>)

Inicializa una nueva instancia de la clase PageAsyncTask mediante un controlador de eventos que habilita la tarea que se va a controlar.Initializes a new instance of the PageAsyncTask class using an event handler that enables the task to be handled.

Propiedades

BeginHandler BeginHandler BeginHandler BeginHandler

Obtiene el método al que se debe llamar al iniciar una tarea asincrónica.Gets the method to call when beginning an asynchronous task.

EndHandler EndHandler EndHandler 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.Gets the method to call when the task completes successfully within the time-out period.

ExecuteInParallel ExecuteInParallel ExecuteInParallel ExecuteInParallel

Obtiene un valor que indica si la tarea se puede procesar a la vez que otras tareas o no.Gets a value that indicates whether the task can be processed in parallel with other tasks.

State State State State

Obtiene un objeto que representa el estado de la tarea.Gets an object that represents the state of the task.

TimeoutHandler TimeoutHandler TimeoutHandler 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.Gets the method to call when the task does not complete successfully within the time-out period.

Métodos

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

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

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

Sirve como la función hash predeterminada.Serves as the default hash function.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Se aplica a