Task.Wait Metod

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

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

Parametrar

Returer

trueom den Task slutförda körningen inom den tilldelade tiden, annars . false

Undantag

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

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

Parametrar

Returer

trueom den Task slutförda körningen inom den tilldelade tiden, annars . false

Undantag

Exempel

I följande exempel anropas Wait(Int32, CancellationToken) metoden för att ange både ett timeout-värde och en annulleringstoken som kan avsluta väntan på att en aktivitet har slutförts. En ny tråd startas CancelToken och kör metoden, som pausar och sedan anropar CancellationTokenSource.Cancel metoden för att avbryta annulleringstoken. En uppgift startas sedan och fördröjs i 5 sekunder. Metoden Wait anropas sedan för att vänta tills aktiviteten har slutförts och får både ett kort timeout-värde och en annulleringstoken.

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

Observera att de exakta utdata från exemplet beror på om väntetiden avbröts på grund av annulleringstoken eller på grund av att tidsgränsintervallet förflutit.

Kommentarer

Wait(Int32, CancellationToken) är en synkroniseringsmetod som gör att den anropande tråden väntar på att den aktuella aktivitetsinstansen ska slutföras tills något av följande inträffar:

• Uppgiften har slutförts.

• Själva uppgiften avbryts eller utlöser ett undantag. I det här fallet hanterar du ett AggregateException undantag. Egenskapen AggregateException.InnerExceptions innehåller information om undantaget eller undantagen.

• Annulleringstoken cancellationToken avbryts. I det här fallet genererar anropet Wait(Int32, CancellationToken) till metoden en OperationCanceledException.

• Intervallet som definieras av millisecondsTimeout förflutit. I det här fallet återupptar den aktuella tråden körningen och metoden returnerar false.

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

public:
 bool Wait(TimeSpan timeout);

public bool Wait(TimeSpan timeout);

member this.Wait : TimeSpan -> bool

Public Function Wait (timeout As TimeSpan) As Boolean

Parametrar

Returer

trueom den Task slutförda körningen inom den tilldelade tiden, annars . false

Undantag

Exempel

I följande exempel startar en uppgift som genererar fem miljoner slumpmässiga heltal mellan 0 och 100 och beräknar deras medelvärde. I exemplet används Wait(TimeSpan) metoden för att vänta tills programmet har slutförts inom 150 millisekunder. Om programmet slutförs normalt visar aktiviteten summan och medelvärdet av de slumpmässiga tal som det har genererat. Om tidsgränsintervallet har förflutit visar exemplet ett meddelande innan det avslutas.

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.

Kommentarer

Wait(TimeSpan) är en synkroniseringsmetod som gör att den anropande tråden väntar på att den aktuella aktivitetsinstansen ska slutföras tills något av följande inträffar:

• Uppgiften har slutförts.

• Själva uppgiften avbryts eller utlöser ett undantag. I det här fallet hanterar du ett AggregateException undantag. Egenskapen AggregateException.InnerExceptions innehåller information om undantaget eller undantagen.

• Intervallet som definieras av timeout förflutit. I det här fallet återupptar den aktuella tråden körningen och metoden returnerar false.

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

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)

Parametrar

Undantag

Exempel

I följande exempel visas den enkla användningen av en annulleringstoken för att avbryta väntan på att en aktivitet ska slutföras. En uppgift startas, anropar CancellationTokenSource.Cancel metoden för att avbryta någon av tokenkällans annulleringstoken och fördröjer sedan i fem sekunder. Observera att själva uppgiften inte har skickats annulleringstoken och inte kan avbrytas. Programtråden anropar aktivitetens metod för att vänta tills Task.Wait aktiviteten har slutförts, men väntan avbryts när annulleringstoken har avbrutits och en OperationCanceledException genereras. Undantagshanteraren rapporterar undantaget och viloläge i sex sekunder. Som utdata från exemplet visar tillåter den fördröjningen att aktiviteten slutförs i tillståndet 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

Kommentarer

Metoden Wait(CancellationToken) skapar en väntetid som kan avbrytas. Det innebär att den aktuella tråden väntar tills något av följande inträffar:

• Uppgiften slutförs.

• Annulleringstoken avbryts. I det här fallet genererar anropet Wait(CancellationToken) till metoden en OperationCanceledException.

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

public:
 void Wait();

public void Wait();

member this.Wait : unit -> unit

Public Sub Wait ()

Undantag

Exempel

I följande exempel startas en uppgift som genererar en miljon slumpmässiga heltal mellan 0 och 100 och beräknar deras medelvärde. I exemplet används Wait metoden för att säkerställa att aktiviteten slutförs innan programmet avslutas. Annars, eftersom det här är ett konsolprogram, skulle exemplet avslutas innan uppgiften kan beräkna och visa medelvärdet.

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

Kommentarer

Wait är en synkroniseringsmetod som gör att den anropande tråden väntar tills den aktuella aktiviteten har slutförts. Om den aktuella aktiviteten inte har startat körningen försöker wait-metoden ta bort aktiviteten från schemaläggaren och köra den infogad i den aktuella tråden. Om det inte går att göra det, eller om den aktuella aktiviteten redan har startat körningen, blockerar den anropande tråden tills uppgiften har slutförts. Mer information finns i Task.Wait och "Inlining" i bloggen Parallell programmering med .NET.

Se även

• Task.Wait och "Inlining"

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

Källa:

Task.cs

public:
 bool Wait(int millisecondsTimeout);

public bool Wait(int millisecondsTimeout);

member this.Wait : int -> bool

Public Function Wait (millisecondsTimeout As Integer) As Boolean

Parametrar

Returer

trueom den Task slutförda körningen inom den tilldelade tiden, annars . false

Undantag

Exempel

I följande exempel startar en uppgift som genererar fem miljoner slumpmässiga heltal mellan 0 och 100 och beräknar deras medelvärde. I exemplet används Wait(Int32) metoden för att vänta tills programmet har slutförts inom 150 millisekunder. Om programmet slutförs normalt visar aktiviteten summan och medelvärdet av de slumpmässiga tal som det har genererat. Om tidsgränsintervallet har förflutit visar exemplet ett meddelande innan det avslutas.

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.

Kommentarer

Wait(Int32) är en synkroniseringsmetod som gör att den anropande tråden väntar på att den aktuella aktivitetsinstansen ska slutföras tills något av följande inträffar:

• Uppgiften har slutförts.

• Själva uppgiften avbryts eller utlöser ett undantag. I det här fallet hanterar du ett AggregateException undantag. Egenskapen AggregateException.InnerExceptions innehåller information om undantaget eller undantagen.

• Intervallet som definieras av millisecondsTimeout förflutit. I det här fallet återupptar den aktuella tråden körningen och metoden returnerar false.