Remarque : cette classe est nouvelle dans le .NET Framework version 2.0.
Contient des informations à propos d'une tâche asynchrone inscrite dans une page. Cette classe ne peut pas être héritée.
Espace de noms : System.Web.UI
Assembly : System.Web (dans system.web.dll)
Visual Basic (Déclaration)
Public NotInheritable Class PageAsyncTask
Visual Basic (Utilisation)
Dim instance As PageAsyncTask
public sealed class PageAsyncTask
public ref class PageAsyncTask sealed
public final class PageAsyncTask
public final class PageAsyncTask
La version 2.0 d'ASP.NET vous permet d'inscrire plusieurs tâches dans une page et de les exécuter de manière asynchrone avant de générer le rendu de la page. Vous pouvez spécifier d'exécuter une tâche de manière asynchrone s'il s'agit d'un processus lent et que vous ne souhaitez pas bloquer d'autres processus lors de son exécution. Les tâches asynchrones peuvent être exécutées en parallèle ou séquentiellement.
Un objet PageAsyncTask doit être inscrit dans la page par l'intermédiaire de la méthode RegisterAsyncTask. La page elle-même ne doit pas être traitée de manière asynchrone pour exécuter des tâches asynchrones. Que vous affectiez à l'attribut Async la valeur true (comme indiqué dans l'exemple de code suivant) ou false sur la directive de page, les tâches asynchrones sont traitées de manière asynchrone :
<%@ Page Async="true" %>
Lorsque l'attribut Async a la valeur false, le thread qui exécute la page est bloqué jusqu'à ce 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 par l'intermédiaire de la méthode ExecuteRegisteredAsyncTasks. La méthode ExecuteRegisteredAsyncTasks peut également être utilisée pour démarrer les tâches avant l'événement PreRenderComplete. La méthode ExecuteRegisteredAsyncTasks exécute toutes les tâches asynchrones inscrites sur la page qui n'ont pas été exécutées.
Par défaut, le délai d'attente d'une tâche asynchrone expire si elle ne se termine pas en moins de 45 secondes. Vous pouvez spécifier une valeur de délai d'attente différente dans le fichier Web.config ou dans la directive de page. La section <pages> du fichier Web.config contient un attribut asyncTimeout, comme indiqué ci-dessous.
<system.web>
<pages asyncTimeout="30">
</pages>
</system.web>
La directive de page contient un attribut AsyncTimeout.
<%@ Page AsyncTimeout="30" %>
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 provoque seulement une mise en veille du thread de 5 secondes.
<%@ 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()
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)
' Execute the register asynchronous task.
Page.ExecuteRegisteredAsyncTasks()
TaskMessage.InnerHtml = slowTask1.GetAsyncTaskProgress() + "<br>" + slowTask2.GetAsyncTaskProgress() + "<br>" + slowTask3.GetAsyncTaskProgress()
End Sub
</script>
<html >
<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>
<%@ Page Language="C#" Async="true" AsyncTimeout="35"%>
<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();
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);
// Execute the register asynchronous task.
Page.ExecuteRegisteredAsyncTasks();
TaskMessage.InnerHtml = slowTask1.GetAsyncTaskProgress()+ "<br>" + slowTask2.GetAsyncTaskProgress() + "<br>" + slowTask3.GetAsyncTaskProgress();
}
</script>
<html >
<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>
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
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.";
}
}
}
System.Object
System.Web.UI.PageAsyncTask
Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.
Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition
Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.
.NET Framework
Prise en charge dans : 2.0