Task.Wait Metode

Referensi

Definisi

Ruang nama:: System.Threading.Tasks

Rakitan:: System.Runtime.dll

Rakitan:: System.Threading.Tasks.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Task Menunggu eksekusi selesai.

Overload

Wait(TimeSpan, CancellationToken)	Task Menunggu eksekusi selesai.
Wait(Int32, CancellationToken)	Task Menunggu eksekusi selesai. Tunggu berakhir jika interval batas waktu berlalu atau token pembatalan dibatalkan sebelum tugas selesai.
Wait(TimeSpan)	Task Menunggu eksekusi selesai dalam interval waktu tertentu.
Wait(CancellationToken)	Task Menunggu eksekusi selesai. Tunggu berakhir jika token pembatalan dibatalkan sebelum tugas selesai.
Wait()	Task Menunggu eksekusi selesai.
Wait(Int32)	Task Menunggu eksekusi selesai dalam jumlah milidetik tertentu.

Wait(TimeSpan, CancellationToken)

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai.

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

Parameter

timeout: TimeSpan

Waktu untuk menunggu, atau InfiniteTimeSpan menunggu tanpa batas waktu

cancellationToken: CancellationToken

A CancellationToken untuk mengamati sambil menunggu tugas selesai.

Mengembalikan

Boolean

true Task jika eksekusi selesai dalam waktu yang dialokasikan; jika tidak, false.

Pengecualian

AggregateException

Dibatalkan Task

-atau-

pengecualian dilemparkan selama eksekusi Task.

ArgumentOutOfRangeException

timeout adalah angka negatif selain -1 milidetik, yang mewakili batas waktu tak terbatas

-atau-

batas waktu lebih besar dari MaxValue.

OperationCanceledException

Dibatalkan cancellationToken .

Berlaku untuk

Wait(Int32, CancellationToken)

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai. Tunggu berakhir jika interval batas waktu berlalu atau token pembatalan dibatalkan sebelum tugas selesai.

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

Parameter

millisecondsTimeout: Int32

Jumlah milidetik untuk menunggu, atau Infinite (-1) untuk menunggu tanpa batas waktu.

cancellationToken: CancellationToken

Token pembatalan untuk diamati sambil menunggu tugas selesai.

Mengembalikan

Boolean

true Task jika eksekusi selesai dalam waktu yang dialokasikan; jika tidak, false.

Pengecualian

OperationCanceledException

Dibatalkan cancellationToken .

ObjectDisposedException

Sudah Task dibuang.

ArgumentOutOfRangeException

millisecondsTimeout adalah angka negatif selain -1, yang mewakili waktu habis yang tak terbatas.

AggregateException

Tugas dibatalkan. Koleksi InnerExceptions berisi TaskCanceledException objek .

-atau-

Pengecualian dilemparkan selama pelaksanaan tugas. Koleksi InnerExceptions berisi informasi tentang pengecualian atau pengecualian.

Contoh

Contoh berikut memanggil Wait(Int32, CancellationToken) metode untuk memberikan nilai batas waktu dan token pembatalan yang dapat mengakhiri penantian penyelesaian tugas. Utas CancelToken baru dimulai dan menjalankan metode , yang menjeda dan kemudian memanggil CancellationTokenSource.Cancel metode untuk membatalkan token pembatalan. Tugas kemudian diluncurkan dan tertunda selama 5 detik. Metode Wait ini kemudian dipanggil untuk menunggu penyelesaian tugas dan disediakan nilai batas waktu singkat dan token pembatalan.

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...

Perhatikan bahwa output yang tepat dari contoh tergantung pada apakah penantian dibatalkan karena token pembatalan atau karena interval batas waktu berlalu.

Keterangan

Wait(Int32, CancellationToken) adalah metode sinkronisasi yang menyebabkan utas panggilan menunggu instans tugas saat ini selesai hingga salah satu hal berikut ini terjadi:

Tugas berhasil diselesaikan.
Tugas itu sendiri dibatalkan atau melempar pengecualian. Dalam hal ini, Anda menangani AggregateException pengecualian. Properti AggregateException.InnerExceptions berisi detail tentang pengecualian atau pengecualian.
Token cancellationToken pembatalan dibatalkan. Dalam hal ini, panggilan ke Wait(Int32, CancellationToken) metode melempar OperationCanceledException.
Interval yang ditentukan oleh millisecondsTimeout berlalu. Dalam hal ini, utas saat ini melanjutkan eksekusi dan metode mengembalikan false.

Catatan

Membatalkan cancellationToken token pembatalan tidak berpengaruh pada tugas yang sedang berjalan kecuali token pembatalan juga telah diteruskan dan siap untuk menangani pembatalan. Meneruskan objek ke cancellationToken metode ini hanya memungkinkan penantian dibatalkan berdasarkan beberapa kondisi.

Berlaku untuk

Wait(TimeSpan)

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai dalam interval waktu tertentu.

public:
 bool Wait(TimeSpan timeout);

public bool Wait (TimeSpan timeout);

member this.Wait : TimeSpan -> bool

Public Function Wait (timeout As TimeSpan) As Boolean

Parameter

timeout: TimeSpan

TimeSpan yang mewakili jumlah milidetik untuk menunggu, atau TimeSpan yang mewakili -1 milidetik untuk menunggu tanpa batas waktu.

Mengembalikan

Boolean

true Task jika eksekusi selesai dalam waktu yang dialokasikan; jika tidak, false.

Pengecualian

ObjectDisposedException

Sudah Task dibuang.

ArgumentOutOfRangeException

timeout adalah angka negatif selain -1 milidetik, yang mewakili waktu habis yang tak terbatas.

-atau-

timeout lebih besar dari Int32.MaxValue.

AggregateException

Tugas dibatalkan. Koleksi InnerExceptions berisi TaskCanceledException objek .

-atau-

Pengecualian dilemparkan selama pelaksanaan tugas. Koleksi InnerExceptions berisi informasi tentang pengecualian atau pengecualian.

Contoh

Contoh berikut memulai tugas yang menghasilkan lima juta bilangan bulat acak antara 0 dan 100 dan menghitung rata-ratanya. Contohnya menggunakan Wait(TimeSpan) metode untuk menunggu aplikasi selesai dalam 150 milidetik. Jika aplikasi selesai secara normal, tugas menampilkan jumlah dan rata-rata angka acak yang telah dihasilkannya. Jika interval batas waktu telah berlalu, contoh menampilkan pesan sebelum berakhir.

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.

Keterangan

Wait(TimeSpan) adalah metode sinkronisasi yang menyebabkan utas panggilan menunggu instans tugas saat ini selesai hingga salah satu hal berikut ini terjadi:

Tugas berhasil diselesaikan.
Tugas itu sendiri dibatalkan atau melempar pengecualian. Dalam hal ini, Anda menangani AggregateException pengecualian. Properti AggregateException.InnerExceptions berisi detail tentang pengecualian atau pengecualian.
Interval yang ditentukan oleh timeout berlalu. Dalam hal ini, utas saat ini melanjutkan eksekusi dan metode mengembalikan false.

Berlaku untuk

Wait(CancellationToken)

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai. Tunggu berakhir jika token pembatalan dibatalkan sebelum tugas selesai.

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)

Parameter

cancellationToken: CancellationToken

Token pembatalan untuk diamati sambil menunggu tugas selesai.

Pengecualian

OperationCanceledException

Dibatalkan cancellationToken .

ObjectDisposedException

Tugas telah dibuang.

AggregateException

Tugas dibatalkan. Koleksi InnerExceptions berisi TaskCanceledException objek .

-atau-

Pengecualian dilemparkan selama pelaksanaan tugas. Koleksi InnerExceptions berisi informasi tentang pengecualian atau pengecualian.

Contoh

Contoh berikut mengilustrasikan penggunaan sederhana token pembatalan untuk membatalkan menunggu penyelesaian tugas. Tugas diluncurkan, memanggil CancellationTokenSource.Cancel metode untuk membatalkan salah satu token pembatalan sumber token, lalu menunda selama lima detik. Perhatikan bahwa tugas itu sendiri belum diteruskan token pembatalan dan tidak dapat dibatalkan. Utas aplikasi memanggil metode tugas Task.Wait untuk menunggu tugas selesai, tetapi penantian dibatalkan setelah token pembatalan dibatalkan dan OperationCanceledException dilemparkan. Handler pengecualian melaporkan pengecualian dan kemudian tidur selama enam detik. Seperti yang ditunjukkan oleh output dari contoh, penundaan tersebut memungkinkan tugas selesai dalam status RanToCompletion .

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

Keterangan

Metode Wait(CancellationToken) ini membuat penantian yang dapat dibatalkan; yaitu, menyebabkan utas saat ini menunggu sampai salah satu hal berikut terjadi:

Tugas selesai.
Token pembatalan dibatalkan. Dalam hal ini, panggilan ke Wait(CancellationToken) metode melempar OperationCanceledException.

Catatan

Berlaku untuk

Wait()

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai.

public:
 void Wait();

public void Wait ();

member this.Wait : unit -> unit

Public Sub Wait ()

Pengecualian

ObjectDisposedException

Sudah Task dibuang.

AggregateException

Tugas dibatalkan. Koleksi InnerExceptions berisi TaskCanceledException objek .

-atau-

Pengecualian dilemparkan selama pelaksanaan tugas. Koleksi InnerExceptions berisi informasi tentang pengecualian atau pengecualian.

Contoh

Contoh berikut memulai tugas yang menghasilkan satu juta bilangan bulat acak antara 0 dan 100 dan menghitung rata-ratanya. Contohnya menggunakan Wait metode untuk memastikan bahwa tugas selesai sebelum aplikasi berakhir. Jika tidak, karena ini adalah aplikasi konsol, contohnya akan berakhir sebelum tugas dapat menghitung dan menampilkan rata-rata.

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

Keterangan

Wait adalah metode sinkronisasi yang menyebabkan alur panggilan menunggu hingga tugas saat ini selesai. Jika tugas saat ini belum memulai eksekusi, metode Tunggu mencoba menghapus tugas dari penjadwal dan menjalankannya sebaris pada utas saat ini. Jika tidak dapat melakukannya, atau jika tugas saat ini telah memulai eksekusi, tugas akan memblokir utas panggilan hingga tugas selesai. Untuk informasi selengkapnya, lihat Task.Wait dan "Inlining" di blog Pemrograman Paralel dengan .NET.

Lihat juga

Task.Wait dan "Inlining"

Berlaku untuk

Wait(Int32)

Sumber:: Task.cs

Sumber:: Task.cs

Sumber:: Task.cs

Task Menunggu eksekusi selesai dalam jumlah milidetik tertentu.

public:
 bool Wait(int millisecondsTimeout);

public bool Wait (int millisecondsTimeout);

member this.Wait : int -> bool

Public Function Wait (millisecondsTimeout As Integer) As Boolean

Parameter

millisecondsTimeout: Int32

Jumlah milidetik untuk menunggu, atau Infinite (-1) untuk menunggu tanpa batas waktu.

Mengembalikan

Boolean

true Task jika eksekusi selesai dalam waktu yang dialokasikan; jika tidak, false.

Pengecualian

ObjectDisposedException

Sudah Task dibuang.

ArgumentOutOfRangeException

millisecondsTimeout adalah angka negatif selain -1, yang mewakili waktu habis yang tak terbatas.

AggregateException

Tugas dibatalkan. Koleksi InnerExceptions berisi TaskCanceledException objek .

-atau-

Pengecualian dilemparkan selama pelaksanaan tugas. Koleksi InnerExceptions berisi informasi tentang pengecualian atau pengecualian.

Contoh

Contoh berikut memulai tugas yang menghasilkan lima juta bilangan bulat acak antara 0 dan 100 dan menghitung rata-ratanya. Contohnya menggunakan Wait(Int32) metode untuk menunggu aplikasi selesai dalam 150 milidetik. Jika aplikasi selesai secara normal, tugas menampilkan jumlah dan rata-rata angka acak yang telah dihasilkannya. Jika interval batas waktu telah berlalu, contoh menampilkan pesan sebelum berakhir.

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.

Keterangan

Wait(Int32) adalah metode sinkronisasi yang menyebabkan utas panggilan menunggu instans tugas saat ini selesai hingga salah satu hal berikut ini terjadi:

Tugas berhasil diselesaikan.
Tugas itu sendiri dibatalkan atau melempar pengecualian. Dalam hal ini, Anda menangani AggregateException pengecualian. Properti AggregateException.InnerExceptions berisi detail tentang pengecualian atau pengecualian.
Interval yang ditentukan oleh millisecondsTimeout berlalu. Dalam hal ini, utas saat ini melanjutkan eksekusi dan metode mengembalikan false.

Berlaku untuk

Bagikan melalui

Task.Wait Metode

Definisi

Overload

Wait(TimeSpan, CancellationToken)

Parameter

Mengembalikan

Pengecualian

Berlaku untuk

Wait(Int32, CancellationToken)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Wait(TimeSpan)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Wait(CancellationToken)

Parameter

Pengecualian

Contoh

Keterangan

Berlaku untuk

Wait()

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Wait(Int32)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Sumber Daya Tambahan: