PageAsyncTask Třída

  • Reference

Definice

Obor názvů:
System.Web.UI
Sestavení:
System.Web.dll

Obsahuje informace o asynchronní úloze registrované na stránce. Tato třída se nemůže dědit.

public ref class PageAsyncTask sealed
public sealed class PageAsyncTask
type PageAsyncTask = class
Public NotInheritable Class PageAsyncTask
Dědičnost
Object
PageAsyncTask

Příklady

Následující příklad kódu registruje tři asynchronní úlohy na stránce a spouští je paralelně. Každý úkol volá metodu, která pouze způsobí, že vlákno uspí po dobu 5 sekund.

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

Poznámky

ASP.NET verze 2.0 umožňuje zaregistrovat na stránku více úloh a spouštět je asynchronně před vykreslením stránky. Můžete určit, že se má úloha spouštět asynchronně, pokud se jedná o pomalý proces a nechcete, aby se během provádění svážely další procesy. Asynchronní úlohy lze provádět paralelně nebo sekvenčně.

Objekt PageAsyncTask musí být na stránce zaregistrován metodou RegisterAsyncTask . Samotná stránka nemusí být zpracována asynchronně, aby bylo možné provádět asynchronní úlohy. Můžete nastavit Async atribut buď true na (jak je znázorněno v následujícím příkladu kódu) nebo false v direktivě page a asynchronní úlohy budou stále zpracovány asynchronně:

<%@ Page Async="true" %>

Async Pokud je atribut nastaven na falsehodnotu , vlákno, které spouští stránku, bude blokováno, dokud nebudou dokončeny všechny asynchronní úlohy.

Všechny asynchronní úlohy zaregistrované před PreRenderComplete událostí budou stránkou automaticky provedeny, pokud ještě nebyly provedeny. Tyto asynchronní úlohy zaregistrované po PreRenderComplete události musí být provedeny explicitně prostřednictvím ExecuteRegisteredAsyncTasks metody . Metodu ExecuteRegisteredAsyncTasks lze také použít ke spuštění úkolů před událostí PreRenderComplete . Metoda ExecuteRegisteredAsyncTasks spustí všechny registrované asynchronní úlohy na stránce, které nebyly provedeny.

Ve výchozím nastavení vyprší časový limit asynchronní úlohy, pokud se nedokončil do 45 sekund. V souboru Web.config nebo direktivě page můžete zadat jinou hodnotu časového limitu. Oddíl <pages> souboru Web.config obsahuje asyncTimeout atribut, jak je znázorněno níže.

<system.web>

<pages asyncTimeout="30">

</pages>

</system.web>

Direktiva page obsahuje AsyncTimeout atribut .

<%@ Page AsyncTimeout="30" %>

Konstruktory

PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object)

Inicializuje novou instanci PageAsyncTask třídy pomocí výchozí hodnoty pro paralelní provádění.
PageAsyncTask(BeginEventHandler, EndEventHandler, EndEventHandler, Object, Boolean)

Inicializuje novou instanci PageAsyncTask třídy pomocí zadané hodnoty pro paralelní provádění.
PageAsyncTask(Func<CancellationToken,Task>)

Inicializuje novou instanci PageAsyncTask třídy pomocí obslužné rutiny události, která umožňuje zrušit úlohu.
PageAsyncTask(Func<Task>)

Inicializuje novou instanci PageAsyncTask třídy pomocí obslužné rutiny události, která umožňuje zpracování úlohy.

Vlastnosti

BeginHandler

Získá metodu volání při zahájení asynchronní úlohy.
EndHandler

Získá metodu volání při úspěšném dokončení úkolu v časovém limitu.
ExecuteInParallel

Získá hodnotu, která označuje, zda úkol lze zpracovávat paralelně s jinými úkoly.
State

Získá objekt, který představuje stav úlohy.
TimeoutHandler

Získá metodu volání, když úloha není úspěšně dokončena v časovém limitu.

Metody

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetType()

Type Získá z aktuální instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)

Platí pro