Teilen über

Task.Wait Methode

  • Referenz

Definition

Namespace:
System.Threading.Tasks
Assembly:
System.Runtime.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Wartet, bis der Task die Ausführung abschließt.

Überlädt

Wait(TimeSpan, CancellationToken)

Wartet, bis der Task die Ausführung abschließt.
Wait(Int32, CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.
Wait(TimeSpan)

Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird.
Wait(CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.
Wait()

Wartet, bis der Task die Ausführung abschließt.
Wait(Int32)

Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird.

Wait(TimeSpan, CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet, bis der Task die Ausführung abschließt.

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

Die Zeit, die gewartet werden soll oder InfiniteTimeSpan unbegrenzt gewartet werden soll

cancellationToken
CancellationToken

Ein CancellationToken , der beim Warten auf den Abschluss der Aufgabe zu beobachten ist.

Gibt zurück

Boolean

true, wenn der Task die Ausführung innerhalb der zugewiesenen Zeit abgeschlossen hat, andernfalls false.

Ausnahmen

AggregateException

Die Task wurde abgebrochen.

Oder

Während der Ausführung von Taskwurde eine Ausnahme ausgelöst.

ArgumentOutOfRangeException

timeout ist eine andere negative Zahl als -1 Millisekunden, was ein unendliches Timeout darstellt

Oder

Das Timeout ist größer als MaxValue.

OperationCanceledException

Das cancellationToken wurde abgebrochen.

Gilt für:

Wait(Int32, CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

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

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.

cancellationToken
CancellationToken

Ein Abbruchtoken, das beim Warten auf den Abschluss der Aufgabe überwacht werden soll.

Gibt zurück

Boolean

true, wenn der Task die Ausführung innerhalb der zugewiesenen Zeit abgeschlossen hat, andernfalls false.

Ausnahmen

OperationCanceledException

Das cancellationToken wurde abgebrochen.

ObjectDisposedException

Task wurde verworfen.

ArgumentOutOfRangeException

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.

AggregateException

Der Task wurde abgebrochen. Die InnerExceptions-Sammlung enthält ein TaskCanceledException-Objekt.

- oder -

Während der Ausführung des Tasks wurde eine Ausnahme ausgelöst. Die InnerExceptions-Sammlung enthält Informationen zu der Ausnahme bzw. den Ausnahmen.

Beispiele

Im folgenden Beispiel wird die Wait(Int32, CancellationToken) -Methode aufgerufen, um sowohl einen Timeoutwert als auch ein Abbruchtoken bereitzustellen, das die Wartezeit auf den Abschluss einer Aufgabe beenden kann. Ein neuer Thread wird gestartet und führt die CancelToken -Methode aus, die anhält und dann die CancellationTokenSource.Cancel -Methode aufruft, um die Abbruchtoken abzubrechen. Anschließend wird eine Aufgabe gestartet und verzögert sich um 5 Sekunden. Die Wait Methode wird dann aufgerufen, um auf den Abschluss der Aufgabe zu warten, und es wird sowohl ein kurzer Timeoutwert als auch ein Abbruchtoken bereitgestellt.

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

Beachten Sie, dass die genaue Ausgabe des Beispiels davon abhängt, ob die Wartezeit aufgrund des Abbruchtokens abgebrochen wurde oder ob das Timeoutintervall verstrichen ist.

Hinweise

Wait(Int32, CancellationToken)ist eine Synchronisierungsmethode, die dazu führt, dass der aufrufende Thread wartet, bis die aktuelle Aufgabe instance abgeschlossen ist, bis eine der folgenden Aktionen eintritt:

  • Die Aufgabe wird erfolgreich abgeschlossen.

  • Die Aufgabe selbst wird abgebrochen oder löst eine Ausnahme aus. In diesem Fall behandeln Sie eine AggregateException Ausnahme. Die AggregateException.InnerExceptions -Eigenschaft enthält Details zu der Ausnahme oder den Ausnahmen.

  • Das cancellationToken Abbruchtoken wird abgebrochen. In diesem Fall löst der Aufruf der Wait(Int32, CancellationToken) -Methode einen aus OperationCanceledException.

  • Das durch millisecondsTimeout Verstreichen definierte Intervall. In diesem Fall setzt der aktuelle Thread die Ausführung fort, und die -Methode gibt zurück false.

Hinweis

Das Abbrechen des cancellationToken Abbruchtokens hat keine Auswirkungen auf den ausgeführten Task, es sei denn, es wurde auch das Abbruchtoken übergeben und ist bereit, den Abbruch zu behandeln. Das Übergeben des cancellationToken Objekts an diese Methode ermöglicht einfach, dass die Wartezeit basierend auf einer Bestimmten Bedingung abgebrochen wird.

Gilt für:

Wait(TimeSpan)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird.

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

Eine TimeSpan-Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine TimeSpan-Struktur, die -1 Millisekunden zum unendlichen Warten angibt.

Gibt zurück

Boolean

true, wenn der Task die Ausführung innerhalb der zugewiesenen Zeit abgeschlossen hat, andernfalls false.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentOutOfRangeException

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.

- oder -

timeout ist größer als Int32.MaxValue.

AggregateException

Der Task wurde abgebrochen. Die InnerExceptions-Sammlung enthält ein TaskCanceledException-Objekt.

- oder -

Während der Ausführung des Tasks wurde eine Ausnahme ausgelöst. Die InnerExceptions-Sammlung enthält Informationen zu der Ausnahme bzw. den Ausnahmen.

Beispiele

Im folgenden Beispiel wird eine Aufgabe gestartet, die fünf Millionen zufällige ganze Zahlen zwischen 0 und 100 generiert und deren Mittelwert berechnet. Im Beispiel wird die Wait(TimeSpan) -Methode verwendet, um zu warten, bis die Anwendung innerhalb von 150 Millisekunden abgeschlossen ist. Wenn die Anwendung normal abgeschlossen wird, zeigt der Task die Summe und den Mittelwert der generierten Zufallszahlen an. Wenn das Timeoutintervall abgelaufen ist, wird im Beispiel eine Meldung angezeigt, bevor es beendet wird.

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.

Hinweise

Wait(TimeSpan)ist eine Synchronisierungsmethode, die dazu führt, dass der aufrufende Thread wartet, bis die aktuelle Aufgabe instance abgeschlossen ist, bis eine der folgenden Aktionen eintritt:

  • Die Aufgabe wird erfolgreich abgeschlossen.

  • Die Aufgabe selbst wird abgebrochen oder löst eine Ausnahme aus. In diesem Fall behandeln Sie eine AggregateException Ausnahme. Die AggregateException.InnerExceptions -Eigenschaft enthält Details zu der Ausnahme oder den Ausnahmen.

  • Das durch timeout Verstreichen definierte Intervall. In diesem Fall setzt der aktuelle Thread die Ausführung fort, und die -Methode gibt zurück false.

Gilt für:

Wait(CancellationToken)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

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

Ein Abbruchtoken, das beim Warten auf den Abschluss der Aufgabe überwacht werden soll.

Ausnahmen

OperationCanceledException

Das cancellationToken wurde abgebrochen.

ObjectDisposedException

Die Aufgabe wurde verworfen.

AggregateException

Der Task wurde abgebrochen. Die InnerExceptions-Sammlung enthält ein TaskCanceledException-Objekt.

- oder -

Während der Ausführung des Tasks wurde eine Ausnahme ausgelöst. Die InnerExceptions-Sammlung enthält Informationen zu der Ausnahme bzw. den Ausnahmen.

Beispiele

Das folgende Beispiel veranschaulicht die einfache Verwendung eines Abbruchtokens, um das Warten auf den Abschluss eines Vorgangs abzubrechen. Eine Aufgabe wird gestartet, ruft die CancellationTokenSource.Cancel -Methode auf, um die Abbruchtoken der Tokenquelle abzubrechen, und verzögert sich dann um fünf Sekunden. Beachten Sie, dass die Aufgabe selbst das Abbruchtoken nicht übergeben hat und nicht abbruchfähig ist. Der Anwendungsthread ruft die Methode der Aufgabe Task.Wait auf, um auf den Abschluss der Aufgabe zu warten, aber die Wartezeit wird abgebrochen, sobald das Abbruchtoken abgebrochen und ein OperationCanceledException ausgelöst wird. Der Ausnahmehandler meldet die Ausnahme und schläft dann sechs Sekunden lang. Wie die Ausgabe aus dem Beispiel zeigt, ermöglicht diese Verzögerung, dass die Aufgabe im RanToCompletion Zustand abgeschlossen werden kann.

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

Hinweise

Die Wait(CancellationToken) -Methode erstellt eine abbruchbare Wartezeit. Das heißt, sie bewirkt, dass der aktuelle Thread wartet, bis einer der folgenden Auftritte auftritt:

Hinweis

Das Abbrechen des cancellationToken Abbruchtokens hat keine Auswirkungen auf den ausgeführten Task, es sei denn, es wurde auch das Abbruchtoken übergeben und ist bereit, den Abbruch zu behandeln. Wenn Sie das cancellationToken Objekt an diese Methode übergeben, kann die Wartezeit einfach abgebrochen werden.

Gilt für:

Wait()

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet, bis der Task die Ausführung abschließt.

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

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

AggregateException

Der Task wurde abgebrochen. Die InnerExceptions-Sammlung enthält ein TaskCanceledException-Objekt.

- oder -

Während der Ausführung des Tasks wurde eine Ausnahme ausgelöst. Die InnerExceptions-Sammlung enthält Informationen zu der Ausnahme bzw. den Ausnahmen.

Beispiele

Im folgenden Beispiel wird eine Aufgabe gestartet, die eine Million zufällige ganze Zahlen zwischen 0 und 100 generiert und deren Mittelwert berechnet. Im Beispiel wird die Wait -Methode verwendet, um sicherzustellen, dass der Task abgeschlossen wird, bevor die Anwendung beendet wird. Andernfalls wird das Beispiel beendet, da es sich um eine Konsolenanwendung handelt, bevor die Aufgabe den Mittelwert berechnen und anzeigen kann.

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

Hinweise

Wait ist eine Synchronisierungsmethode, die dazu führt, dass der aufrufende Thread wartet, bis die aktuelle Aufgabe abgeschlossen ist. Wenn die Ausführung der aktuellen Aufgabe nicht gestartet wurde, versucht die Wait-Methode, den Task aus dem Planer zu entfernen und inline im aktuellen Thread auszuführen. Wenn dies nicht möglich ist oder die Ausführung der aktuellen Aufgabe bereits gestartet wurde, blockiert sie den aufrufenden Thread, bis die Aufgabe abgeschlossen ist. Weitere Informationen finden Sie unter Task.Wait und "Inlining" im Blog Parallele Programmierung mit .NET.

Weitere Informationen

Gilt für:

Wait(Int32)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird.

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

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.

Gibt zurück

Boolean

true, wenn der Task die Ausführung innerhalb der zugewiesenen Zeit abgeschlossen hat, andernfalls false.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentOutOfRangeException

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.

AggregateException

Der Task wurde abgebrochen. Die InnerExceptions-Sammlung enthält ein TaskCanceledException-Objekt.

- oder -

Während der Ausführung des Tasks wurde eine Ausnahme ausgelöst. Die InnerExceptions-Sammlung enthält Informationen zu der Ausnahme bzw. den Ausnahmen.

Beispiele

Im folgenden Beispiel wird eine Aufgabe gestartet, die fünf Millionen zufällige ganze Zahlen zwischen 0 und 100 generiert und deren Mittelwert berechnet. Im Beispiel wird die Wait(Int32) -Methode verwendet, um zu warten, bis die Anwendung innerhalb von 150 Millisekunden abgeschlossen ist. Wenn die Anwendung normal abgeschlossen wird, zeigt der Task die Summe und den Mittelwert der generierten Zufallszahlen an. Wenn das Timeoutintervall abgelaufen ist, wird im Beispiel eine Meldung angezeigt, bevor es beendet wird.

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.

Hinweise

Wait(Int32)ist eine Synchronisierungsmethode, die dazu führt, dass der aufrufende Thread wartet, bis die aktuelle Aufgabe instance abgeschlossen ist, bis eine der folgenden Aktionen eintritt:

  • Die Aufgabe wird erfolgreich abgeschlossen.

  • Die Aufgabe selbst wird abgebrochen oder löst eine Ausnahme aus. In diesem Fall behandeln Sie eine AggregateException Ausnahme. Die AggregateException.InnerExceptions -Eigenschaft enthält Details zu der Ausnahme oder den Ausnahmen.

  • Das durch millisecondsTimeout Verstreichen definierte Intervall. In diesem Fall setzt der aktuelle Thread die Ausführung fort, und die -Methode gibt zurück false.

Gilt für: