Task.WaitAll Metod

Definition

Namnområde:: System.Threading.Tasks

Sammansättningar:: mscorlib.dll, System.Threading.Tasks.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Threading.Tasks.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Väntar på att alla angivna Task objekt ska slutföra körningen.

Överlagringar

Name	Description
WaitAll(Task[], Int32, CancellationToken)	Väntar tills alla angivna Task objekt slutför körningen inom ett angivet antal millisekunder eller tills väntan avbryts.
WaitAll(ReadOnlySpan<Task>)	Väntar på att alla angivna Task objekt ska slutföra körningen.
WaitAll(Task[])	Väntar på att alla angivna Task objekt ska slutföra körningen.
WaitAll(IEnumerable<Task>, CancellationToken)	Väntar på att alla angivna Task objekt ska slutföra körningen om inte väntan avbryts.
WaitAll(Task[], Int32)	Väntar på att alla angivna Task objekt ska slutföra körningen inom ett angivet antal millisekunder.
WaitAll(Task[], CancellationToken)	Väntar på att alla angivna Task objekt ska slutföra körningen om inte väntan avbryts.
WaitAll(Task[], TimeSpan)	Väntar på att alla angivna cancellable-objekt Task ska slutföra körningen inom ett angivet tidsintervall.

WaitAll(Task[], Int32, CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar tills alla angivna Task objekt slutför körningen inom ett angivet antal millisekunder eller tills väntan avbryts.

public:
 static bool WaitAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, int millisecondsTimeout, System::Threading::CancellationToken cancellationToken);

public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);

static member WaitAll : System.Threading.Tasks.Task[] * int * System.Threading.CancellationToken -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : System.Threading.Tasks.Task[] * int * System.Threading.CancellationToken -> bool

Public Shared Function WaitAll (tasks As Task(), millisecondsTimeout As Integer, cancellationToken As CancellationToken) As Boolean

Parametrar

tasks: Task[]

En matris med Task instanser som du kan vänta på.

millisecondsTimeout: Int32

Antalet millisekunder som ska vänta eller Infinite (-1) för att vänta på obestämd tid.

cancellationToken: CancellationToken

A CancellationToken att observera i väntan på att aktiviteterna ska slutföras.

Returer

Boolean

trueom alla Task instanser slutförde körningen inom den tilldelade tiden, annars . false

Attribut: UnsupportedOSPlatformAttribute

Undantag

ObjectDisposedException

Ett eller flera av objekten Task i tasks har tagits bort.

ArgumentNullException

Argumentet tasks är null.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller den AggregateException en OperationCanceledException i samlingen InnerExceptions .

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

ArgumentOutOfRangeException

millisecondsTimeout är ett annat negativt tal än -1, vilket representerar en oändlig timeout.

ArgumentException

Argumentet tasks innehåller ett null-element.

OperationCanceledException

Det cancellationToken avbröts.

Kommentarer

Argumentet cancellationToken används för att avbryta vänteåtgärden. Annullering av uppgifterna är en distinkt åtgärd och signaleras av ovan AggregateException antecknade uppgifter.

Gäller för

WaitAll(ReadOnlySpan<Task>)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna Task objekt ska slutföra körningen.

public:
 static void WaitAll(ReadOnlySpan<System::Threading::Tasks::Task ^> tasks);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static void WaitAll(scoped ReadOnlySpan<System.Threading.Tasks.Task> tasks);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : ReadOnlySpan<System.Threading.Tasks.Task> -> unit

Public Shared Sub WaitAll (tasks As ReadOnlySpan(Of Task))

Parametrar

tasks: ReadOnlySpan<Task>

En matris med Task instanser som du kan vänta på.

Attribut: UnsupportedOSPlatformAttribute

Undantag

ArgumentNullException

Argumentet tasks innehåller ett null element.

AggregateException

Minst en av Task instanserna avbröts.

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

Gäller för

WaitAll(Task[])

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna Task objekt ska slutföra körningen.

public:
 static void WaitAll(... cli::array <System::Threading::Tasks::Task ^> ^ tasks);

public static void WaitAll(params System.Threading.Tasks.Task[] tasks);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static void WaitAll(params System.Threading.Tasks.Task[] tasks);

static member WaitAll : System.Threading.Tasks.Task[] -> unit

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : System.Threading.Tasks.Task[] -> unit

Public Shared Sub WaitAll (ParamArray tasks As Task())

Parametrar

tasks: Task[]

En matris med Task instanser som du kan vänta på.

Attribut: UnsupportedOSPlatformAttribute

Undantag

ObjectDisposedException

Ett eller flera av objekten Task i tasks har tagits bort.

ArgumentNullException

Argumentet tasks är null.

ArgumentException

Argumentet tasks innehåller ett null-element.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller undantaget AggregateException ett OperationCanceledException undantag i samlingen InnerExceptions .

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

Exempel

I följande exempel startar 10 uppgifter, som vart och ett skickas ett index som ett tillståndsobjekt. Uppgifter med ett index från två till fem utlöser undantag. Anropet WaitAll till metoden omsluter alla undantag i ett AggregateException objekt och sprider det till den anropande tråden.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        var tasks = new List<Task<int>>();
         
        // Define a delegate that prints and returns the system tick count
        Func<object, int> action = (object obj) =>
        {
            int i = (int)obj;

            // Make each thread sleep a different time in order to return a different tick count
            Thread.Sleep(i * 100);

            // The tasks that receive an argument between 2 and 5 throw exceptions
            if (2 <= i && i <= 5)
            {
                throw new InvalidOperationException("SIMULATED EXCEPTION");
            }

            int tickCount = Environment.TickCount;
            Console.WriteLine("Task={0}, i={1}, TickCount={2}, Thread={3}", Task.CurrentId, i, tickCount, Thread.CurrentThread.ManagedThreadId);

            return tickCount;
        };

        // Construct started tasks
        for (int i = 0; i < 10; i++)
        {
            int index = i;
            tasks.Add(Task<int>.Factory.StartNew(action, index));
        }

        try
        {
            // Wait for all the tasks to finish.
            Task.WaitAll(tasks.ToArray());

            // We should never get to this point
            Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED.");
        }
        catch (AggregateException e)
        {
            Console.WriteLine("\nThe following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)");
            for (int j = 0; j < e.InnerExceptions.Count; j++)
            {
                Console.WriteLine("\n-------------------------------------------------\n{0}", e.InnerExceptions[j].ToString());
            }
        }
    }
}
// The example displays output like the following:
//     Task=1, i=0, TickCount=1203822250, Thread=3
//     Task=2, i=1, TickCount=1203822359, Thread=4
//     Task=7, i=6, TickCount=1203823484, Thread=3
//     Task=8, i=7, TickCount=1203823890, Thread=4
//     Task=9, i=8, TickCount=1203824296, Thread=3
//     Task=10, i=9, TickCount=1203824796, Thread=4
//     
//     The following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)
//     
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//     
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//     
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//     
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()

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

// Define a delegate that prints and returns the system tick count
let action =
    fun (obj: obj) ->
        let i = obj :?> int

        // Make each thread sleep a different time in order to return a different tick count
        Thread.Sleep(i * 100)

        // The tasks that receive an argument between 2 and 5 throw exceptions
        if 2 <= i && i <= 5 then
            raise (InvalidOperationException "SIMULATED EXCEPTION")


        let tickCount = Environment.TickCount
        printfn $"Task={Task.CurrentId}, i={i}, TickCount={tickCount}, Thread={Thread.CurrentThread.ManagedThreadId}"
        tickCount

// Construct started tasks
let tasks =
    [| for i = 0 to 9 do
           Task<int>.Factory.StartNew (action, i) |]

try

    // Wait for all the tasks to finish.
    Seq.cast tasks |> Seq.toArray |> Task.WaitAll

    // We should never get to this point
    printfn "WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED."

with :? AggregateException as e ->
    printfn "\nThe following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)"

    for ex in e.InnerExceptions do
        printfn $"\n-------------------------------------------------\n{ex}"

// The example displays output like the following:
//     Task=1, i=0, TickCount=1203822250, Thread=3
//     Task=2, i=1, TickCount=1203822359, Thread=4
//     Task=7, i=6, TickCount=1203823484, Thread=3
//     Task=8, i=7, TickCount=1203823890, Thread=4
//     Task=9, i=8, TickCount=1203824296, Thread=3
//     Task=10, i=9, TickCount=1203824796, Thread=4
//
//     The following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)
//
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()
//
//     -------------------------------------------------
//     System.InvalidOperationException: SIMULATED EXCEPTION
//        at Example.<Main>b__0(Object obj)
//        at System.Threading.Tasks.Task`1.InnerInvoke()
//        at System.Threading.Tasks.Task.Execute()

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module WaitAllDemo
    Sub Main()
        Dim tasks As New List(Of Task(Of Integer))()
        ' Define a delegate that prints and returns the system tick count
        Dim action As Func(Of Object, Integer) = Function(obj As Object)
                                                     Dim i As Integer = CInt(obj)

                                                     ' Make each thread sleep a different time in order to return a different tick count
                                                     Thread.Sleep(i * 100)

                                                     ' The tasks that receive an argument between 2 and 5 throw exceptions
                                                     If 2 <= i AndAlso i <= 5 Then
                                                         Throw New InvalidOperationException("SIMULATED EXCEPTION")
                                                     End If

                                                     Dim tickCount As Integer = Environment.TickCount
                                                     Console.WriteLine("Task={0}, i={1}, TickCount={2}, Thread={3}", Task.CurrentId, i, tickCount, Thread.CurrentThread.ManagedThreadId)

                                                     Return tickCount
                                                 End Function

        ' Construct started tasks
        For i As Integer = 0 To 9
            Dim index As Integer = i
            tasks.Add(Task(Of Integer).Factory.StartNew(action, index))
        Next

        Try
            ' Wait for all the tasks to finish.
            Task.WaitAll(tasks.ToArray())

            ' We should never get to this point
            Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED.")
        Catch e As AggregateException
            Console.WriteLine(vbLf & "The following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)")
            For j As Integer = 0 To e.InnerExceptions.Count - 1
                Console.WriteLine(vbLf & "-------------------------------------------------" & vbLf & "{0}", e.InnerExceptions(j).ToString())
            Next
        End Try
    End Sub
End Module
' The example displays output like the following:
'     Task=1, i=0, TickCount=1203822250, Thread=3
'     Task=2, i=1, TickCount=1203822359, Thread=4
'     Task=7, i=6, TickCount=1203823484, Thread=3
'     Task=8, i=7, TickCount=1203823890, Thread=4
'     Task=9, i=8, TickCount=1203824296, Thread=3
'     Task=10, i=9, TickCount=1203824796, Thread=4
'     
'     The following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)
'     
'     -------------------------------------------------
'     System.InvalidOperationException: SIMULATED EXCEPTION
'        at Example.<Main>b__0(Object obj)
'        at System.Threading.Tasks.Task`1.InnerInvoke()
'        at System.Threading.Tasks.Task.Execute()
'     
'     -------------------------------------------------
'     System.InvalidOperationException: SIMULATED EXCEPTION
'        at Example.<Main>b__0(Object obj)
'        at System.Threading.Tasks.Task`1.InnerInvoke()
'        at System.Threading.Tasks.Task.Execute()
'     
'     -------------------------------------------------
'     System.InvalidOperationException: SIMULATED EXCEPTION
'        at Example.<Main>b__0(Object obj)
'        at System.Threading.Tasks.Task`1.InnerInvoke()
'        at System.Threading.Tasks.Task.Execute()
'     
'     -------------------------------------------------
'     System.InvalidOperationException: SIMULATED EXCEPTION
'        at Example.<Main>b__0(Object obj)
'        at System.Threading.Tasks.Task`1.InnerInvoke()
'        at System.Threading.Tasks.Task.Execute()

Gäller för

WaitAll(IEnumerable<Task>, CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna Task objekt ska slutföra körningen om inte väntan avbryts.

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static void WaitAll(System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task> tasks, System.Threading.CancellationToken cancellationToken = default);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : seq<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> unit

Public Shared Sub WaitAll (tasks As IEnumerable(Of Task), Optional cancellationToken As CancellationToken = Nothing)

Parametrar

tasks: IEnumerable<Task>

En samling uppgifter att vänta på.

cancellationToken: CancellationToken

En token som ska observeras i väntan på att aktiviteterna ska slutföras.

Attribut: UnsupportedOSPlatformAttribute

Undantag

ArgumentNullException

Argumentet tasks är null.

ArgumentException

Argumentet tasks innehåller ett null element.

ObjectDisposedException

Ett eller flera objekt Task i aktiviteter har tagits bort.

OperationCanceledException

Det cancellationToken avbröts.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller den AggregateException en OperationCanceledException i samlingen InnerExceptions .

Gäller för

WaitAll(Task[], Int32)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna Task objekt ska slutföra körningen inom ett angivet antal millisekunder.

public:
 static bool WaitAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, int millisecondsTimeout);

public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout);

static member WaitAll : System.Threading.Tasks.Task[] * int -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : System.Threading.Tasks.Task[] * int -> bool

Public Shared Function WaitAll (tasks As Task(), millisecondsTimeout As Integer) As Boolean

Parametrar

tasks: Task[]

En matris med Task instanser som du kan vänta på.

millisecondsTimeout: Int32

Antalet millisekunder som ska vänta eller Infinite (-1) för att vänta på obestämd tid.

Returer

Boolean

trueom alla Task instanser slutförde körningen inom den tilldelade tiden, annars . false

Attribut: UnsupportedOSPlatformAttribute

Undantag

ObjectDisposedException

Ett eller flera av objekten Task i tasks har tagits bort.

ArgumentNullException

Argumentet tasks är null.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller den AggregateException en OperationCanceledException i samlingen InnerExceptions .

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

ArgumentOutOfRangeException

millisecondsTimeout är ett annat negativt tal än -1, vilket representerar en oändlig timeout.

ArgumentException

Argumentet tasks innehåller ett null-element.

Gäller för

WaitAll(Task[], CancellationToken)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna Task objekt ska slutföra körningen om inte väntan avbryts.

public:
 static void WaitAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, System::Threading::CancellationToken cancellationToken);

public static void WaitAll(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static void WaitAll(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken);

static member WaitAll : System.Threading.Tasks.Task[] * System.Threading.CancellationToken -> unit

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : System.Threading.Tasks.Task[] * System.Threading.CancellationToken -> unit

Public Shared Sub WaitAll (tasks As Task(), cancellationToken As CancellationToken)

Parametrar

tasks: Task[]

En matris med Task instanser som du kan vänta på.

cancellationToken: CancellationToken

A CancellationToken att observera i väntan på att aktiviteterna ska slutföras.

Attribut: UnsupportedOSPlatformAttribute

Undantag

OperationCanceledException

Det cancellationToken avbröts.

ArgumentNullException

Argumentet tasks är null.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller den AggregateException en OperationCanceledException i samlingen InnerExceptions .

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

ArgumentException

Argumentet tasks innehåller ett null-element.

ObjectDisposedException

Ett eller flera av objekten Task i tasks har tagits bort.

Kommentarer

Argumentet cancellationToken används för att avbryta vänteåtgärden. Att avbryta aktiviteterna är en distinkt åtgärd och signaleras av enligt AggregateException ovanstående.

Gäller för

WaitAll(Task[], TimeSpan)

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Källa:: Task.cs

Väntar på att alla angivna cancellable-objekt Task ska slutföra körningen inom ett angivet tidsintervall.

public:
 static bool WaitAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, TimeSpan timeout);

public static bool WaitAll(System.Threading.Tasks.Task[] tasks, TimeSpan timeout);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static bool WaitAll(System.Threading.Tasks.Task[] tasks, TimeSpan timeout);

static member WaitAll : System.Threading.Tasks.Task[] * TimeSpan -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member WaitAll : System.Threading.Tasks.Task[] * TimeSpan -> bool

Public Shared Function WaitAll (tasks As Task(), timeout As TimeSpan) As Boolean

Parametrar

tasks: Task[]

En matris med Task instanser som du kan vänta på.

timeout: TimeSpan

En TimeSpan som representerar antalet millisekunder som ska vänta, eller ett TimeSpan som representerar -1 millisekunder för att vänta på obestämd tid.

Returer

Boolean

trueom alla Task instanser slutförde körningen inom den tilldelade tiden, annars . false

Attribut: UnsupportedOSPlatformAttribute

Undantag

ObjectDisposedException

Ett eller flera av objekten Task i tasks har tagits bort.

ArgumentNullException

Argumentet tasks är null.

AggregateException

Minst en av Task instanserna avbröts. Om en uppgift avbröts innehåller den AggregateException en OperationCanceledException i samlingen InnerExceptions .

-eller-

Ett undantag utlöstes under körningen av minst en av Task instanserna.

ArgumentOutOfRangeException

timeout är ett annat negativt tal än -1 millisekunder, vilket representerar en oändlig timeout.

-eller-

timeout är större än Int32.MaxValue.

ArgumentException

Argumentet tasks innehåller ett null-element.

Gäller för

Feedback

Var den här sidan till hjälp?