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

Sağlanan tüm görevler tamamlandığında tamamlanacak bir görev oluşturur.

Aşırı Yüklemeler

WhenAll(IEnumerable<Task>)

Numaralandırılabilir bir koleksiyondaki tüm Task nesneleri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll(ReadOnlySpan<Task>)

Sağlanan tüm görevler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll(Task[])

Dizideki tüm Task nesneleri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Sağlanan tüm görevler tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Numaralandırılabilir bir koleksiyondaki tüm Task<TResult> nesneleri tamamlandığında tamamlanacak bir görev oluşturur.
WhenAll<TResult>(Task<TResult>[])

Dizideki tüm Task<TResult> nesneleri tamamlandığında tamamlanacak bir görev oluşturur.

WhenAll(IEnumerable<Task>)

Kaynak:
Task.cs
Kaynak:
Task.cs
Kaynak:
Task.cs

Numaralandırılabilir bir koleksiyondaki tüm Task nesneleri tamamlandığında tamamlanacak bir görev oluşturur.

public:
 static System::Threading::Tasks::Task ^ WhenAll(System::Collections::Generic::IEnumerable<System::Threading::Tasks::Task ^> ^ tasks);
public static System.Threading.Tasks.Task WhenAll (System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task> tasks);
static member WhenAll : seq<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Shared Function WhenAll (tasks As IEnumerable(Of Task)) As Task

Parametreler

tasks
IEnumerable<Task>

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentNullException

tasks bağımsız değişkeni null.

ArgumentException

tasks koleksiyonu bir null görevi içeriyordu.

Örnekler

Aşağıdaki örnek, dizideki URL'lere ping atan bir görev kümesi oluşturur. Görevler, WhenAll(IEnumerable<Task>) yöntemine geçirilen bir List<Task> koleksiyonunda depolanır. Wait yöntemine yapılan çağrı tüm iş parçacıklarının tamamlanmasını sağladıktan sonra, örnek Task.Status özelliğini inceleyerek herhangi bir görevde hata olup olmadığını belirler.

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

public class Example
{
   public static void Main()
   {
      int failed = 0;
      var tasks = new List<Task>();
      String[] urls = { "www.adatum.com", "www.cohovineyard.com",
                        "www.cohowinery.com", "www.northwindtraders.com",
                        "www.contoso.com" };
      
      foreach (var value in urls) {
         var url = value;
         tasks.Add(Task.Run( () => { var png = new Ping();
                                     try {
                                        var reply = png.Send(url);
                                        if (! (reply.Status == IPStatus.Success)) {
                                           Interlocked.Increment(ref failed);
                                           throw new TimeoutException("Unable to reach " + url + ".");
                                        }
                                     }
                                     catch (PingException) {
                                        Interlocked.Increment(ref failed);
                                        throw;
                                     }
                                   }));
      }
      Task t = Task.WhenAll(tasks);
      try {
         t.Wait();
      }
      catch {}   

      if (t.Status == TaskStatus.RanToCompletion)
         Console.WriteLine("All ping attempts succeeded.");
      else if (t.Status == TaskStatus.Faulted)
         Console.WriteLine("{0} ping attempts failed", failed);      
   }
}
// The example displays output like the following:
//       5 ping attempts failed

open System
open System.Net.NetworkInformation
open System.Threading
open System.Threading.Tasks

let mutable failed = 0

let urls =
    [ "www.adatum.com"
      "www.cohovineyard.com"
      "www.cohowinery.com"
      "www.northwindtraders.com"
      "www.contoso.com" ]

let tasks =
    urls
    |> List.map (fun url ->
        Task.Run(fun () ->
            let png = new Ping()

            try
                let reply = png.Send url

                if reply.Status <> IPStatus.Success then
                    Interlocked.Increment &failed |> ignore
                    raise (TimeoutException $"Unable to reach {url}.")
            with :? PingException ->
                Interlocked.Increment &failed |> ignore
                reraise ()))

let t = Task.WhenAll tasks

try
    t.Wait()
with _ ->
    ()

if t.Status = TaskStatus.RanToCompletion then
    printfn "All ping attempts succeeded."
elif t.Status = TaskStatus.Faulted then
    printfn $"{failed} ping attempts failed"

// The example displays output like the following:
//       5 ping attempts failed

Imports System.Collections.Generic
Imports System.Net.NetworkInformation
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim failed As Integer = 0
      Dim tasks As New List(Of Task)()
      Dim urls() As String = { "www.adatum.com", "www.cohovineyard.com",
                              "www.cohowinery.com", "www.northwindtraders.com",
                              "www.contoso.com" }
      
      For Each value In urls
         Dim url As String = value
         tasks.Add(Task.Run( Sub()
                                Dim png As New Ping()
                                Try
                                   Dim reply = png.Send(url)
                                   If Not reply.Status = IPStatus.Success Then
                                      Interlocked.Increment(failed)
                                      Throw New TimeoutException("Unable to reach " + url + ".")
                                   End If
                                   Catch e As PingException
                                      Interlocked.Increment(failed)
                                      Throw
                                   End Try
                             End Sub))
      Next
      Dim t As Task = Task.WhenAll(tasks)
      Try
         t.Wait()
      Catch
      End Try   

      If t.Status = TaskStatus.RanToCompletion
         Console.WriteLine("All ping attempts succeeded.")
      ElseIf t.Status = TaskStatus.Faulted
         Console.WriteLine("{0} ping attempts failed", failed)      
      End If
   End Sub
End Module
' The example displays output like the following:
'     5 ping attempts failed

Açıklamalar

bir Task nesnesi döndüren WhenAll yönteminin aşırı yüklemeleri genellikle bir görev kümesinin durumuyla veya bir görev kümesi tarafından oluşan özel durumlarla ilgilendiğinizde çağrılır.

Not

WhenAll(IEnumerable<Task>) yöntemi çağrısı, çağıran iş parçacığını engellemez.

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev de Faulted durumunda tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev Canceled durumunda sona erer.

Görevlerin hiçbiri hatalı değilse ve hiçbir görev iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer.

Sağlanan dizi/numaralandırılabilir görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen RanToCompletion durumuna geçer.

Şunlara uygulanır

WhenAll(ReadOnlySpan<Task>)

Sağlanan tüm görevler tamamlandığında tamamlanacak bir görev oluşturur.

public:
 static System::Threading::Tasks::Task ^ WhenAll(ReadOnlySpan<System::Threading::Tasks::Task ^> tasks);
public static System.Threading.Tasks.Task WhenAll (scoped ReadOnlySpan<System.Threading.Tasks.Task> tasks);
static member WhenAll : ReadOnlySpan<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Shared Function WhenAll (tasks As ReadOnlySpan(Of Task)) As Task

Parametreler

tasks
ReadOnlySpan<Task>

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentException

tasks dizisi bir null görevi içerir.

Açıklamalar

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev hata durumunda da tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev İptal Edildi durumunda sona erer.

Görevlerden hiçbiri hatalı değilse ve görevlerden hiçbiri iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer.

Sağlanan span hiçbir görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen Bir RanToCompletion durumuna geçer.

Şunlara uygulanır

WhenAll(Task[])

Kaynak:
Task.cs
Kaynak:
Task.cs
Kaynak:
Task.cs

Dizideki tüm Task nesneleri tamamlandığında tamamlanacak bir görev oluşturur.

public:
 static System::Threading::Tasks::Task ^ WhenAll(... cli::array <System::Threading::Tasks::Task ^> ^ tasks);
public static System.Threading.Tasks.Task WhenAll (params System.Threading.Tasks.Task[] tasks);
static member WhenAll : System.Threading.Tasks.Task[] -> System.Threading.Tasks.Task
Public Shared Function WhenAll (ParamArray tasks As Task()) As Task

Parametreler

tasks
Task[]

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentNullException

tasks bağımsız değişkeni null.

ArgumentException

tasks dizisi bir null görevi içeriyordu.

Örnekler

Aşağıdaki örnek, dizideki URL'lere ping atan bir görev kümesi oluşturur. Görevler, diziye dönüştürülen ve WhenAll(IEnumerable<Task>) yöntemine geçirilen bir List<Task> koleksiyonunda depolanır. Wait yöntemine yapılan çağrı tüm iş parçacıklarının tamamlanmasını sağladıktan sonra, örnek Task.Status özelliğini inceleyerek herhangi bir görevde hata olup olmadığını belirler.

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

public class Example
{
   public static async Task Main()
   {
      int failed = 0;
      var tasks = new List<Task>();
      String[] urls = { "www.adatum.com", "www.cohovineyard.com",
                        "www.cohowinery.com", "www.northwindtraders.com",
                        "www.contoso.com" };
      
      foreach (var value in urls) {
         var url = value;
         tasks.Add(Task.Run( () => { var png = new Ping();
                                     try {
                                        var reply = png.Send(url);
                                        if (! (reply.Status == IPStatus.Success)) {
                                           Interlocked.Increment(ref failed);
                                           throw new TimeoutException("Unable to reach " + url + ".");
                                        }
                                     }
                                     catch (PingException) {
                                        Interlocked.Increment(ref failed);
                                        throw;
                                     }
                                   }));
      }
      Task t = Task.WhenAll(tasks.ToArray());
      try {
         await t;
      }
      catch {}   

      if (t.Status == TaskStatus.RanToCompletion)
         Console.WriteLine("All ping attempts succeeded.");
      else if (t.Status == TaskStatus.Faulted)
         Console.WriteLine("{0} ping attempts failed", failed);      
   }
}
// The example displays output like the following:
//       5 ping attempts failed

open System
open System.Net.NetworkInformation
open System.Threading
open System.Threading.Tasks

let mutable failed = 0

let urls =
    [| "www.adatum.com"
       "www.cohovineyard.com"
       "www.cohowinery.com"
       "www.northwindtraders.com"
       "www.contoso.com" |]

let tasks =
    urls
    |> Array.map (fun url ->
        Task.Run(fun () ->
            let png = new Ping()

            try
                let reply = png.Send url

                if reply.Status <> IPStatus.Success then
                    Interlocked.Increment &failed |> ignore
                    raise (TimeoutException $"Unable to reach {url}.")
            with :? PingException ->
                Interlocked.Increment &failed |> ignore
                reraise ()))

let main =
    task {
        let t = Task.WhenAll tasks

        try
            do! t
        with _ ->
            ()

        if t.Status = TaskStatus.RanToCompletion then
            printfn "All ping attempts succeeded."
        elif t.Status = TaskStatus.Faulted then
            printfn $"{failed} ping attempts failed"
    }

main.Wait()
// The example displays output like the following:
//       5 ping attempts failed

Imports System.Collections.Generic
Imports System.Net.NetworkInformation
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim failed As Integer = 0
      Dim tasks As New List(Of Task)()
      Dim urls() As String = { "www.adatum.com", "www.cohovineyard.com",
                              "www.cohowinery.com", "www.northwindtraders.com",
                              "www.contoso.com" }
      
      For Each value In urls
         Dim url As String = value
         tasks.Add(Task.Run( Sub()
                                Dim png As New Ping()
                                Try
                                   Dim reply = png.Send(url)
                                   If Not reply.Status = IPStatus.Success Then
                                      Interlocked.Increment(failed)
                                      Throw New TimeoutException("Unable to reach " + url + ".")
                                   End If
                                   Catch e As PingException
                                      Interlocked.Increment(failed)
                                      Throw
                                   End Try
                             End Sub))
      Next
      Dim t As Task = Task.WhenAll(tasks.ToArray())
      Try
         t.Wait()
      Catch
      End Try   

      If t.Status = TaskStatus.RanToCompletion
         Console.WriteLine("All ping attempts succeeded.")
      ElseIf t.Status = TaskStatus.Faulted
         Console.WriteLine("{0} ping attempts failed", failed)      
      End If
   End Sub
End Module
' The example displays output like the following:
'     5 ping attempts failed

Açıklamalar

bir Task nesnesi döndüren WhenAll yönteminin aşırı yüklemeleri genellikle bir görev kümesinin durumuyla veya bir görev kümesi tarafından oluşan özel durumlarla ilgilendiğinizde çağrılır.

Not

WhenAll(Task[]) yöntemi çağrısı, çağıran iş parçacığını engellemez.

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev de Faulted durumunda tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev Canceled durumunda sona erer.

Görevlerin hiçbiri hatalı değilse ve hiçbir görev iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer.

Sağlanan dizi/numaralandırılabilir görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen RanToCompletion durumuna geçer.

Şunlara uygulanır

WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Sağlanan tüm görevler tamamlandığında tamamlanacak bir görev oluşturur.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(ReadOnlySpan<System::Threading::Tasks::Task<TResult> ^> tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (scoped ReadOnlySpan<System.Threading.Tasks.Task<TResult>> tasks);
static member WhenAll : ReadOnlySpan<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (tasks As ReadOnlySpan(Of Task(Of TResult))) As Task(Of TResult())

Tür Parametreleri

TResult

Parametreler

tasks
ReadOnlySpan<Task<TResult>>

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task<TResult[]>

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentException

tasks dizisi bir null görevi içerir.

Açıklamalar

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev hata durumunda da tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev İptal Edildi durumunda sona erer.

Görevlerden hiçbiri hatalı değilse ve görevlerden hiçbiri iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer. Döndürülen görevin Sonucu, sağlanan görevlerin tüm sonuçlarını sağlandığı sırada içeren bir diziye ayarlanır (örneğin, giriş görevleri dizisi t1, t2, t3 içeriyorsa, çıkış görevinin Sonucu bir TResult[] döndürür; burada arr[0] == t1. Sonuç, arr[1] == t2. Sonuç ve arr[2] == t3. Sonuç).

Sağlanan dizi/numaralandırılabilir görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen Bir RanToCompletion durumuna geçer. Döndürülen TResult[] 0 öğeden oluşan bir dizi olacaktır.

Şunlara uygulanır

WhenAll<TResult>(IEnumerable<Task<TResult>>)

Kaynak:
Task.cs
Kaynak:
Task.cs
Kaynak:
Task.cs

Numaralandırılabilir bir koleksiyondaki tüm Task<TResult> nesneleri tamamlandığında tamamlanacak bir görev oluşturur.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(System::Collections::Generic::IEnumerable<System::Threading::Tasks::Task<TResult> ^> ^ tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<TResult>> tasks);
static member WhenAll : seq<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (tasks As IEnumerable(Of Task(Of TResult))) As Task(Of TResult())

Tür Parametreleri

TResult

Tamamlanan görevin türü.

Parametreler

tasks
IEnumerable<Task<TResult>>

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task<TResult[]>

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentNullException

tasks bağımsız değişkeni null.

ArgumentException

tasks koleksiyonu bir null görevi içeriyordu.

Örnekler

Aşağıdaki örnek, her biri 1 ile 1.000 arasında rastgele 1000 sayı oluşturan ve ortalamasını hesaplayan rastgele bir sayı oluşturucu oluşturan on görev oluşturur. Delay(Int32) yöntemi, aynı tohum değerleriyle oluşturulmamaları için rastgele sayı oluşturucuların örneklemesini geciktirmek için kullanılır. daha sonra WhenAll yöntemine yapılan çağrı, her görev tarafından hesaplanan ortalamayı içeren bir Int64 dizisi döndürür. Bunlar daha sonra genel ortalamayı hesaplamak için kullanılır.

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

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<long>>();
      for (int ctr = 1; ctr <= 10; ctr++) {
         int delayInterval = 18 * ctr;
         tasks.Add(Task.Run(async () => { long total = 0;
                                          await Task.Delay(delayInterval);
                                          var rnd = new Random();
                                          // Generate 1,000 random numbers.
                                          for (int n = 1; n <= 1000; n++)
                                             total += rnd.Next(0, 1000);
                                          return total; } ));
      }
      var continuation = Task.WhenAll(tasks);
      try {
         continuation.Wait();
      }
      catch (AggregateException)
      { }
   
      if (continuation.Status == TaskStatus.RanToCompletion) {
         long grandTotal = 0;
         foreach (var result in continuation.Result) {
            grandTotal += result;
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000.0);
         }
   
         Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000);
      }
      // Display information on faulted tasks.
      else {
         foreach (var t in tasks) {
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status);
         }
      }
   }
}
// The example displays output like the following:
//       Mean: 506.34, n = 1,000
//       Mean: 504.69, n = 1,000
//       Mean: 489.32, n = 1,000
//       Mean: 505.96, n = 1,000
//       Mean: 515.31, n = 1,000
//       Mean: 499.94, n = 1,000
//       Mean: 496.92, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 494.88, n = 1,000
//       Mean: 493.53, n = 1,000
//
//       Mean of Means: 501.55, n = 10,000

open System
open System.Threading.Tasks

let tasks =
    [| for i = 1 to 10 do
           let delayInterval = 18 * i

           task {
               let mutable total = 0L
               do! Task.Delay delayInterval
               let rnd = Random()

               for _ = 1 to 1000 do
                   total <- total + (rnd.Next(0, 1000) |> int64)

               return total
           } |]

let continuation = Task.WhenAll tasks

try
    continuation.Wait()

with :? AggregateException ->
    ()

if continuation.Status = TaskStatus.RanToCompletion then
    for result in continuation.Result do
        printfn $"Mean: {float result / 1000.:N2}, n = 1,000"

    let grandTotal = continuation.Result |> Array.sum

    printfn $"\nMean of Means: {float grandTotal / 10000.:N2}, n = 10,000"

// Display information on faulted tasks.
else
    for t in tasks do
        printfn $"Task {t.Id}: {t.Status}"

// The example displays output like the following:
//       Mean: 506.34, n = 1,000
//       Mean: 504.69, n = 1,000
//       Mean: 489.32, n = 1,000
//       Mean: 505.96, n = 1,000
//       Mean: 515.31, n = 1,000
//       Mean: 499.94, n = 1,000
//       Mean: 496.92, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 494.88, n = 1,000
//       Mean: 493.53, n = 1,000
//
//       Mean of Means: 501.55, n = 10,000

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

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Long))()
      For ctr As Integer = 1 To 10
         Dim delayInterval As Integer = 18 * ctr
         tasks.Add(Task.Run(Async Function()
                               Dim total As Long = 0
                               Await Task.Delay(delayInterval)
                               Dim rnd As New Random()
                               ' Generate 1,000 random numbers.
                               For n As Integer = 1 To 1000
                                  total += rnd.Next(0, 1000)
                               Next
                               Return total
                            End Function))
      Next
      Dim continuation = Task.WhenAll(tasks)
      Try
         continuation.Wait()
      Catch ae As AggregateException
      End Try
      
      If continuation.Status = TaskStatus.RanToCompletion Then
         Dim grandTotal As Long = 0
         For Each result in continuation.Result
            grandTotal += result
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000)
         Next
         Console.WriteLine()
         Console.WriteLine("Mean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000)
      ' Display information on faulted tasks.
      Else 
         For Each t In tasks
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status)
         Next
      End If
   End Sub
End Module
' The example displays output like the following:
'       Mean: 506.34, n = 1,000
'       Mean: 504.69, n = 1,000
'       Mean: 489.32, n = 1,000
'       Mean: 505.96, n = 1,000
'       Mean: 515.31, n = 1,000
'       Mean: 499.94, n = 1,000
'       Mean: 496.92, n = 1,000
'       Mean: 508.58, n = 1,000
'       Mean: 494.88, n = 1,000
'       Mean: 493.53, n = 1,000
'
'       Mean of Means: 501.55, n = 10,000

Bu durumda, on ayrı görev bir List<T> nesnesinde depolanır. List<T> IEnumerable<T> arabirimini uygular.

Açıklamalar

WhenAll<TResult>(IEnumerable<Task<TResult>>) yöntemi çağrısı, çağıran iş parçacığını engellemez. Ancak, döndürülen Result özelliğine yapılan bir çağrı, çağıran iş parçacığını engeller.

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev de Faulted durumunda tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev Canceled durumunda sona erer.

Görevlerin hiçbiri hatalı değilse ve hiçbir görev iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer. Döndürülen görevin Task<TResult>.Result özelliği, sağlanan görevlerin tüm sonuçlarını sağlandığı sırada içeren bir diziye ayarlanır (örneğin, giriş görevleri dizisi t1, t2, t3 içeriyorsa, çıkış görevinin Task<TResult>.Result özelliği arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)bir TResult[] döndürür.

tasks bağımsız değişkeni görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen bir RanToCompletion durumuna geçer. Döndürülen TResult[] 0 öğeden oluşan bir dizi olacaktır.

Şunlara uygulanır

WhenAll<TResult>(Task<TResult>[])

Kaynak:
Task.cs
Kaynak:
Task.cs
Kaynak:
Task.cs

Dizideki tüm Task<TResult> nesneleri tamamlandığında tamamlanacak bir görev oluşturur.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(... cli::array <System::Threading::Tasks::Task<TResult> ^> ^ tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (params System.Threading.Tasks.Task<TResult>[] tasks);
static member WhenAll : System.Threading.Tasks.Task<'Result>[] -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (ParamArray tasks As Task(Of TResult)()) As Task(Of TResult())

Tür Parametreleri

TResult

Tamamlanan görevin türü.

Parametreler

tasks
Task<TResult>[]

Tamamlanmasını beklemeniz gereken görevler.

Döndürülenler

Task<TResult[]>

Sağlanan tüm görevlerin tamamlanmasını temsil eden görev.

Özel durumlar

ArgumentNullException

tasks bağımsız değişkeni null.

ArgumentException

tasks dizisi bir null görevi içeriyordu.

Örnekler

Aşağıdaki örnek, her biri 1 ile 1.000 arasında rastgele 1000 sayı oluşturan ve ortalamasını hesaplayan rastgele bir sayı oluşturucu oluşturan on görev oluşturur. Bu durumda, on ayrı görev bir Task<Int64> dizisinde depolanır. Delay(Int32) yöntemi, aynı tohum değerleriyle oluşturulmamaları için rastgele sayı oluşturucuların örneklemesini geciktirmek için kullanılır. daha sonra WhenAll yöntemine yapılan çağrı, her görev tarafından hesaplanan ortalamayı içeren bir Int64 dizisi döndürür. Bunlar daha sonra genel ortalamayı hesaplamak için kullanılır.

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

public class Example
{
   public static void Main()
   {
      var tasks = new Task<long>[10];
      for (int ctr = 1; ctr <= 10; ctr++) {
         int delayInterval = 18 * ctr;
         tasks[ctr - 1] = Task.Run(async () => { long total = 0;
                                                 await Task.Delay(delayInterval);
                                                 var rnd = new Random();
                                                 // Generate 1,000 random numbers.
                                                 for (int n = 1; n <= 1000; n++)
                                                    total += rnd.Next(0, 1000);

                                                 return total; } );
      }
      var continuation = Task.WhenAll(tasks);
      try {
         continuation.Wait();
      }
      catch (AggregateException)
      {}
   
      if (continuation.Status == TaskStatus.RanToCompletion) {
         long grandTotal = 0;
         foreach (var result in continuation.Result) {
            grandTotal += result;
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000.0);
         }
   
         Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000);
      }
      // Display information on faulted tasks.
      else { 
         foreach (var t in tasks)
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status);
      }
   }
}
// The example displays output like the following:
//       Mean: 506.38, n = 1,000
//       Mean: 501.01, n = 1,000
//       Mean: 505.36, n = 1,000
//       Mean: 492.00, n = 1,000
//       Mean: 508.36, n = 1,000
//       Mean: 503.99, n = 1,000
//       Mean: 504.95, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 490.23, n = 1,000
//       Mean: 501.59, n = 1,000
//
//       Mean of Means: 502.00, n = 10,000

open System
open System.Threading.Tasks

let tasks =
    [| for i = 1 to 10 do
           let delayInterval = 18 * i

           task {
               let mutable total = 0L
               do! Task.Delay delayInterval
               let rnd = Random()

               for _ = 1 to 1000 do
                   total <- total + (rnd.Next(0, 1000) |> int64)

               return total
           } |]

let continuation = Task.WhenAll tasks

try
    continuation.Wait()

with :? AggregateException ->
    ()

if continuation.Status = TaskStatus.RanToCompletion then
    for result in continuation.Result do
        printfn $"Mean: {float result / 1000.:N2}, n = 1,000"

    let grandTotal = Array.sum continuation.Result

    printfn $"\nMean of Means: {float grandTotal / 10000.:N2}, n = 10,000"

// Display information on faulted tasks.
else
    for t in tasks do
        printfn $"Task {t.Id}: {t.Status}"

// The example displays output like the following:
//       Mean: 506.38, n = 1,000
//       Mean: 501.01, n = 1,000
//       Mean: 505.36, n = 1,000
//       Mean: 492.00, n = 1,000
//       Mean: 508.36, n = 1,000
//       Mean: 503.99, n = 1,000
//       Mean: 504.95, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 490.23, n = 1,000
//       Mean: 501.59, n = 1,000
//
//       Mean of Means: 502.00, n = 10,000

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

Module Example
   Public Sub Main()
      Dim tasks(9) As Task(Of Long)
      For ctr As Integer = 1 To 10
         Dim delayInterval As Integer = 18 * ctr
         tasks(ctr - 1) =Task.Run(Async Function()
                                     Dim total As Long = 0
                                     Await Task.Delay(delayInterval)
                                     Dim rnd As New Random()
                                     ' Generate 1,000 random numbers.
                                     For n As Integer = 1 To 1000
                                        total += rnd.Next(0, 1000)
                                     Next
                                     Return total
                                  End Function)
      Next
      Dim continuation = Task.WhenAll(tasks)
      Try
         continuation.Wait()
      Catch ae As AggregateException
      End Try
         
      If continuation.Status = TaskStatus.RanToCompletion Then
         Dim grandTotal As Long = 0
         For Each result in continuation.Result
            grandTotal += result
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000)
         Next
         Console.WriteLine()
         Console.WriteLine("Mean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000)
      ' Display information on faulted tasks.
      Else 
         For Each t In tasks
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status)
         Next
      End If
   End Sub
End Module
' The example displays output like the following:
'       Mean: 506.38, n = 1,000
'       Mean: 501.01, n = 1,000
'       Mean: 505.36, n = 1,000
'       Mean: 492.00, n = 1,000
'       Mean: 508.36, n = 1,000
'       Mean: 503.99, n = 1,000
'       Mean: 504.95, n = 1,000
'       Mean: 508.58, n = 1,000
'       Mean: 490.23, n = 1,000
'       Mean: 501.59, n = 1,000
'
'       Mean of Means: 502.00, n = 10,000

Açıklamalar

WhenAll<TResult>(Task<TResult>[]) yöntemi çağrısı, çağıran iş parçacığını engellemez. Ancak, döndürülen Result özelliğine yapılan bir çağrı, çağıran iş parçacığını engeller.

Sağlanan görevlerden herhangi biri hatalı durumda tamamlanırsa, döndürülen görev de Faulted durumunda tamamlanır ve burada özel durumları sağlanan görevlerin her birinden eşlenmemiş özel durumlar kümesinin toplanmasını içerir.

Sağlanan görevlerden hiçbiri hatalı değilse ancak bunlardan en az biri iptal edildiyse, döndürülen görev Canceled durumunda sona erer.

Görevlerin hiçbiri hatalı değilse ve hiçbir görev iptal edilmediyse, sonuçta elde edilen görev RanToCompletion durumunda sona erer. Döndürülen görevin Result, sağlanan görevlerin tüm sonuçlarını sağlandığı sırada içeren bir diziye ayarlanır (örneğin, giriş görevleri dizisi t1, t2, t3 içeriyorsa, çıkış görevinin Resultarr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)bir TResult[] döndürür.

Sağlanan dizi/numaralandırılabilir görev içermiyorsa, döndürülen görev çağırana döndürülmeden önce hemen RanToCompletion durumuna geçer. Döndürülen TResult[] 0 öğeden oluşan bir dizi olacaktır.

Şunlara uygulanır