Task Sınıf
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Zaman uyumsuz bir işlemi temsil eder.
public ref class Task : IAsyncResultpublic ref class Task : IAsyncResult, IDisposablepublic class Task : IAsyncResultpublic class Task : IAsyncResult, IDisposabletype Task = class
interface IAsyncResulttype Task = class
interface IAsyncResult
interface IDisposablePublic Class Task
Implements IAsyncResultPublic Class Task
Implements IAsyncResult, IDisposable- Devralma
-
Task
- Türetilmiş
- Uygulamalar
Açıklamalar
sınıfı, Task bir değer döndürmeyen ve genellikle zaman uyumsuz olarak yürütülen tek bir işlemi temsil eder. Task nesneler, görev tabanlı zaman uyumsuz desenin merkezi bileşenlerinden biridir. Bir Task nesne tarafından gerçekleştirilen çalışma genellikle ana uygulama iş parçacığında zaman uyumlu olarak değil, bir iş parçacığı havuzunda zaman uyumsuz olarak yürütülür. Bir görevin durumunu belirlemek için Status özelliğinin yanı sıra, IsCanceled, IsCompleted ve IsFaulted özelliklerini de kullanabilirsiniz. En yaygın olarak, görevin gerçekleştireceğiniz çalışmayı belirtmek için bir lambda ifadesi kullanılır.
Değer döndüren işlemler için sınıfını Task<TResult> kullanırsınız.
Görev örneği oluşturma
Aşağıdaki örnek dört görev oluşturur ve yürütür. Üç görev, Action<T> türünde bir bağımsız değişken kabul eden, action adlı bir Object temsilciyi yürütür. Dördüncü görev, görev oluşturma yöntemine yapılan çağrıda satır içi olarak tanımlanan bir lambda ifadesini (Action temsilci) yürütür. Her görevin örneği oluşturulur ve farklı bir şekilde çalıştırılır:
Görev
t1, Task sınıfı oluşturucusu çağrılarak örneklenir, ancak yalnızca görev Start() başlatıldıktan sonrat2yöntemini çağırarak başlatılır.Task
t2örneklendirilir ve TaskFactory.StartNew(Action<Object>, Object) yöntemi çağrılarak tek bir çağrıda başlatılır.Task
t3örneklendirilir ve Run(Action) yöntemi çağrılarak tek bir çağrıda başlatılır.Görev
t4, RunSynchronously() metodu çağrılarak ana iş parçacığında senkron olarak yürütülür.
Görev t4 zaman uyumlu olarak yürütüldüğü için ana uygulama iş parçacığında çalışır. Kalan görevler genellikle bir veya daha fazla iş parçacığı havuzunda eşzamansız olarak yürütülür.
using System;
using System.Threading;
using System.Threading.Tasks;
class Example
{
static void Main()
{
Action<object> action = (object obj) =>
{
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId);
};
// Create a task but do not start it.
Task t1 = new Task(action, "alpha");
// Construct a started task
Task t2 = Task.Factory.StartNew(action, "beta");
// Block the main thread to demonstrate that t2 is executing
t2.Wait();
// Launch t1
t1.Start();
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId);
// Wait for the task to finish.
t1.Wait();
// Construct a started task using Task.Run.
String taskData = "delta";
Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId);
});
// Wait for the task to finish.
t3.Wait();
// Construct an unstarted task
Task t4 = new Task(action, "gamma");
// Run it synchronously
t4.RunSynchronously();
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait();
}
}
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
open System.Threading
open System.Threading.Tasks
let action =
fun (obj: obj) -> printfn $"Task={Task.CurrentId}, obj={obj}, Thread={Thread.CurrentThread.ManagedThreadId}"
// Create a task but do not start it.
let t1 = new Task(action, "alpha")
// Construct a started task
let t2 = Task.Factory.StartNew(action, "beta")
// Block the main thread to demonstrate that t2 is executing
t2.Wait()
// Launch t1
t1.Start()
printfn $"t1 has been launched. (Main Thread={Thread.CurrentThread.ManagedThreadId})"
// Wait for the task to finish.
t1.Wait()
// Construct a started task using Task.Run.
let taskData = "delta"
let t3 =
Task.Run(fun () -> printfn $"Task={Task.CurrentId}, obj={taskData}, Thread={Thread.CurrentThread.ManagedThreadId}")
// Wait for the task to finish.
t3.Wait()
// Construct an unstarted task
let t4 = new Task(action, "gamma")
// Run it synchronously
t4.RunSynchronously()
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait()
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks
Module Example2
Public Sub Main()
Dim action As Action(Of Object) =
Sub(obj As Object)
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId)
End Sub
' Construct an unstarted task
Dim t1 As New Task(action, "alpha")
' Construct a started task
Dim t2 As Task = Task.Factory.StartNew(action, "beta")
' Block the main thread to demonstrate that t2 is executing
t2.Wait()
' Launch t1
t1.Start()
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId)
' Wait for the task to finish.
t1.Wait()
' Construct a started task using Task.Run.
Dim taskData As String = "delta"
Dim t3 As Task = Task.Run(Sub()
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId)
End Sub)
' Wait for the task to finish.
t3.Wait()
' Construct an unstarted task
Dim t4 As New Task(action, "gamma")
' Run it synchronously
t4.RunSynchronously()
' Although the task was run synchronously, it is a good practice
' to wait for it in the event exceptions were thrown by the task.
t4.Wait()
End Sub
End Module
' The example displays output like the following:
' Task=1, obj=beta, Thread=3
' t1 has been launched. (Main Thread=1)
' Task=2, obj=alpha, Thread=3
' Task=3, obj=delta, Thread=3
' Task=4, obj=gamma, Thread=1
Görev oluşturma ve yürütme
Task örneklerini çeşitli yollarla oluşturabilirsiniz. En yaygın yaklaşım statik Run yöntemi çağırmaktır. yöntemi, Run varsayılan değerleri kullanarak ve ek parametreler gerektirmeden bir görevi başlatmak için basit bir yol sağlar. Aşağıdaki örnek, döngü oluşturan ve döngü yinelemelerinin sayısını görüntüleyen bir görev başlatmak için yöntemini kullanır Run(Action) :
using System;
using System.Threading.Tasks;
public class Example
{
public static async Task Main()
{
await Task.Run( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let main =
task {
do!
Task.Run(fun () ->
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
}
main.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example1
Public Sub Main()
Dim t As Task = Task.Run(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Alternatif statik TaskFactory.StartNew yöntemidir. Task.Factory özelliği bir TaskFactory nesnesi döndürür. yönteminin TaskFactory.StartNew aşırı yüklemeleri, görev oluşturma seçeneklerine ve bir görev zamanlayıcıya geçireceğiniz parametreleri belirtmenize olanak sağlar. Aşağıdaki örnek, bir görevi başlatmak için yöntemini kullanır TaskFactory.StartNew . İşlevsel olarak önceki örnekteki kodla eşdeğerdir.
using System;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
Task t = Task.Factory.StartNew( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
t.Wait();
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let t =
Task.Factory.StartNew(fun () ->
// Just loop.
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
t.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example3
Public Sub Main()
Dim t As Task = Task.Factory.StartNew(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Daha eksiksiz örnekler için bkz. Görev Tabanlı Zaman Uyumsuz Programlama.
Ayrı görev oluşturma ve yürütme
Task sınıfı, görevi başlatan ancak yürütme için zamanlamayan oluşturucular da sağlar. Performans nedenleriyle, Task.Run veya TaskFactory.StartNew yöntemi hesaplama görevlerini oluşturmak ve zamanlamak için tercih edilen mekanizmadır, ancak oluşturma ve zamanlamanın ayrılması gereken senaryolar için oluşturucuları kullanabilir ve ardından daha sonra görevi yürütme için zamanlamak üzere yöntemini çağırabilirsiniz Task.Start .
Görevin tamamlanmasını bekleme
Görevler genellikle bir iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak çalıştığından, görevi oluşturan ve başlatan iş parçacığı, görev örneği oluşturulur oluşturulmaz yürütmeye devam eder. Bazı durumlarda, çağıran iş parçacığı ana uygulama iş parçacığı olduğunda, görev yürütülmeye başlamadan önce uygulama sonlandırılabilir. Uygulamanızın mantığı gereği, diğer durumlarda, çağırıcı iş parçacığının yalnızca bir veya daha fazla görev tamamlandığında yürütmeye devam etmesi gerekebilir. Bir veya daha fazla görevin tamamlanmasını beklemek için bir Wait yöntemi çağırarak çağıran iş parçacığının ve başlattığı eşzamansız görevlerin yürütülmesini eşitleyebilirsiniz.
Tek bir görevin tamamlanmasını beklemek için yöntemini çağırabilirsiniz Task.Wait . Wait yöntemine yapılan çağrı, tek sınıf örneği yürütmeyi tamamlayana kadar çağıran iş parçacığını engeller.
Aşağıdaki örnek, bir görev tamamlanana kadar koşulsuz olarak beklemek için parametresiz Wait() yöntemini çağırır. Görev, iki saniye boyunca uyku durumuna geçmesi için Thread.Sleep yöntemini çağırarak çalışmayı simüle eder.
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static Random rand = new Random();
static void Main()
{
// Wait on a single task with no timeout specified.
Task taskA = Task.Run( () => Thread.Sleep(2000));
Console.WriteLine("taskA Status: {0}", taskA.Status);
try {
taskA.Wait();
Console.WriteLine("taskA Status: {0}", taskA.Status);
}
catch (AggregateException) {
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
let rand = Random()
// Wait on a single task with no timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
printfn $"taskA Status: {taskA.Status}"
try
taskA.Wait()
printfn $"taskA Status: {taskA.Status}"
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example4
Public Sub Main()
' Wait on a single task with no timeout specified.
Dim taskA = Task.Run(Sub() Thread.Sleep(2000))
Console.WriteLine("taskA Status: {0}", taskA.Status)
Try
taskA.Wait()
Console.WriteLine("taskA Status: {0}", taskA.Status)
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays output like the following:
' taskA Status: WaitingToRun
' taskA Status: RanToCompletion
Ayrıca, bir görevin tamamlanmasını koşullu olarak bekleyebilirsiniz. Wait(Int32) ve Wait(TimeSpan) yöntemleri, görev bitene veya zaman aşımı aralığı geçene kadar (hangisi önce gelirse) çağıran iş parçacığını engeller. Aşağıdaki örnek iki saniye boyunca uyuyan ancak bir saniyelik bir zaman aşımı değeri tanımlayan bir görevi başlattığından, zaman aşımı süresi dolana kadar ve görev yürütme tamamlanmadan önce çağrılan iş parçacığı engeller.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Wait on a single task with a timeout specified.
Task taskA = Task.Run( () => Thread.Sleep(2000));
try {
taskA.Wait(1000); // Wait for 1 second.
bool completed = taskA.IsCompleted;
Console.WriteLine("Task A completed: {0}, Status: {1}",
completed, taskA.Status);
if (!completed)
Console.WriteLine("Timed out before task A completed.");
}
catch (AggregateException) {
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
open System
open System.Threading
open System.Threading.Tasks
// Wait on a single task with a timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
try
taskA.Wait 1000 |> ignore // Wait for 1 second.
let completed = taskA.IsCompleted
printfn $"Task A completed: {completed}, Status: {taskA.Status}"
if not completed then
printfn "Timed out before task A completed."
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks
Module Example5
Public Sub Main()
' Wait on a single task with a timeout specified.
Dim taskA As Task = Task.Run(Sub() Thread.Sleep(2000))
Try
taskA.Wait(1000) ' Wait for 1 second.
Dim completed As Boolean = taskA.IsCompleted
Console.WriteLine("Task.Completed: {0}, Status: {1}",
completed, taskA.Status)
If Not completed Then
Console.WriteLine("Timed out before task A completed.")
End If
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays the following output:
' Task A completed: False, Status: Running
' Timed out before task A completed.
Wait(CancellationToken) ve Wait(Int32, CancellationToken) yöntemlerini çağırarak bir iptal belirteci de sağlayabilirsiniz. Belirtecin IsCancellationRequested özelliği true veya true yöntemi yürütülürken Wait olursa, yöntem bir OperationCanceledException fırlatır.
Bazı durumlarda, bir dizi yürütme görevinin ilkinin tamamlanmasını beklemek isteyebilirsiniz, ancak hangi görev olduğu önemli değildir. Bu amaçla, Task.WaitAny yönteminin aşırı yüklemelerinden birini çağırabilirsiniz. Aşağıdaki örnek, her biri rastgele bir sayı oluşturucu tarafından belirlenen bir aralık için uyku moduna geçen üç görev oluşturur. yöntemi, WaitAny(Task[]) ilk görevin tamamlanmasını bekler. Örnek daha sonra üç görevin durumu hakkında bilgi görüntüler.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
var tasks = new Task[3];
var rnd = new Random();
for (int ctr = 0; ctr <= 2; ctr++)
tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));
try {
int index = Task.WaitAny(tasks);
Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
Console.WriteLine("Status of all tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
catch (AggregateException) {
Console.WriteLine("An exception occurred.");
}
}
}
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
open System
open System.Threading
open System.Threading.Tasks
let rnd = new Random()
let tasks =
[| for _ = 0 to 2 do
Task.Run(fun () -> rnd.Next(500, 3000) |> Thread.Sleep) |]
try
let index = Task.WaitAny tasks
printfn $"Task #{tasks[index].Id} completed first.\n"
printfn "Status of all tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
with :? AggregateException ->
printfn "An exception occurred."
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks
Module Example8
Public Sub Main()
Dim tasks(2) As Task
Dim rnd As New Random()
For ctr As Integer = 0 To 2
tasks(ctr) = Task.Run(Sub() Thread.Sleep(rnd.Next(500, 3000)))
Next
Try
Dim index As Integer = Task.WaitAny(tasks)
Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
Console.WriteLine()
Console.WriteLine("Status of all tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
Catch e As AggregateException
Console.WriteLine("An exception occurred.")
End Try
End Sub
End Module
' The example displays output like the following:
' Task #1 completed first.
'
' Status of all tasks:
' Task #3: Running
' Task #1: RanToCompletion
' Task #4: Running
Ayrıca WaitAll yöntemini kullanarak bir dizi görevin tamamlanmasını da bekleyebilirsiniz. Aşağıdaki örnekte on görev oluşturulur, on görev de tamamlanmasını bekler ve ardından durumlarını görüntüler.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Wait for all tasks to complete.
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => Thread.Sleep(2000));
}
try {
Task.WaitAll(tasks);
}
catch (AggregateException ae) {
Console.WriteLine("One or more exceptions occurred: ");
foreach (var ex in ae.Flatten().InnerExceptions)
Console.WriteLine(" {0}", ex.Message);
}
Console.WriteLine("Status of completed tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
}
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
// Wait for all tasks to complete.
let tasks =
[| for _ = 0 to 9 do
Task.Run(fun () -> Thread.Sleep 2000) |]
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred: "
for ex in ae.Flatten().InnerExceptions do
printfn $" {ex.Message}"
printfn "Status of completed tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example6
Public Sub Main()
' Wait for all tasks to complete.
Dim tasks(9) As Task
For i As Integer = 0 To 9
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
Next
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred: ")
For Each ex In ae.Flatten().InnerExceptions
Console.WriteLine(" {0}", ex.Message)
Next
End Try
Console.WriteLine("Status of completed tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
End Sub
End Module
' The example displays the following output:
' Status of completed tasks:
' Task #2: RanToCompletion
' Task #1: RanToCompletion
' Task #3: RanToCompletion
' Task #4: RanToCompletion
' Task #6: RanToCompletion
' Task #5: RanToCompletion
' Task #7: RanToCompletion
' Task #8: RanToCompletion
' Task #9: RanToCompletion
' Task #10: RanToCompletion
Bir veya daha fazla görevi tamamlamayı beklediğinizde, çalışan görevlerde oluşan özel durumlar, yöntemi çağıran iş parçacığına aşağıdaki örnekte gösterildiği gibi iletilir. 12 görev başlatır. Bu görevlerin üçü normal olarak tamamlanıp üçü özel durum oluşturur. Kalan altı görevden üçü başlamadan önce iptal edilir ve üçü yürütülürken iptal edilir. Özel durumlar WaitAll yöntem çağrısında atılır ve bir try/catch bloğu tarafından işlenir.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Create a cancellation token and cancel it.
var source1 = new CancellationTokenSource();
var token1 = source1.Token;
source1.Cancel();
// Create a cancellation token for later cancellation.
var source2 = new CancellationTokenSource();
var token2 = source2.Token;
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
Task[] tasks = new Task[12];
for (int i = 0; i < 12; i++)
{
switch (i % 4)
{
// Task should run to completion.
case 0:
tasks[i] = Task.Run(() => Thread.Sleep(2000));
break;
// Task should be set to canceled state.
case 1:
tasks[i] = Task.Run( () => Thread.Sleep(2000),
token1);
break;
case 2:
// Task should throw an exception.
tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
break;
case 3:
// Task should examine cancellation token.
tasks[i] = Task.Run( () => { Thread.Sleep(2000);
if (token2.IsCancellationRequested)
token2.ThrowIfCancellationRequested();
Thread.Sleep(500); }, token2);
break;
}
}
Thread.Sleep(250);
source2.Cancel();
try {
Task.WaitAll(tasks);
}
catch (AggregateException ae) {
Console.WriteLine("One or more exceptions occurred:");
foreach (var ex in ae.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message);
}
Console.WriteLine("\nStatus of tasks:");
foreach (var t in tasks) {
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
if (t.Exception != null) {
foreach (var ex in t.Exception.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message);
}
}
}
}
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
open System
open System.Threading
open System.Threading.Tasks
// Create a cancellation token and cancel it.
let source1 = new CancellationTokenSource()
let token1 = source1.Token
source1.Cancel()
// Create a cancellation token for later cancellation.
let source2 = new CancellationTokenSource()
let token2 = source2.Token
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
let tasks =
[| for i in 0..11 do
match i % 4 with
// Task should run to completion.
| 0 -> Task.Run(fun () -> Thread.Sleep 2000)
// Task should be set to canceled state.
| 1 -> Task.Run(fun () -> Thread.Sleep 2000, token1)
// Task should throw an exception.
| 2 -> Task.Run(fun () -> NotSupportedException())
// Task should examine cancellation token.
| _ ->
Task.Run(fun () ->
Thread.Sleep 2000
if token2.IsCancellationRequested then
token2.ThrowIfCancellationRequested()
Thread.Sleep 500, token2) |]
Thread.Sleep 250
source2.Cancel()
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred:"
for ex in ae.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
printfn "\nStatus of tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
if isNull t.Exception |> not then
for ex in t.Exception.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks
Module Example7
Public Sub Main()
' Create a cancellation token and cancel it.
Dim source1 As New CancellationTokenSource()
Dim token1 As CancellationToken = source1.Token
source1.Cancel()
' Create a cancellation token for later cancellation.
Dim source2 As New CancellationTokenSource()
Dim token2 As CancellationToken = source2.Token
' Create a series of tasks that will complete, be cancelled,
' timeout, or throw an exception.
Dim tasks(11) As Task
For i As Integer = 0 To 11
Select Case i Mod 4
' Task should run to completion.
Case 0
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
' Task should be set to canceled state.
Case 1
tasks(i) = Task.Run(Sub() Thread.Sleep(2000), token1)
Case 2
' Task should throw an exception.
tasks(i) = Task.Run(Sub()
Throw New NotSupportedException()
End Sub)
Case 3
' Task should examine cancellation token.
tasks(i) = Task.Run(Sub()
Thread.Sleep(2000)
If token2.IsCancellationRequested Then
token2.ThrowIfCancellationRequested()
End If
Thread.Sleep(500)
End Sub, token2)
End Select
Next
Thread.Sleep(250)
source2.Cancel()
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred:")
For Each ex In ae.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message)
Next
End Try
Console.WriteLine()
Console.WriteLine("Status of tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
If t.Exception IsNot Nothing Then
For Each ex In t.Exception.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message)
Next
End If
Next
End Sub
End Module
' The example displays output like the following:
' One or more exceptions occurred:
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
'
' Status of tasks:
' Task #13: RanToCompletion
' Task #1: Canceled
' Task #3: Faulted
' NotSupportedException: Specified method is not supported.
' Task #8: Canceled
' Task #14: RanToCompletion
' Task #4: Canceled
' Task #6: Faulted
' NotSupportedException: Specified method is not supported.
' Task #7: Canceled
' Task #15: RanToCompletion
' Task #9: Canceled
' Task #11: Faulted
' NotSupportedException: Specified method is not supported.
' Task #12: Canceled
Görev tabanlı zaman uyumsuz işlemlerde özel durum işleme hakkında daha fazla bilgi için bkz. Özel Durum İşleme.
Görevler ve kültür
.NET Framework 4.6'yı hedefleyen masaüstü uygulamalarından başlayarak, bir görevi oluşturan ve çağıran iş parçacığının kültürü iş parçacığı bağlamının bir parçası haline gelir. Yani, görevin yürütüldiği iş parçacığının geçerli kültüründen bağımsız olarak, görevin geçerli kültürü çağıran iş parçacığının kültürüdür. .NET Framework 4.6'dan önceki .NET Framework sürümlerini hedefleyen uygulamalar için görevin kültürü, görevin yürütüldiği iş parçacığının kültürüdür. Daha fazla bilgi için konunun "Kültür ve görev tabanlı zaman uyumsuz işlemler" bölümüne CultureInfo bakın.
Note
Mağaza uygulamaları, varsayılan kültürü ayarlarken ve almada Windows Çalışma Zamanı'nı izler.
Hata ayıklayıcısı geliştiricileri için
Özel hata ayıklayıcıları uygulayan geliştiriciler için görevin birkaç iç ve özel üyesi yararlı olabilir (bunlar yayından sürüme değişebilir). Alan m_taskId özelliği için Id yedekleme deposu görevi görür, ancak bu alana doğrudan bir hata ayıklayıcıdan erişmek, özelliğin getter yöntemi aracılığıyla aynı değere erişmekten daha verimli olabilir ( s_taskIdCounter sayaç, bir görevin sonraki kullanılabilir kimliğini almak için kullanılır). Benzer şekilde, m_stateFlags alanı görevin geçerli yaşam döngüsü aşaması hakkındaki bilgileri depolar ve bu bilgilere özelliği üzerinden Status de erişilebilir. alanı m_action , görevin temsilcisine bir başvuru depolar ve m_stateObject alan, geliştirici tarafından göreve geçirilen zaman uyumsuz durumu depolar. Son olarak, yığın çerçevelerini ayrıştıran hata ayıklayıcılar için InternalWait yöntemi, bir görevin bekleme işlemine girmekte olduğunu gösteren olası bir işaretleyici işlevi görür.
Oluşturucular
| Name | Description |
|---|---|
| Task(Action, CancellationToken, TaskCreationOptions) |
Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır. |
| Task(Action, CancellationToken) |
Belirtilen eylem ve Taskile yeni CancellationToken bir başlatır. |
| Task(Action, TaskCreationOptions) |
Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır. |
| Task(Action) |
Belirtilen eylemle yeni Task bir başlatır. |
| Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) |
Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır. |
| Task(Action<Object>, Object, CancellationToken) |
Belirtilen eylem, durum ve Taskile yeni CancellationToken bir başlatır. |
| Task(Action<Object>, Object, TaskCreationOptions) |
Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır. |
| Task(Action<Object>, Object) |
Belirtilen eylem ve durumla yeni Task bir başlatır. |
Özellikler
| Name | Description |
|---|---|
| AsyncState |
oluşturulurken Task sağlanan durum nesnesini veya hiçbiri sağlanmadıysa null değerini alır. |
| CompletedTask |
Başarıyla tamamlanmış bir görevi alır. |
| CreationOptions |
Bu görevi oluşturmak için kullanılan değerini TaskCreationOptions alır. |
| CurrentId |
Şu anda yürütülmekte Taskolan öğesinin kimliğini döndürür. |
| Exception |
'nin AggregateException erken sona ermesini sağlayan öğesini Task alır.
Task başarıyla tamamlandıysa veya henüz herhangi bir özel durum oluşturmazsa, bu döndürür |
| Factory |
Ve örnekleri oluşturmak ve yapılandırmak için fabrika yöntemlerine TaskTask<TResult> erişim sağlar. |
| Id |
Bu Task örnek için bir kimlik alır. |
| IsCanceled |
Bu Task örneğin iptal edildiği için yürütmeyi tamamlayıp tamamlamadığını alır. |
| IsCompleted |
Görevin tamamlanıp tamamlanmadığını gösteren bir değer alır. |
| IsCompletedSuccessfully |
Görevin tamamlanmak üzere çalıştırılıp çalıştırılmadığını alır. |
| IsFaulted |
İşlenmeyen Task bir özel durum nedeniyle tamamlanıp tamamlanmadığını alır. |
| Status |
Bu görevin değerini TaskStatus alır. |
Yöntemler
| Name | Description |
|---|---|
| ConfigureAwait(Boolean) |
Bunu Taskbeklemek için kullanılan bir awaiter yapılandırılır. |
| ConfigureAwait(ConfigureAwaitOptions) |
Bunu Taskbeklemek için kullanılan bir awaiter yapılandırılır. |
| ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Çağıran tarafından sağlanan durum bilgilerini ve iptal belirtecini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen koşullar kümesine göre yürütülür ve belirtilen zamanlayıcıyı kullanır. |
| ContinueWith(Action<Task,Object>, Object, CancellationToken) |
Çağıran tarafından sağlanan durum bilgilerini ve iptal belirtecini alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) |
Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur. Devam, belirtilen koşullar kümesine göre yürütülür. |
| ContinueWith(Action<Task,Object>, Object, TaskScheduler) |
Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır. |
| ContinueWith(Action<Task,Object>, Object) |
Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur. |
| ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hedef görev belirtilen TaskContinuationOptionsdeğerine göre rekabet ettiğinde yürütülen bir devamlılık oluşturur. Devamlılık bir iptal belirteci alır ve belirtilen zamanlayıcıyı kullanır. |
| ContinueWith(Action<Task>, CancellationToken) |
İptal belirteci alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| ContinueWith(Action<Task>, TaskContinuationOptions) |
Hedef görev belirtilen TaskContinuationOptionsdeğerine göre tamamlandığında yürütülen bir devamlılık oluşturur. |
| ContinueWith(Action<Task>, TaskScheduler) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır. |
| ContinueWith(Action<Task>) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hedef Task tamamlandığında ve bir değer döndürdüğünde belirtilen görev devamlılığı seçeneklerine göre yürütülen bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini ve bir iptal belirtecini alır ve belirtilen zamanlayıcıyı kullanır. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık, arayan tarafından sağlanan durum bilgilerini ve bir iptal belirtecini alır. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) |
Hedef Task tamamlandığında belirtilen görev devamlılığı seçeneklerine göre yürütülen bir devamlılık oluşturur. Devamlılık, arayan tarafından sağlanan durum bilgilerini alır. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. Devamlılık, çağıran tarafından sağlanan durum bilgilerini alır ve belirtilen zamanlayıcıyı kullanır. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object) |
Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında ve bir değer döndürdüğünde zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Belirtilen devamlılık seçeneklerine göre yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devama bir iptal belirteci geçirilir ve belirtilen bir zamanlayıcı kullanılır. |
| ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık bir iptal belirteci alır. |
| ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) |
Belirtilen devamlılık seçeneklerine göre yürütülen ve bir değer döndüren bir devamlılık oluşturur. |
| ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. Devamlılık, belirtilen bir zamanlayıcıyı kullanır. |
| ContinueWith<TResult>(Func<Task,TResult>) |
Hedef Task<TResult> tamamlandığında zaman uyumsuz olarak yürütülen ve bir değer döndüren bir devamlılık oluşturur. |
| Delay(Int32, CancellationToken) |
Belirtilen sayıda milisaniyeden sonra tamamlanan iptal edilebilir bir görev oluşturur. |
| Delay(Int32) |
Belirtilen sayıda milisaniyeden sonra tamamlanan bir görev oluşturur. |
| Delay(TimeSpan, CancellationToken) |
Belirtilen zaman aralığından sonra tamamlanan iptal edilebilir bir görev oluşturur. |
| Delay(TimeSpan, TimeProvider, CancellationToken) |
Belirtilen zaman aralığından sonra tamamlanan iptal edilebilir bir görev oluşturur. |
| Delay(TimeSpan, TimeProvider) |
Belirtilen zaman aralığından sonra tamamlanan bir görev oluşturur. |
| Delay(TimeSpan) |
Belirtilen zaman aralığından sonra tamamlanan bir görev oluşturur. |
| Dispose() |
Sınıfın geçerli örneği Task tarafından kullanılan tüm kaynakları serbest bırakır. |
| Dispose(Boolean) |
Tasktüm yönetilmeyen kaynaklarını serbest bırakarak öğesini atılır. |
| Equals(Object) |
Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object) |
| FromCanceled(CancellationToken) |
Belirtilen iptal Task belirteciyle iptal nedeniyle tamamlanan bir oluşturur. |
| FromCanceled<TResult>(CancellationToken) |
Belirtilen iptal Task<TResult> belirteciyle iptal nedeniyle tamamlanan bir oluşturur. |
| FromException(Exception) |
Task Belirtilen özel durumla tamamlanmış bir oluşturur. |
| FromException<TResult>(Exception) |
Task<TResult> Belirtilen özel durumla tamamlanmış bir oluşturur. |
| FromResult<TResult>(TResult) |
Belirtilen sonuçla başarıyla tamamlanan bir Task<TResult> oluşturur. |
| GetAwaiter() |
Bunu Taskbeklemek için kullanılan bir awaiter alır. |
| GetHashCode() |
Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object) |
| GetType() |
Geçerli örneğin Type alır. (Devralındığı yer: Object) |
| MemberwiseClone() |
Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object) |
| Run(Action, CancellationToken) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task nesne döndürür. İptal belirteci, henüz başlatılmamışsa çalışmanın iptal edilmesini sağlar. |
| Run(Action) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task nesne döndürür. |
| Run(Func<Task>, CancellationToken) |
Belirtilen çalışmayı iş parçacığı havuzunda çalıştırılacak şekilde kuyruğa alır ve tarafından |
| Run(Func<Task>) |
Belirtilen çalışmayı iş parçacığı havuzunda çalıştırılacak şekilde kuyruğa alır ve tarafından |
| Run<TResult>(Func<Task<TResult>>, CancellationToken) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından |
| Run<TResult>(Func<Task<TResult>>) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından |
| Run<TResult>(Func<TResult>, CancellationToken) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir |
| Run<TResult>(Func<TResult>) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve bu çalışmayı temsil eden bir Task<TResult> nesne döndürür. İptal belirteci, henüz başlatılmamışsa çalışmanın iptal edilmesini sağlar. |
| RunSynchronously() |
Task geçerli TaskSchedulerüzerinde zaman uyumlu olarak çalıştırır. |
| RunSynchronously(TaskScheduler) |
Task Sağlanan üzerinde TaskScheduler zaman uyumlu olarak çalıştırır. |
| Start() |
Taskgeçerli TaskScheduleröğesine yürütülmek üzere zamanlayarak öğesini başlatır. |
| Start(TaskScheduler) |
Taskbelirtilen TaskScheduleröğesine yürütülmek üzere zamanlayarak öğesini başlatır. |
| ToString() |
Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object) |
| Wait() |
yürütmenin Task tamamlanmasını bekler. |
| Wait(CancellationToken) |
yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce iptal belirteci iptal edilirse bekleme sonlandırılır. |
| Wait(Int32, CancellationToken) |
yürütmenin Task tamamlanmasını bekler. Görev tamamlanmadan önce bir zaman aşımı aralığı geçtiğinde veya iptal belirteci iptal edilirse bekleme sonlandırılır. |
| Wait(Int32) |
belirtilen sayıda milisaniye içinde yürütmenin Task tamamlanmasını bekler. |
| Wait(TimeSpan, CancellationToken) |
yürütmenin Task tamamlanmasını bekler. |
| Wait(TimeSpan) |
Yürütmenin Task belirtilen zaman aralığı içinde tamamlanmasını bekler. |
| WaitAll(IEnumerable<Task>, CancellationToken) |
Bekleme iptal edilmediği sürece sağlanan Task tüm nesnelerin yürütülmesini bekler. |
| WaitAll(ReadOnlySpan<Task>) |
Sağlanan Task tüm nesnelerin yürütülmesini bekler. |
| WaitAll(Task[], CancellationToken) |
Bekleme iptal edilmediği sürece sağlanan Task tüm nesnelerin yürütülmesini bekler. |
| WaitAll(Task[], Int32, CancellationToken) |
Belirtilen sayıda milisaniye içinde veya bekleme iptal edilene kadar sağlanan Task tüm nesnelerin yürütülmesini bekler. |
| WaitAll(Task[], Int32) |
Sağlanan Task tüm nesnelerin belirtilen sayıda milisaniye içinde yürütülmesini bekler. |
| WaitAll(Task[], TimeSpan) |
Sağlanan tüm iptal edilebilir Task nesnelerin belirli bir zaman aralığı içinde yürütülmesini bekler. |
| WaitAll(Task[]) |
Sağlanan Task tüm nesnelerin yürütülmesini bekler. |
| WaitAny(Task[], CancellationToken) |
Bekleme iptal edilmediği sürece sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler. |
| WaitAny(Task[], Int32, CancellationToken) |
Belirtilen sayıda milisaniye içinde veya iptal belirteci iptal edilene kadar sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler. |
| WaitAny(Task[], Int32) |
Sağlanan Task nesnelerden herhangi birinin belirtilen sayıda milisaniye içinde yürütülmesini bekler. |
| WaitAny(Task[], TimeSpan) |
Belirtilen zaman aralığı içinde sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler. |
| WaitAny(Task[]) |
Sağlanan Task nesnelerden herhangi birinin yürütülmesini bekler. |
| WaitAsync(CancellationToken) |
Bu Task işlem tamamlandığında veya belirtilen Task iptal istendiğinde tamamlanacak bir CancellationToken alır. |
| WaitAsync(TimeSpan, CancellationToken) |
Bu Task tamamlandığında, belirtilen zaman aşımı sona erdiğinde veya belirtilen Task iptal istendiğinde tamamlanacak bir CancellationToken alır. |
| WaitAsync(TimeSpan, TimeProvider, CancellationToken) |
Bu Task tamamlandığında, belirtilen zaman aşımı sona erdiğinde veya belirtilen Task iptal istendiğinde tamamlanacak bir CancellationToken alır. |
| WaitAsync(TimeSpan, TimeProvider) |
Bu Task işlem tamamlandığında veya belirtilen zaman aşımı sona erdiğinde tamamlanacak bir Task alır. |
| WaitAsync(TimeSpan) |
Bu Task işlem tamamlandığında veya belirtilen zaman aşımı sona erdiğinde tamamlanacak bir Task alır. |
| WhenAll(IEnumerable<Task>) |
Numaralandırılabilir bir koleksiyondaki Task tüm nesneler 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[]) |
Bir dizideki Task tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAll<TResult>(IEnumerable<Task<TResult>>) |
Numaralandırılabilir bir koleksiyondaki Task<TResult> tüm nesneler 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>(Task<TResult>[]) |
Bir dizideki Task<TResult> tüm nesneler tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny(IEnumerable<Task>) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny(ReadOnlySpan<Task>) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny(Task, Task) |
Sağlanan görevlerden biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny(Task[]) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny<TResult>(IEnumerable<Task<TResult>>) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny<TResult>(ReadOnlySpan<Task<TResult>>) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny<TResult>(Task<TResult>, Task<TResult>) |
Sağlanan görevlerden biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenAny<TResult>(Task<TResult>[]) |
Sağlanan görevlerden herhangi biri tamamlandığında tamamlanacak bir görev oluşturur. |
| WhenEach(IEnumerable<Task>) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| WhenEach(ReadOnlySpan<Task>) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| WhenEach(Task[]) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| WhenEach<TResult>(IEnumerable<Task<TResult>>) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| WhenEach<TResult>(ReadOnlySpan<Task<TResult>>) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| WhenEach<TResult>(Task<TResult>[]) |
Bu görevler tamamlandıktan sonra sağlanan görevleri verecek bir IAsyncEnumerable<T> oluşturur. |
| Yield() |
Beklendiğinde zaman uyumsuz olarak geçerli bağlama geri döndüren beklenebilir bir görev oluşturur. |
Belirtik Arabirim Kullanımları
| Name | Description |
|---|---|
| IAsyncResult.AsyncWaitHandle |
Görevin tamamlanmasını beklemek için kullanılabilecek bir WaitHandle alır. |
| IAsyncResult.CompletedSynchronously |
İşlemin zaman uyumlu olarak tamamlanıp tamamlanmadığına ilişkin bir gösterge alır. |
Uzantı Metotları
| Name | Description |
|---|---|
| AsAsyncAction(Task) |
Başlatılan görevi temsil eden bir Windows Çalışma Zamanı zaman uyumsuz eylemi döndürür. |
| DispatcherOperationWait(Task, TimeSpan) |
Temel DispatcherOperation alınan işlemin tamamlanması için belirtilen süreyi bekler. |
| DispatcherOperationWait(Task) |
Temel alınanın DispatcherOperation tamamlanmasını süresiz olarak bekler. |
| IsDispatcherOperationTask(Task) |
Bunun Task bir ile ilişkilendirilip ilişkilendirildiğini belirten bir DispatcherOperationdeğer döndürür. |
Şunlara uygulanır
İş Parçacığı Güvenliği
dışındaki Tasktüm üyeleri Dispose()iş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.
