PageAsyncTask Klas

Definitie

Naamruimte:
System.Web.UI
Assembly:
System.Web.dll

Bevat informatie over een asynchrone taak die is geregistreerd op een pagina. Deze klasse kan niet worden overgenomen.

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

Voorbeelden

In het volgende codevoorbeeld worden drie asynchrone taken op een pagina geregistreerd en parallel uitgevoerd. Elke taak roept een methode aan waarmee de thread slechts vijf seconden in de slaapstand wordt gezet.

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

Opmerkingen

ASP.NET versie 2.0 kunt u meerdere taken registreren bij een pagina en deze asynchroon uitvoeren voordat u de pagina weer geeft. U kunt opgeven dat een taak asynchroon wordt uitgevoerd als het een traag proces is en u niet wilt dat andere processen worden gekoppeld terwijl deze wordt uitgevoerd. De asynchrone taken kunnen parallel of opeenvolgend worden uitgevoerd.

Een PageAsyncTask object moet via de RegisterAsyncTask methode op de pagina worden geregistreerd. De pagina zelf hoeft niet asynchroon te worden verwerkt om asynchrone taken uit te voeren. U kunt het Async kenmerk instellen op true (zoals wordt weergegeven in het volgende codevoorbeeld) of false op de pagina-instructie en de asynchrone taken worden nog steeds asynchroon verwerkt:

<%@ Page Async="true" %>

Wanneer het Async kenmerk is ingesteld falseop, wordt de thread die de pagina uitvoert, geblokkeerd totdat alle asynchrone taken zijn voltooid.

Asynchrone taken die zijn geregistreerd voordat de PreRenderComplete gebeurtenis wordt uitgevoerd, worden automatisch uitgevoerd door de pagina als ze nog niet zijn uitgevoerd. Deze asynchrone taken die zijn geregistreerd nadat de PreRenderComplete gebeurtenis is geregistreerd, moeten expliciet worden uitgevoerd via de ExecuteRegisteredAsyncTasks methode. De ExecuteRegisteredAsyncTasks methode kan ook worden gebruikt om taken te starten vóór de PreRenderComplete gebeurtenis. Met ExecuteRegisteredAsyncTasks de methode worden alle geregistreerde asynchrone taken uitgevoerd op de pagina die niet zijn uitgevoerd.

Standaard treedt er een time-out op voor een asynchrone taak als deze niet binnen 45 seconden is voltooid. U kunt een andere time-outwaarde opgeven in het bestand Web.config of de pagina-instructie. De <pages> sectie van het bestand Web.config bevat een asyncTimeout kenmerk, zoals hieronder wordt weergegeven.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

De pagina-instructie bevat een AsyncTimeout kenmerk.

<%@ Page AsyncTimeout="30" %>

Constructors

Name Description
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Initialiseert een nieuw exemplaar van de PageAsyncTask klasse met behulp van de opgegeven waarde voor parallelle uitvoering.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Initialiseert een nieuw exemplaar van de PageAsyncTask klasse met behulp van de standaardwaarde voor parallelle uitvoering.
PageAsyncTask(Func<CancellationToken,Task>)

Initialiseert een nieuw exemplaar van de PageAsyncTask klasse met behulp van een gebeurtenishandler waarmee de taak kan worden geannuleerd.
PageAsyncTask(Func<Task>)

Initialiseert een nieuw exemplaar van de PageAsyncTask klasse met behulp van een gebeurtenis-handler waarmee de taak kan worden verwerkt.

Eigenschappen

Name Description
BeginHandler

Hiermee haalt u de methode op die moet worden aangeroepen bij het starten van een asynchrone taak.
EndHandler

Hiermee haalt u de methode op die moet worden aangeroepen wanneer de taak binnen de time-outperiode is voltooid.
ExecuteInParallel

Hiermee wordt een waarde opgehaald die aangeeft of de taak parallel met andere taken kan worden verwerkt.
State

Hiermee haalt u een object op dat de status van de taak vertegenwoordigt.
TimeoutHandler

Hiermee haalt u de methode op die moet worden aangeroepen wanneer de taak niet binnen de time-outperiode is voltooid.

Methoden

Name Description
Equals(Object)

Bepaalt of het opgegeven object gelijk is aan het huidige object.

(Overgenomen van Object)
GetHashCode()

Fungeert als de standaardhashfunctie.

(Overgenomen van Object)
GetType()

Hiermee haalt u de Type huidige instantie op.

(Overgenomen van Object)
MemberwiseClone()

Hiermee maakt u een ondiepe kopie van de huidige Object.

(Overgenomen van Object)
ToString()

Retourneert een tekenreeks die het huidige object vertegenwoordigt.

(Overgenomen van Object)

Van toepassing op