Task.Wait Metoda

Reference

Definice

Obor názvů:: System.Threading.Tasks

Sestavení:: System.Threading.Tasks.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Čeká na Task dokončení spuštění.

Přetížení

Wait()	Čeká na Task dokončení spuštění.
Wait(Int32)	Čeká na Task dokončení spuštění v zadaném počtu milisekund.
Wait(CancellationToken)	Čeká na Task dokončení spuštění. Čekání se ukončí, pokud se před dokončením úkolu zruší token zrušení.
Wait(TimeSpan)	Čeká na Task dokončení spuštění v zadaném časovém intervalu.
Wait(Int32, CancellationToken)	Čeká na Task dokončení spuštění. Čekání se ukončí, pokud uplynou interval časového limitu nebo se zruší token zrušení před dokončením úkolu.
Wait(TimeSpan, CancellationToken)	Čeká na Task dokončení spuštění.

Wait()

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění.

public:
 void Wait();

public void Wait ();

member this.Wait : unit -> unit

Public Sub Wait ()

Výjimky

ObjectDisposedException

Byla Task odstraněna.

AggregateException

Úkol byl zrušen. Kolekce InnerExceptions obsahuje TaskCanceledException objekt.

-nebo-

Během provádění úlohy došlo k výjimce. Kolekce InnerExceptions obsahuje informace o výjimce nebo výjimkách.

Příklady

Následující příklad spustí úlohu, která vygeneruje milion náhodných celých čísel mezi 0 a 100 a vypočítá jejich střední hodnotu. Příklad používá metodu Wait k zajištění, že se úloha dokončí před ukončením aplikace. V opačném případě, protože se jedná o konzolovou aplikaci, by se příklad ukončil před tím, než úloha může vypočítat a zobrazit střední hodnotu.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 1000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     t.Wait();
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 1000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

t.Wait()

// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 1000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     t.Wait()
   End Sub
End Module
' The example displays output similar to the following:
'       Total:   50,015,714
'       Mean:    50.02
'       N:       1,000,000

Poznámky

Wait je metoda synchronizace, která způsobí, že volající vlákno počká na dokončení aktuální úlohy. Pokud aktuální úloha nezačala provádět, metoda Wait se pokusí odebrat úlohu z plánovače a provést ji vloženou v aktuálním vlákně. Pokud to není možné provést nebo pokud aktuální úloha již spustila provádění, blokuje volající vlákno, dokud se úloha nedokončuje. Další informace najdete v tématech Task.Wait a Inlining v blogu Paralelní programování pomocí .NET.

Viz také

Task.Wait a Inlining

Platí pro

Wait(Int32)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění v zadaném počtu milisekund.

public:
 bool Wait(int millisecondsTimeout);

public bool Wait (int millisecondsTimeout);

member this.Wait : int -> bool

Public Function Wait (millisecondsTimeout As Integer) As Boolean

Parametry

millisecondsTimeout: Int32

Počet milisekund, které se mají čekat, nebo Infinite (-1) čekat na neomezenou dobu.

Návraty

Boolean

true pokud je Task provádění dokončeno v přiděleném čase, falsev opačném případě .

Výjimky

ObjectDisposedException

Byla Task odstraněna.

ArgumentOutOfRangeException

millisecondsTimeout je záporné číslo jiné než -1, které představuje nekonečný časový limit.

AggregateException

Úkol byl zrušen. Kolekce InnerExceptions obsahuje TaskCanceledException objekt.

-nebo-

Během provádění úlohy došlo k výjimce. Kolekce InnerExceptions obsahuje informace o výjimce nebo výjimkách.

Příklady

Následující příklad spustí úlohu, která vygeneruje pět milionů náhodných celých čísel mezi 0 a 100 a vypočítá jejich střední hodnotu. Příklad používá metodu Wait(Int32) k čekání na dokončení aplikace do 150 milisekund. Pokud se aplikace dokončí normálně, úloha zobrazí součet a průměr náhodných čísel, která vygenerovala. Pokud interval časového limitu uplynul, zobrazí příklad před ukončením zprávu.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     if (! t.Wait(150))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 5000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

if t.Wait 150 |> not then
    printfn "The timeout interval elapsed."

// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     If Not t.Wait(150) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' The example displays output similar to the following:
'       Total:   50,015,714
'       Mean:    50.02
'       N:       1,000,000
' Or it displays the following output:
'       The timeout interval elapsed.

Poznámky

Wait(Int32) je metoda synchronizace, která způsobí, že volající vlákno čeká na dokončení aktuální instance úlohy, dokud nedojde k jedné z následujících:

Úkol se úspěšně dokončí.
Samotný úkol se zruší nebo vyvolá výjimku. V tomto případě zpracujete AggregateException výjimku. Vlastnost AggregateException.InnerExceptions obsahuje podrobnosti o výjimce nebo výjimkách.
Interval definovaný uplynulými millisecondsTimeout tečkami. V tomto případě aktuální vlákno obnoví provádění a metoda vrátí false.

Platí pro

Wait(CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění. Čekání se ukončí, pokud se před dokončením úkolu zruší token zrušení.

public:
 void Wait(System::Threading::CancellationToken cancellationToken);

public void Wait (System.Threading.CancellationToken cancellationToken);

member this.Wait : System.Threading.CancellationToken -> unit

Public Sub Wait (cancellationToken As CancellationToken)

Parametry

cancellationToken: CancellationToken

Token zrušení, který se má sledovat při čekání na dokončení úkolu.

Výjimky

OperationCanceledException

Akce cancellationToken byla zrušena.

ObjectDisposedException

Úkol byl odstraněn.

AggregateException

Úkol byl zrušen. Kolekce InnerExceptions obsahuje TaskCanceledException objekt.

-nebo-

Během provádění úlohy došlo k výjimce. Kolekce InnerExceptions obsahuje informace o výjimce nebo výjimkách.

Příklady

Následující příklad ukazuje jednoduché použití tokenu zrušení ke zrušení čekání na dokončení úkolu. Spustí se úloha, zavolá metodu CancellationTokenSource.Cancel pro zrušení některého ze zdrojů tokenů pro zrušení a pak se pět sekund zpoždí. Všimněte si, že samotný úkol nebyl předán tokenu zrušení a nelze ho zrušit. Vlákno aplikace volá metodu úlohy Task.Wait , aby počkala na dokončení úkolu, ale po zrušení tokenu zrušení a OperationCanceledException vyvolání se zruší čekání. Obslužná rutina výjimky ohlásí výjimku a poté přejde do režimu spánku po dobu šesti sekund. Jak ukazuje výstup z příkladu, toto zpoždění umožňuje dokončení úkolu ve RanToCompletion stavu.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();

      Task t = Task.Run( () => { Console.WriteLine("Calling Cancel...");
                                 ts.Cancel();
                                 Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait for the task to complete...");
         t.Wait(ts.Token);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(6000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
      }
      ts.Dispose();
   }
}
// The example displays output like the following:
//    About to wait for the task to complete...
//    Calling Cancel...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion

open System
open System.Threading
open System.Threading.Tasks

let ts = new CancellationTokenSource()

let t =
    Task.Run(fun () ->
        printfn "Calling Cancel..."
        ts.Cancel()
        Task.Delay(5000).Wait()
        printfn $"Task ended delay...")

try
    printfn "About to wait for the task to complete..."
    t.Wait ts.Token

with :? OperationCanceledException as e ->
    printfn $"{e.GetType().Name}: The wait has been canceled. Task status: {t.Status:G}"
    Thread.Sleep 6000
    printfn $"After sleeping, the task status:  {t.Status:G}"

ts.Dispose()


// The example displays output like the following:
//    About to wait for the task to complete...
//    Calling Cancel...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()

      Dim t = Task.Run( Sub()
                           Console.WriteLine("Calling Cancel...")
                           ts.Cancel()
                           Task.Delay(5000).Wait()
                           Console.WriteLine("Task ended delay...")
                        End Sub)
      Try
         Console.WriteLine("About to wait for the task to complete...")
         t.Wait(ts.Token)
      Catch e As OperationCanceledException
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status)
         Thread.Sleep(6000)
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status)
      End Try
      ts.Dispose()
   End Sub
End Module
' The example displays output like the following:
'    About to wait for the task to complete...
'    Calling Cancel...
'    OperationCanceledException: The wait has been canceled. Task status: Running
'    Task ended delay...
'    After sleeping, the task status:  RanToCompletion

Poznámky

Metoda Wait(CancellationToken) vytvoří zrušitelné čekání, to znamená, že způsobí, že aktuální vlákno počká, dokud nedojde k jedné z následujících:

Úkol se dokončí.
Token zrušení se zruší. V tomto případě volání Wait(CancellationToken) metody vyvolá .OperationCanceledException

Poznámka

Zrušení tokenu cancellationToken zrušení nemá žádný vliv na spuštěnou úlohu, pokud nebyl předán také token zrušení a je připraven zpracovat zrušení. Předání objektu cancellationToken této metodě jednoduše umožní, aby se čekání zrušilo.

Platí pro

Wait(TimeSpan)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění v zadaném časovém intervalu.

public:
 bool Wait(TimeSpan timeout);

public bool Wait (TimeSpan timeout);

member this.Wait : TimeSpan -> bool

Public Function Wait (timeout As TimeSpan) As Boolean

Parametry

timeout: TimeSpan

Jedná TimeSpan se o počet milisekund, které se mají čekat, nebo TimeSpan hodnota představující -1 milisekund, která má čekat na dobu neurčitou.

Návraty

Boolean

true pokud se Task provádění dokončilo v přiděleném čase, jinak hodnota false.

Výjimky

ObjectDisposedException

Byla Task odstraněna.

ArgumentOutOfRangeException

timeout je záporné číslo jiné než -1 milisekund, což představuje nekonečný časový limit.

-nebo-

timeout je větší než Int32.MaxValue.

AggregateException

Úkol byl zrušen. Kolekce InnerExceptions obsahuje TaskCanceledException objekt.

-nebo-

Během provádění úlohy došlo k výjimce. Kolekce InnerExceptions obsahuje informace o výjimce nebo výjimkách.

Příklady

Následující příklad spustí úlohu, která vygeneruje pět milionů náhodných celých čísel mezi 0 a 100 a vypočítá jejich střední hodnotu. Příklad používá metodu Wait(TimeSpan) k čekání na dokončení aplikace do 150 milisekund. Pokud se aplikace dokončí normálně, úloha zobrazí součet a průměr náhodných čísel, která vygenerovala. Pokud interval časového limitu uplynul, zobrazí příklad před ukončením zprávu.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     TimeSpan ts = TimeSpan.FromMilliseconds(150);
     if (! t.Wait(ts))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 5000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

let ts = TimeSpan.FromMilliseconds 150

if t.Wait ts |> not then
    printfn "The timeout interval elapsed."

// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     Dim ts As TimeSpan = TimeSpan.FromMilliseconds(150)
     If Not t.Wait(ts) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' The example displays output similar to the following:
'       Total:   50,015,714
'       Mean:    50.02
'       N:       1,000,000
' Or it displays the following output:
'       The timeout interval elapsed.

Poznámky

Wait(TimeSpan) je metoda synchronizace, která způsobí, že volající vlákno čeká na dokončení aktuální instance úlohy, dokud nedojde k jedné z následujících:

Úkol se úspěšně dokončí.
Samotný úkol se zruší nebo vyvolá výjimku. V tomto případě zpracujete AggregateException výjimku. Vlastnost AggregateException.InnerExceptions obsahuje podrobnosti o výjimce nebo výjimkách.
Interval definovaný uplynulými timeout tečkami. V tomto případě aktuální vlákno obnoví provádění a metoda vrátí false.

Platí pro

Wait(Int32, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění. Čekání se ukončí, pokud uplynou interval časového limitu nebo se před dokončením úlohy zruší token zrušení.

public:
 bool Wait(int millisecondsTimeout, System::Threading::CancellationToken cancellationToken);

public bool Wait (int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);

member this.Wait : int * System.Threading.CancellationToken -> bool

Public Function Wait (millisecondsTimeout As Integer, cancellationToken As CancellationToken) As Boolean

Parametry

millisecondsTimeout: Int32

Počet milisekund, které se mají čekat, nebo Infinite (-1) čekání na neomezenou dobu.

cancellationToken: CancellationToken

Token zrušení, který se má sledovat při čekání na dokončení úlohy.

Návraty

Boolean

true pokud se Task provádění dokončilo v přiděleném čase, jinak hodnota false.

Výjimky

OperationCanceledException

Akce cancellationToken byla zrušena.

ObjectDisposedException

Byla Task zlikvidována.

ArgumentOutOfRangeException

millisecondsTimeout je záporné číslo jiné než -1, které představuje nekonečný časový limit.

AggregateException

Úkol byl zrušen. Kolekce InnerExceptions obsahuje TaskCanceledException objekt .

-nebo-

Během provádění úlohy došlo k výjimce. Kolekce InnerExceptions obsahuje informace o výjimce nebo výjimkách.

Příklady

Následující příklad volá metodu Wait(Int32, CancellationToken) k poskytnutí hodnoty časového limitu i tokenu zrušení, který může ukončit čekání na dokončení úkolu. Spustí se nové vlákno, které spustí metodu CancelToken , která pozastaví a pak zavolá metodu CancellationTokenSource.Cancel pro zrušení tokenů zrušení. Pak se spustí úkol a zpozdí se o 5 sekund. Metoda Wait je pak volána, aby počkala na dokončení úlohy, a je k dispozici jak krátká hodnota časového limitu, tak token zrušení.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();
      Thread thread = new Thread(CancelToken);
      thread.Start(ts);

      Task t = Task.Run( () => { Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait completion of task {0}", t.Id);
         bool result = t.Wait(1510, ts.Token);
         Console.WriteLine("Wait completed normally: {0}", result);
         Console.WriteLine("The task status:  {0:G}", t.Status);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(4000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
         ts.Dispose();
      }
   }

   private static void CancelToken(Object obj)
   {
      Thread.Sleep(1500);
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId);
      CancellationTokenSource source = obj as CancellationTokenSource;
      if (source != null) source.Cancel();
   }
}
// The example displays output like the following if the wait is canceled by
// the cancellation token:
//    About to wait completion of task 1
//    Canceling the cancellation token from thread 3...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion
// The example displays output like the following if the wait is canceled by
// the timeout interval expiring:
//    About to wait completion of task 1
//    Wait completed normally: False
//    The task status:  Running
//    Canceling the cancellation token from thread 3...

open System
open System.Threading
open System.Threading.Tasks

let cancelToken (obj: obj) =
    Thread.Sleep 1500
    printfn $"Canceling the cancellation token from thread {Thread.CurrentThread.ManagedThreadId}..."

    match obj with
    | :? CancellationTokenSource as source -> source.Cancel()
    | _ -> ()

let ts = new CancellationTokenSource()
let thread = Thread(ParameterizedThreadStart cancelToken)
thread.Start ts

let t =
    Task.Run(fun () ->
        Task.Delay(5000).Wait()
        printfn "Task ended delay...")

try
    printfn $"About to wait completion of task {t.Id}"
    let result = t.Wait(1510, ts.Token)
    printfn $"Wait completed normally: {result}"
    printfn $"The task status:  {t.Status:G}"

with :? OperationCanceledException as e ->
    printfn $"{e.GetType().Name}: The wait has been canceled. Task status: {t.Status:G}"
    Thread.Sleep 4000
    printfn $"After sleeping, the task status:  {t.Status:G}"
    ts.Dispose()

// The example displays output like the following if the wait is canceled by
// the cancellation token:
//    About to wait completion of task 1
//    Canceling the cancellation token from thread 3...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion
// The example displays output like the following if the wait is canceled by
// the timeout interval expiring:
//    About to wait completion of task 1
//    Wait completed normally: False
//    The task status:  Running
//    Canceling the cancellation token from thread 3...

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()
      Dim thread As New Thread(AddressOf CancelToken)
      thread.Start(ts)

      Dim t As Task = Task.Run( Sub()
                                   Task.Delay(5000).Wait()
                                    Console.WriteLine("Task ended delay...")
                                End Sub)
      Try
         Console.WriteLine("About to wait completion of task {0}", t.Id)
         Dim result As Boolean = t.Wait(1510, ts.Token)
         Console.WriteLine("Wait completed normally: {0}", result)
         Console.WriteLine("The task status:  {0:G}", t.Status)
      Catch e As OperationCanceledException
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status)
         Thread.Sleep(4000)
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status)
         ts.Dispose()
      End Try
   End Sub

   Private Sub CancelToken(obj As Object)
      Thread.Sleep(1500)
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId)

      If TypeOf obj Is CancellationTokenSource Then
         Dim source As CancellationTokenSource = CType(obj, CancellationTokenSource)
         source.Cancel()
      End If
   End Sub
End Module
' The example displays output like the following if the wait is canceled by
' the cancellation token:
'    About to wait completion of task 1
'    Canceling the cancellation token from thread 3...
'    OperationCanceledException: The wait has been canceled. Task status: Running
'    Task ended delay...
'    After sleeping, the task status:  RanToCompletion
' The example displays output like the following if the wait is canceled by
' the timeout interval expiring:
'    About to wait completion of task 1
'    Wait completed normally: False
'    The task status:  Running
'    Canceling the cancellation token from thread 3...

Všimněte si, že přesný výstup z příkladu závisí na tom, jestli bylo čekání zrušeno kvůli tokenu zrušení, nebo kvůli vypršení časového limitu.

Poznámky

Wait(Int32, CancellationToken) je metoda synchronizace, která způsobí, že volající vlákno čeká na dokončení aktuální instance úlohy, dokud nedojde k jedné z následujících akcí:

Úloha se úspěšně dokončí.
Úloha samotná je zrušena nebo vyvolá výjimku. V tomto případě zpracujete AggregateException výjimku. Vlastnost AggregateException.InnerExceptions obsahuje podrobnosti o výjimce nebo výjimky.
Token cancellationToken zrušení je zrušený. V tomto případě volání Wait(Int32, CancellationToken) metody vyvolá .OperationCanceledException
Interval definovaný uplynulými millisecondsTimeout tečkami. V tomto případě aktuální vlákno obnoví provádění a metoda vrátí false.

Poznámka

Platí pro

Wait(TimeSpan, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Čeká na Task dokončení spuštění.

public:
 bool Wait(TimeSpan timeout, System::Threading::CancellationToken cancellationToken);

public bool Wait (TimeSpan timeout, System.Threading.CancellationToken cancellationToken);

member this.Wait : TimeSpan * System.Threading.CancellationToken -> bool

Public Function Wait (timeout As TimeSpan, cancellationToken As CancellationToken) As Boolean

Parametry

timeout: TimeSpan

Doba čekání nebo InfiniteTimeSpan čekání po neomezenou dobu

cancellationToken: CancellationToken

K CancellationToken pozorování při čekání na dokončení úlohy.

Návraty

Boolean

true pokud se Task provádění dokončilo v přiděleném čase, jinak hodnota false.

Výjimky

AggregateException

Služba Task byla zrušena.

-nebo-

během provádění příkazu došlo k výjimce Task.

ArgumentOutOfRangeException

timeout je záporné číslo jiné než -1 milisekund, které představuje nekonečný časový limit.

-nebo-

časový limit je větší než MaxValue.

OperationCanceledException

Akce cancellationToken byla zrušena.

Platí pro

Task.Wait Metoda

Definice

Přetížení

Wait()

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Wait(Int32)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Wait(CancellationToken)

Parametry

Výjimky

Příklady

Poznámky

Platí pro

Wait(TimeSpan)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Wait(Int32, CancellationToken)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Wait(TimeSpan, CancellationToken)

Parametry

Návraty

Výjimky

Platí pro

Váš názor

Další materiály