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
Task sınıfı, bir değer döndürmeyen ve genellikle zaman uyumsuz olarak yürütülen tek bir işlemi temsil eder. Tasknesneler, ilk olarak .NET Framework 4'te tanıtılan 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ığı havuzu iş parçacığında zaman uyumsuz olarak yürütülür; görevin durumunu belirlemek için özelliğinin yanı IsCanceledsıra , IsCompletedve IsFaulted özelliklerini de kullanabilirsinizStatus. 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.
Bu bölümdeki konular:
Görev örnekleme örnekleri
Görev oluşturma ve yürütme
Görev oluşturma ve yürütmeyi ayırma
Bir veya daha fazla görev tamamlanmasını bekliyor
Görevler ve kültür
Hata ayıklayıcısı geliştiricileri için
Görev örneği oluşturma
Aşağıdaki örnek dört görev oluşturur ve yürütür. Üç görev, türünde Objectbir bağımsız değişken kabul eden adlı actionbir Action<T> temsilci yürütür. Dördüncü bir görev, görev oluşturma yöntemi çağrısında satır içinde tanımlanan bir Action lambda ifadesi (temsilci) yürütür. Her görevin örneği oluşturulur ve farklı bir şekilde çalıştırılır:
Görev
t1sınıfı oluşturucu çağrılarak görev örneği oluşturulur, ancak yalnızca görevt2başlatıldıktan sonra yöntemini çağırarak Start() başlatılır.Görev
t2örneği oluşturulur ve yöntemi çağrılarak tek bir yöntem çağrısında TaskFactory.StartNew(Action<Object>, Object) başlatılır.Görev
t3örneği oluşturulur ve yöntemi çağrılarak tek bir yöntem çağrısında Run(Action) başlatılır.Görev
t4, yöntemi çağrılarak RunSynchronously() ana iş parçacığında zaman uyumlu olarak yürütülür.
Görev t4 zaman uyumlu olarak yürütür çünkü ana uygulama iş parçacığında yürütülür. Kalan görevler genellikle bir veya daha fazla iş parçacığı havuzu iş parçacığında zaman uyumsuz 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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 örnekler çeşitli yollarla oluşturulabilir. .NET Framework 4.5 ile başlayan 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örevi 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
Imports System.Threading.Tasks
Module Example
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 olarak .NET Framework 4'te bir görevi başlatmanın en yaygın yöntemi statik TaskFactory.StartNew yöntemdir. 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
Imports System.Threading.Tasks
Module Example
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.
Görev oluşturma ve yürütmeyi ayırma
sınıfı Task , 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 sonra daha sonra görevi yürütme için zamanlamak için yöntemini çağırabilirsiniz Task.Start .
Bir veya daha fazla görev tamamlanmasını bekliyor
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 başlatılmaz yürütülmeye 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. Diğerlerinde uygulamanızın mantığı, çağıran iş parçacığının yalnızca bir veya daha fazla görev yürütmeyi tamamladığında yürütmeye devam etmesi gerektirebilir. Bir veya daha fazla görev tamamlanmasını beklemek için bir Wait yöntem çağırarak çağıran iş parçacığının ve başlattığı zaman uyumsuz görevlerin yürütülmesini eşitleyebilirsiniz.
Tek bir görevin tamamlanmasını beklemek için yöntemini çağırabilirsiniz Task.Wait . yöntemine yapılan Wait bir ç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 uyku için yöntemini çağırarak Thread.Sleep çalışmanın simülasyonunu oluşturur.
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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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 (hangisi önce gelirse) kadar çağıran iş parçacığını engeller. Aşağıdaki örnek iki saniye boyunca uyku modunda olan 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örevin yürütülmesi tamamlanmadan önce çağıran iş parçacığı engellenir.
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.
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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.
ve Wait(Int32, CancellationToken) yöntemlerini çağırarak Wait(CancellationToken) bir iptal belirteci de sağlayabilirsiniz. Belirtecin IsCancellationRequested özelliği true yöntemi yürütülürken Wait ise veya olursatrue, yöntemi bir OperationCanceledExceptionoluşturur.
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 yönteminin aşırı yüklemelerinden Task.WaitAny 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 ilk WaitAny(Task[]) görevin tamamlanmasını bekler. Örnek daha sonra üç görevi de durumuyla ilgili bilgileri 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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
Yöntemini çağırarak WaitAll bir dizi görevi tamamlamayı da bekleyebilirsiniz. Aşağıdaki örnek on görev oluşturur, on görevinin tümünün tamamlanmasını bekler ve sonra 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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, aşağıdaki örnekte gösterildiği gibi, çalışan görevlerde oluşan özel durumların yöntemini çağıran iş parçacığına Wait yayıldığını unutmayın. Üçü normal tamamlanan ve üçü özel durum oluşturan 12 görevi başlatır. Kalan altı görevden üçü başlamadan önce iptal edilir ve üçü yürütülürken iptal edilir. Yöntem çağrısında WaitAll özel durumlar oluşturulur ve bir try/catch blok 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
Imports System.Threading
Imports System.Threading.Tasks
Module Example
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
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ığının bağlamının bir parçası olur. Yani, görevin yürütülürken iş parçacığının geçerli kültürü ne olursa olsun, 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.
Not
Mağaza uygulamaları, varsayılan kültürü ayarlama ve alma Windows Çalışma Zamanı 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 yayına 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 aracılığıyla Status da 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 yöntemi, InternalWait bir görevin bekleme işlemine girdiği zaman için olası bir işaretleyici sağlar.
Oluşturucular
| Task(Action) |
Belirtilen eylemle yeni Task bir başlatır. |
| Task(Action, CancellationToken) |
Belirtilen eylem ve CancellationTokenile yeni Task bir başlatır. |
| Task(Action, CancellationToken, TaskCreationOptions) |
Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır. |
| Task(Action, TaskCreationOptions) |
Belirtilen eylem ve oluşturma seçenekleriyle yeni Task bir başlatır. |
| Task(Action<Object>, Object) |
Belirtilen eylem ve durumla yeni Task bir başlatır. |
| Task(Action<Object>, Object, CancellationToken) |
Belirtilen eylem, durum ve seçeneklerle 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, TaskCreationOptions) |
Belirtilen eylem, durum ve seçeneklerle yeni Task bir başlatır. |
Özellikler
| AsyncState |
oluşturulduktan sonra sağlanan durum nesnesini veya sağlanmazsa Task 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 öğesini TaskCreationOptions alır. |
| CurrentId |
Şu anda yürütülmekte Taskolan öğesinin kimliğini döndürür. |
| Exception |
AggregateException Erken sona ermesini sağlayan öğesini Task alır. Task başarıyla tamamlandıysa veya henüz herhangi bir özel durum oluşturduysa, 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
| ConfigureAwait(Boolean) |
Bunu Taskbeklemek için kullanılan bir awaiter yapılandırılı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,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, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Çağıran tarafından sağlanan durum bilgilerini ve bir 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, 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. Devamlılık, 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>) |
Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| 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>, 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>, 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<TResult>(Func<Task,Object,TResult>, Object) |
Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlanıp bir değer döndürdüğünde zaman uyumsuz olarak yürütülen bir devamlılık oluşturur. |
| 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, 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, arayan 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, 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,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. |
| 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>, 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. Devamlılık bir iptal belirteci geçirilir ve belirtilen zamanlayıcıyı kullanı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. |
| Delay(Int32) |
Belirtilen sayıda milisaniyeden sonra tamamlanan bir görev oluşturur. |
| Delay(Int32, CancellationToken) |
Belirtilen milisaniyeden sonra tamamlanan iptal edilebilir bir görev oluşturur. |
| Delay(TimeSpan) |
Belirtilen zaman aralığından sonra tamamlanan bir görev oluşturur. |
| Delay(TimeSpan, CancellationToken) |
Belirtilen zaman aralığından sonra tamamlanan iptal edilebilir bir görev oluşturur. |
| Dispose() |
Task sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır. |
| Dispose(Boolean) |
Taskyönetilmeyen kaynaklarının tümünü serbest bırakarak öğesini atmış olur. |
| 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() |
Type Geçerli örneğini alır. (Devralındığı yer: Object) |
| MemberwiseClone() |
Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object) |
| 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(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(Func<Task>) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından |
| Run(Func<Task>, 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<Task<TResult>>, CancellationToken) |
Belirtilen çalışmayı iş parçacığı havuzunda çalışacak şekilde kuyruğa alır ve tarafından |
| 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. |
| 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 |
| RunSynchronously() |
geçerli TaskTaskSchedulerüzerinde zaman uyumlu olarak çalıştırır. |
| RunSynchronously(TaskScheduler) |
sağlanan Task ü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) |
belirtilen TaskScheduleröğesine Taskyürütülmek üzere zamanlayarak öğesini başlatır. |
| ToString() |
Geçerli nesneyi temsil eden dizeyi 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) |
Task belirtilen milisaniye içinde yürütmenin tamamlanmasını bekler. |
| 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(TimeSpan) |
Yürütmenin Task belirli bir zaman aralığı içinde tamamlanmasını bekler. |
| Wait(TimeSpan, CancellationToken) |
yürütmenin Task tamamlanmasını bekler. |
| WaitAll(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) |
Sağlanan Task tüm nesnelerin belirli bir milisaniye içinde yürütmeyi tamamlanmasını bekler. |
| WaitAll(Task[], Int32, CancellationToken) |
Sağlanan Task tüm nesnelerin belirli bir milisaniye içinde veya bekleme iptal edilene kadar yürütülmesini bekler. |
| WaitAll(Task[], TimeSpan) |
Sağlanan iptal edilebilir Task nesnelerin tümünün belirtilen zaman aralığı içinde yürütülmesini bekler. |
| WaitAny(Task[]) |
Sağlanan Task nesnelerden herhangi birinin 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) |
Sağlanan Task nesnelerden herhangi birinin belirtilen sayıda milisaniye içinde yürütmeyi tamamlanmasını bekler. |
| WaitAny(Task[], Int32, CancellationToken) |
Sağlanan Task nesnelerden herhangi birinin belirli bir milisaniye içinde veya iptal belirteci iptal edilene kadar yürütmenin tamamlanmasını bekler. |
| WaitAny(Task[], TimeSpan) |
Sağlanan Task nesnelerden herhangi birinin belirli bir zaman aralığı içinde yürütülmesini bekler. |
| WaitAsync(CancellationToken) |
Bu Task tamamlandığında veya belirtilen CancellationToken iptal istendiğinde tamamlanacak bir Task alır. |
| WaitAsync(TimeSpan) |
Bu Task tamamlandığında veya belirtilen zaman aşımı sona erdiğinde tamamlanacak bir Task alır. |
| WaitAsync(TimeSpan, CancellationToken) |
Bu Task tamamlandığında, belirtilen zaman aşımı sona erdiğinde veya belirtilen CancellationToken iptal istendiğ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(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>(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(Task, Task) |
Sağlanan görevlerden herhangi 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>(Task<TResult>, Task<TResult>) |
Sağlanan görevlerden herhangi 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. |
| Yield() |
Beklendiğinde zaman uyumsuz olarak geçerli bağlama geri döndüren beklenebilir bir görev oluşturur. |
Belirtik Arabirim Kullanımları
| 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ı
| DispatcherOperationWait(Task) |
Temel alınanın DispatcherOperation tamamlanmasını süresiz olarak bekler. |
| DispatcherOperationWait(Task, TimeSpan) |
Temel alınan DispatcherOperation işlemin tamamlanması için belirtilen süreyi bekler. |
| IsDispatcherOperationTask(Task) |
Bunun Task bir ile ilişkilendirilip ilişkilendirildiğini belirten bir DispatcherOperationdeğer döndürür. |
| AsAsyncAction(Task) |
Başlatılan görevi temsil eden Windows Çalışma Zamanı zaman uyumsuz eylemi döndürür. |
Şunlara uygulanır
İş Parçacığı Güvenliği
dışındaki Dispose()tüm üyeleri Taskiş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.