Task.Wait Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Threading.Tasks
Bütünleştirilmiş Kod:
System.Threading.Tasks.dll
Bütünleştirilmiş Kod:
System.Runtime.dll
Bütünleştirilmiş Kod:
mscorlib.dll
Bütünleştirilmiş Kod:
netstandard.dll

yürütmenin Task tamamlanmasını bekler.

Aşırı Yüklemeler

Wait()

yürütmenin Task tamamlanmasını bekler.
Wait(Int32)

belirtilen milisaniye içinde yürütmenin Task tamamlanmasını bekler.
Wait(CancellationToken)

yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce iptal belirteci iptal edilirse bekleme sonlandırılır.
Wait(TimeSpan)

Yürütmenin Task belirli bir zaman aralığı içinde tamamlanmasını bekler.
Wait(Int32, CancellationToken)

yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce bir zaman aşımı aralığı geçtiğinde veya iptal belirteci iptal edilirse bekleme sonlandırılır.
Wait(TimeSpan, CancellationToken)

yürütmenin Task tamamlanmasını bekler.

Wait()

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

yürütmenin Task tamamlanmasını bekler.

public:
 void Wait();
public void Wait ();
member this.Wait : unit -> unit
Public Sub Wait ()

Özel durumlar

ObjectDisposedException

Task yok edildi.

AggregateException

Görev iptal edildi. Koleksiyon InnerExceptions bir TaskCanceledException nesnesi içerir.

-veya-

Görevin yürütülmesi sırasında bir özel durum oluştu. Koleksiyon, InnerExceptions özel durum veya özel durumlar hakkında bilgi içerir.

Örnekler

Aşağıdaki örnek, 0 ile 100 arasında bir milyon rastgele tamsayı oluşturan ve ortalamalarını hesaplayan bir görev başlatır. Örnek, uygulamanın sonlandırılmasından önce görevin tamamlanmasını sağlamak için yöntemini kullanır Wait . Aksi takdirde, bu bir konsol uygulaması olduğundan, örnek görevin ortalamayı hesaplayıp görüntüleyebilmesi için sonlandırılır.

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

Açıklamalar

Wait , çağıran iş parçacığının geçerli görev tamamlanana kadar beklemesine neden olan bir eşitleme yöntemidir. Geçerli görev yürütülmeye başlamadıysa, Wait yöntemi görevi zamanlayıcıdan kaldırmayı ve geçerli iş parçacığında satır içinde yürütmeyi dener. Bunu yapamıyorsa veya geçerli görev yürütmeye zaten başladıysa, görev tamamlanana kadar çağıran iş parçacığını engeller. Daha fazla bilgi için .NET ile Paralel Programlama blogunda Task.Wait ve "Inlining" bölümüne bakın.

Ayrıca bkz.

Şunlara uygulanır

Wait(Int32)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

belirtilen milisaniye içinde yürütmenin Task tamamlanmasını bekler.

public:
 bool Wait(int millisecondsTimeout);
public bool Wait (int millisecondsTimeout);
member this.Wait : int -> bool
Public Function Wait (millisecondsTimeout As Integer) As Boolean

Parametreler

millisecondsTimeout
Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

Döndürülenler

Boolean

trueTask ayrılan süre içinde tamamlanan yürütme ise; değilse, false.

Özel durumlar

ObjectDisposedException

Task yok edildi.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AggregateException

Görev iptal edildi. Koleksiyon InnerExceptions bir TaskCanceledException nesnesi içerir.

-veya-

Görevin yürütülmesi sırasında bir özel durum oluştu. Koleksiyon, InnerExceptions özel durum veya özel durumlar hakkında bilgi içerir.

Örnekler

Aşağıdaki örnek, 0 ile 100 arasında beş milyon rastgele tamsayı oluşturan ve ortalamalarını hesaplayan bir görev başlatır. Örnek, uygulamanın 150 milisaniye içinde tamamlanmasını beklemek için yöntemini kullanır Wait(Int32) . Uygulama normal şekilde tamamlanırsa, görev oluşturduğu rastgele sayıların toplamını ve ortalamasını görüntüler. Zaman aşımı aralığı dolduysa, örnekte sonlandırılana kadar bir ileti görüntülenir.

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.

Açıklamalar

Wait(Int32) , aşağıdakilerden biri gerçekleşene kadar çağıran iş parçacığının geçerli görev örneğinin tamamlanmasını beklemesine neden olan bir eşitleme yöntemidir:

  • Görev başarıyla tamamlar.

  • Görevin kendisi iptal edilir veya bir özel durum oluşturur. Bu durumda, bir AggregateException özel durumu işlersiniz. özelliği özel AggregateException.InnerExceptions durum veya özel durumlar hakkındaki ayrıntıları içerir.

  • Geçen süreler tarafından millisecondsTimeout tanımlanan aralık. Bu durumda, geçerli iş parçacığı yürütmeyi sürdürür ve yöntemi döndürür false.

Şunlara uygulanır

Wait(CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce iptal belirteci iptal edilirse bekleme sonlandırılır.

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)

Parametreler

cancellationToken
CancellationToken

Görevin tamamlanmasını beklerken gözlemlenen bir iptal belirteci.

Özel durumlar

OperationCanceledException

İptal cancellationToken edildi.

ObjectDisposedException

Görev atıldı.

AggregateException

Görev iptal edildi. Koleksiyon InnerExceptions bir TaskCanceledException nesnesi içerir.

-veya-

Görevin yürütülmesi sırasında bir özel durum oluştu. Koleksiyon, InnerExceptions özel durum veya özel durumlar hakkında bilgi içerir.

Örnekler

Aşağıdaki örnekte, bir görevin tamamlanmasını beklerken iptal etmek için basit bir iptal belirteci kullanımı gösterilmektedir. Bir görev başlatılır, belirteç kaynağının CancellationTokenSource.Cancel iptal belirteçlerinden herhangi birini iptal etmek için yöntemini çağırır ve ardından beş saniye boyunca geciktirilir. Görevin kendisine iptal belirtecinin geçirilmediğini ve iptal edilemediğini unutmayın. Uygulama iş parçacığı görevin tamamlanmasını beklemek için görevin Task.Wait yöntemini çağırır, ancak iptal belirteci iptal edildikten ve bir OperationCanceledException oluşturulduktan sonra bekleme iptal edilir. Özel durum işleyicisi özel durumu bildirir ve altı saniye boyunca uyku moduna girer. Örnekteki çıktıda gösterildiği gibi, bu gecikme görevin durumunda tamamlanmasını RanToCompletion sağlar.

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

Açıklamalar

Wait(CancellationToken) yöntemi iptal edilebilir bir bekleme oluşturur; yani geçerli iş parçacığının aşağıdakilerden biri gerçekleşene kadar beklemesine neden olur:

Not

İptal belirtecinin cancellationToken iptali, iptal belirteci de geçirilmediği ve iptali işlemeye hazır olmadığı sürece çalışan görev üzerinde hiçbir etkisi olmaz. cancellationToken Nesnesinin bu yönteme geçirilmesi, beklemenin iptal edilmesini sağlar.

Şunlara uygulanır

Wait(TimeSpan)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Yürütmenin Task belirli bir zaman aralığı içinde tamamlanmasını bekler.

public:
 bool Wait(TimeSpan timeout);
public bool Wait (TimeSpan timeout);
member this.Wait : TimeSpan -> bool
Public Function Wait (timeout As TimeSpan) As Boolean

Parametreler

timeout
TimeSpan

TimeSpan Bekleyebilecek milisaniye sayısını temsil eden veya süresiz olarak bekleyebilecek -1 milisaniyeyi temsil eden birTimeSpan.

Döndürülenler

Boolean

trueTask ayrılan süre içinde tamamlanan yürütme ise; değilse, false.

Özel durumlar

ObjectDisposedException

Task yok edildi.

ArgumentOutOfRangeException

timeout , -1 milisaniye dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

-veya-

timeoutInt32.MaxValue değerinden büyüktür.

AggregateException

Görev iptal edildi. Koleksiyon InnerExceptions bir TaskCanceledException nesnesi içerir.

-veya-

Görevin yürütülmesi sırasında bir özel durum oluştu. Koleksiyon, InnerExceptions özel durum veya özel durumlar hakkında bilgi içerir.

Örnekler

Aşağıdaki örnek, 0 ile 100 arasında beş milyon rastgele tamsayı oluşturan ve ortalamalarını hesaplayan bir görev başlatır. Örnek, uygulamanın 150 milisaniye içinde tamamlanmasını beklemek için yöntemini kullanır Wait(TimeSpan) . Uygulama normal şekilde tamamlanırsa, görev oluşturduğu rastgele sayıların toplamını ve ortalamasını görüntüler. Zaman aşımı aralığı dolduysa, örnekte sonlandırılana kadar bir ileti görüntülenir.

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.

Açıklamalar

Wait(TimeSpan) , aşağıdakilerden biri gerçekleşene kadar çağıran iş parçacığının geçerli görev örneğinin tamamlanmasını beklemesine neden olan bir eşitleme yöntemidir:

  • Görev başarıyla tamamlar.

  • Görevin kendisi iptal edilir veya bir özel durum oluşturur. Bu durumda, bir AggregateException özel durumu işlersiniz. özelliği özel AggregateException.InnerExceptions durum veya özel durumlar hakkındaki ayrıntıları içerir.

  • Geçen süreler tarafından timeout tanımlanan aralık. Bu durumda, geçerli iş parçacığı yürütmeyi sürdürür ve yöntemi döndürür false.

Şunlara uygulanır

Wait(Int32, CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce bir zaman aşımı aralığı geçtiğinde veya iptal belirteci iptal edilirse bekleme sonlandırılır.

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

Parametreler

millisecondsTimeout
Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

cancellationToken
CancellationToken

Görevin tamamlanmasını beklerken gözlemlenen bir iptal belirteci.

Döndürülenler

Boolean

trueTask ayrılan süre içinde tamamlanan yürütme ise; değilse, false.

Özel durumlar

OperationCanceledException

İptal cancellationToken edildi.

ObjectDisposedException

Task yok edildi.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AggregateException

Görev iptal edildi. Koleksiyon InnerExceptions bir TaskCanceledException nesnesi içerir.

-veya-

Görevin yürütülmesi sırasında bir özel durum oluştu. Koleksiyon, InnerExceptions özel durum veya özel durumlar hakkında bilgi içerir.

Örnekler

Aşağıdaki örnek, hem bir zaman aşımı değeri hem de görevin tamamlanması için beklemeyi sonlandırabilecek bir iptal belirteci sağlamak için yöntemini çağırır Wait(Int32, CancellationToken) . Yeni bir iş parçacığı başlatılır ve yöntemini yürütür CancelToken ; bu yöntem duraklatılır ve ardından iptal belirteçlerini iptal etmek için yöntemini çağırır CancellationTokenSource.Cancel . Daha sonra bir görev başlatılır ve 5 saniye boyunca geciktirilir. Daha Wait sonra görevin tamamlanmasını beklemek için yöntemi çağrılır ve hem kısa bir zaman aşımı değeri hem de iptal belirteci sağlanır.

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

Örnekten kesin çıkışın, bekleme işleminin iptal belirteci nedeniyle mi yoksa zaman aşımı aralığı geçtiği için mi iptal edildiğine bağlı olduğunu unutmayın.

Açıklamalar

Wait(Int32, CancellationToken) , aşağıdakilerden biri gerçekleşene kadar çağıran iş parçacığının geçerli görev örneğinin tamamlanmasını beklemesine neden olan bir eşitleme yöntemidir:

  • Görev başarıyla tamamlar.

  • Görevin kendisi iptal edilir veya bir özel durum oluşturur. Bu durumda, bir AggregateException özel durumu işlersiniz. özelliği özel AggregateException.InnerExceptions durum veya özel durumlar hakkındaki ayrıntıları içerir.

  • İptal cancellationToken belirteci iptal edilir. Bu durumda, yöntemine yapılan Wait(Int32, CancellationToken) çağrı bir OperationCanceledExceptionoluşturur.

  • Geçen süreler tarafından millisecondsTimeout tanımlanan aralık. Bu durumda, geçerli iş parçacığı yürütmeyi sürdürür ve yöntemi döndürür false.

Not

İptal belirtecinin cancellationToken iptali, iptal belirteci de geçirilmediği ve iptali işlemeye hazır olmadığı sürece çalışan görev üzerinde hiçbir etkisi olmaz. cancellationToken nesnesinin bu yönteme geçirilmesi, beklemenin bazı koşullar temelinde iptal edilmesini sağlar.

Şunlara uygulanır

Wait(TimeSpan, CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

yürütmenin Task tamamlanmasını bekler.

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

Parametreler

timeout
TimeSpan

Bekleme veya InfiniteTimeSpan süresiz bekleme süresi

cancellationToken
CancellationToken

CancellationToken Görevin tamamlanmasını beklerken gözlemlemek için bir.

Döndürülenler

Boolean

trueTask ayrılan süre içinde tamamlanan yürütme ise; değilse, false.

Özel durumlar

AggregateException

Task iptal edildi

-veya-

yürütmesi Tasksırasında bir özel durum oluştu.

ArgumentOutOfRangeException

timeout -1 milisaniye dışında bir negatif sayıdır ve bu da sonsuz zaman aşımını temsil eder

-veya-

zaman aşımı değerinden büyüktür MaxValue.

OperationCanceledException

İptal cancellationToken edildi.

Şunlara uygulanır