PageAsyncTask Classe

  • Référence

Définition

Espace de noms:
System.Web.UI
Assembly:
System.Web.dll

Contient des informations à propos d'une tâche asynchrone inscrite dans une page. Cette classe ne peut pas être héritée.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Héritage
Object
PageAsyncTask

Exemples

L’exemple de code suivant inscrit trois tâches asynchrones dans une page et les exécute en parallèle. Chaque tâche appelle une méthode qui entraîne simplement la mise en veille du thread pendant 5 secondes.

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

Remarques

ASP.NET version 2.0 vous permet d’inscrire plusieurs tâches dans une page et de les exécuter de manière asynchrone avant de rendre la page. Vous pouvez spécifier qu’une tâche doit être exécutée de manière asynchrone s’il s’agit d’un processus lent et que vous ne souhaitez pas que d’autres processus soient liés pendant son exécution. Les tâches asynchrones peuvent être exécutées en parallèle ou séquentiellement.

Un PageAsyncTask objet doit être inscrit sur la page via la RegisterAsyncTask méthode . La page elle-même n’a pas besoin d’être traitée de manière asynchrone pour exécuter des tâches asynchrones. Vous pouvez définir l’attribut Asynctrue sur (comme indiqué dans l’exemple de code suivant) ou false sur la directive de page, et les tâches asynchrones seront toujours traitées de manière asynchrone :

<%@ Page Async="true" %>

Lorsque l’attribut Async a la valeur , le thread qui exécute la page est bloqué jusqu’à falsece que toutes les tâches asynchrones soient terminées.

Toutes les tâches asynchrones inscrites avant l’événement PreRenderComplete sont exécutées automatiquement par la page si elles n’ont pas déjà été exécutées. Les tâches asynchrones inscrites après l’événement PreRenderComplete doivent être exécutées explicitement via la ExecuteRegisteredAsyncTasks méthode . La ExecuteRegisteredAsyncTasks méthode peut également être utilisée pour démarrer des tâches avant l’événement PreRenderComplete . La ExecuteRegisteredAsyncTasks méthode exécute toutes les tâches asynchrones inscrites sur la page qui n’ont pas été exécutées.

Par défaut, une tâche asynchrone expire si elle ne s’est pas terminée dans les 45 secondes. Vous pouvez spécifier une valeur de délai d’attente différente dans le fichier Web.config ou la directive de page. La <pages> section du fichier Web.config contient un asyncTimeout attribut, comme indiqué ci-dessous.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

La directive de page contient un AsyncTimeout attribut.

<%@ Page AsyncTimeout="30" %>

Constructeurs

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Initialise une nouvelle instance de la classe PageAsyncTask à l'aide de la valeur par défaut pour une exécution en parallèle.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Initialise une nouvelle instance de la classe PageAsyncTask à l'aide de la valeur spécifiée pour une exécution en parallèle.
PageAsyncTask(Func<CancellationToken,Task>)

Initialise une nouvelle instance de la classe PageAsyncTask à l'aide d'un gestionnaire d'événements qui permet l'annulation de la tâche.
PageAsyncTask(Func<Task>)

Initialise une nouvelle instance de la classe PageAsyncTask à l'aide d'un gestionnaire d'événements qui permet la gestion de la tâche.

Propriétés

BeginHandler

Obtient la méthode à appeler au début d'une tâche asynchrone.
EndHandler

Obtient la méthode à appeler lorsque la tâche se termine correctement dans le délai d'attente imparti.
ExecuteInParallel

Obtient une valeur qui indique si la tâche peut être traitée en parallèle avec d'autres tâches.
State

Obtient un objet qui représente l'état de la tâche.
TimeoutHandler

Obtient la méthode à appeler lorsque la tâche ne se termine pas correctement dans le délai d'attente imparti.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à