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

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

Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.

Aşırı Yüklemeler

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>, 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,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, 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, 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)	Ç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>, TaskContinuationOptions)	Hedef görev belirtilen TaskContinuationOptionsdeğerine göre tamamlandığında 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>)	Hedef Task tamamlandığında zaman uyumsuz olarak 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, 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, 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,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,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, 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,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,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,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>, 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(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parametreler

continuationAction: Action<Task,Object>

tamamlandığında çalıştırılacak Task bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve ve çağıran tarafından sağlanan durum nesnesine bağımsız değişken olarak geçirilir.

state: Object

Devamlılık eylemi tarafından kullanılacak verileri temsil eden bir nesne.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülmesi için kullanılacak.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

bağımsız scheduler değişkenidir null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

ObjectDisposedException

Sağlananlar CancellationToken zaten atılmış.

Açıklamalar

Döndürülen Task görev, geçerli görev tamamlanana kadar yürütülecek şekilde zamanlanmaz. Parametresi aracılığıyla continuationOptions belirtilen ölçütler karşılanmazsa, devamlılık görevi zamanlanmış yerine iptal edilir.

Şunlara uygulanır

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parametreler

continuationAction: Action<Task>

Belirtilen continuationOptionsöğesine göre çalıştırılacak bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülmesi için kullanılacak.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ObjectDisposedException

CancellationTokenSource Belirteci oluşturan zaten atılmış.

ArgumentNullException

Bağımsız continuationAction değişken null.

-veya-

Bağımsız scheduler değişken null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Örnekler

Aşağıda, hem arka planda hem de kullanıcı arabirimi iş parçacıklarında çalışma çalıştırmak için ContinueWith kullanma örneği verilmiştir.

private void Button1_Click(object sender, EventArgs e)
{
   var backgroundScheduler = TaskScheduler.Default;
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },
                         backgroundScheduler).
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },
                             backgroundScheduler).
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);
}

Private Sub Button1_Click(ByVal sender As System.Object,
                          ByVal e As System.EventArgs) Handles Button1.Click
   Dim backgroundScheduler = TaskScheduler.Default
   Dim uiScheduler = TaskScheduler.FromCurrentSynchronizationContext()

   Task.Factory.StartNew(Sub()
                           DoBackgroundComputation()
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)
                            UpdateUI()
                         End Sub, uiScheduler).ContinueWith(Sub(t)
                            DoAnotherBackgroundComputation()
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)
                            UpdateUIAgain()
                         End Sub, uiScheduler)
End Sub

Açıklamalar

Şunlara uygulanır

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, scheduler As TaskScheduler) As Task

Parametreler

continuationAction: Action<Task,Object>

state: Object

Devamlılık eylemi tarafından kullanılacak verileri temsil eden bir nesne.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülmesi için kullanılacak.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

bağımsız scheduler değişkenidir null.

Açıklamalar

Döndürülen Task , geçerli görev tamamlanana kadar yürütülmek üzere zamanlanmaz; tamamlanmak üzere başarıyla çalıştırıldığından, işlenmeyen bir özel durumdan dolayı hataya neden olduğundan veya iptal edildiği için erken çıkıldığında tamamlanır.

Şunlara uygulanır

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, continuationOptions As TaskContinuationOptions) As Task

Parametreler

continuationAction: Action<Task,Object>

state: Object

Devamlılık eylemi tarafından kullanılacak verileri temsil eden bir nesne.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

bağımsız continuationAction değişkenidir null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Döndürülen Task görev, geçerli görev tamamlanana kadar yürütülecek şekilde zamanlanmaz. parametresi aracılığıyla continuationOptions belirtilen devamlılık ölçütleri karşılanmazsa, devamlılık görevi zamanlanmış yerine iptal edilir.

Şunlara uygulanır

ContinueWith(Action<Task,Object>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken) As Task

Parametreler

continuationAction: Action<Task,Object>

state: Object

Devamlılık eylemi tarafından kullanılacak verileri temsil eden bir nesne.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

bağımsız continuationAction değişkenidir null.

ObjectDisposedException

Sağlananlar CancellationToken zaten atılmış.

Açıklamalar

Şunlara uygulanır

ContinueWith(Action<Task,Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Çağıran tarafından sağlanan durum bilgilerini alan ve hedef Task tamamlandığında yürütülen bir devamlılık oluşturur.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state);

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object) As Task

Parametreler

continuationAction: Action<Task,Object>

Görev tamamlandığında çalıştırılacak bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve ve çağıran tarafından sağlanan durum nesnesine bağımsız değişken olarak geçirilir.

state: Object

Devamlılık eylemi tarafından kullanılacak verileri temsil eden bir nesne.

Döndürülenler

Task

Yeni bir devamlılık görevi.

Özel durumlar

ArgumentNullException

bağımsız continuationAction değişkenidir null.

Açıklamalar

Döndürülen Task görev, geçerli görev tamamlanana kadar yürütülmek üzere zamanlanmaz; tamamlanmak üzere başarıyla çalıştırıldığı için tamamlanır, işlenmeyen bir özel durum nedeniyle hata verir veya iptal nedeniyle erken çıkılır.

Şunlara uygulanır

ContinueWith(Action<Task>, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Hedef görev belirtilen TaskContinuationOptionsdeğerine göre tamamlandığında yürütülen bir devamlılık oluşturur.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task), continuationOptions As TaskContinuationOptions) As Task

Parametreler

continuationAction: Action<Task>

Belirtilen continuationOptionsöğesine göre çalıştırılacak bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

Bağımsız continuationAction değişken null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Örnekler

Aşağıdaki örnekte, bir devamlılık görevinin öncül görev tamamlandığında zaman uyumlu olarak çalıştırılması gerektiğini belirtmek için kullanma TaskContinuationOptions gösterilmektedir. (Belirtilen görev çağrılana ContinueWith kadar zaten tamamlandıysa, zaman uyumlu devamlılık çağrılan ContinueWithiş parçacığında çalıştırılır.)

public class TaskCounter
{
   private volatile int _count;

   public void Track(Task t)
   {
      if (t == null) throw new ArgumentNullException("t");
      Interlocked.Increment(ref _count);
      t.ContinueWith(ct => Interlocked.Decrement(ref _count), TaskContinuationOptions.ExecuteSynchronously);
   }

   public int NumberOfActiveTasks { get { return _count; } }
}

Public Class TaskCounter
   Private _count as Integer

   Public Sub Track(ByVal t as Task)
      If t is Nothing Then Throw New ArgumentNullException("t")
      Interlocked.Increment(_count)
      t.ContinueWith(Sub(ct)
                        Interlocked.Decrement(_count)
                     End Sub,
                     TaskContinuationOptions.ExecuteSynchronously)
   End Sub

   Public ReadOnly Property NumberOfActiveTasks As Integer
      Get
         Return _count
      End Get
   End Property
End Class

Açıklamalar

Şunlara uygulanır

ContinueWith(Action<Task>, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

İptal belirteci alan ve hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken) As Task

Parametreler

continuationAction: Action<Task>

tamamlandığında çalıştırılacak Task bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ObjectDisposedException

CancellationTokenSource Belirteci oluşturan zaten atılmış.

ArgumentNullException

Bağımsız continuationAction değişken null.

Açıklamalar

Şunlara uygulanır

ContinueWith(Action<Task>)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Hedef Task tamamlandığında zaman uyumsuz olarak yürütülen bir devamlılık oluşturur.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);

member this.ContinueWith : Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task)) As Task

Parametreler

continuationAction: Action<Task>

tamamlandığında çalıştırılacak Task bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ArgumentNullException

bağımsız continuationAction değişkenidir null.

Örnekler

Aşağıdaki örnek, bir diziyi 100 rastgele tarih ve saat değeriyle dolduran bir görevi tanımlar. Dizi tamamen dolduruldıktan sonra en erken ve en son tarih değerlerini seçmek için yöntemini kullanır ContinueWith(Action<Task>) .

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var firstTask = Task.Factory.StartNew( () => {
                               Random rnd = new Random();
                               DateTime[] dates = new DateTime[100];
                               Byte[] buffer = new Byte[8];
                               int ctr = dates.GetLowerBound(0);
                               while (ctr <= dates.GetUpperBound(0)) {
                                  rnd.NextBytes(buffer);
                                  long ticks = BitConverter.ToInt64(buffer, 0);
                                  if (ticks <= DateTime.MinValue.Ticks | ticks >= DateTime.MaxValue.Ticks)
                                     continue;

                                  dates[ctr] = new DateTime(ticks);
                                  ctr++;
                               }
                               return dates;
                            } ); 
                         
      Task continuationTask = firstTask.ContinueWith( (antecedent) => {
                             DateTime[] dates = antecedent.Result;
                             DateTime earliest = dates[0];
                             DateTime latest = earliest;
                             
                             for (int ctr = dates.GetLowerBound(0) + 1; ctr <= dates.GetUpperBound(0); ctr++) {
                                if (dates[ctr] < earliest) earliest = dates[ctr];
                                if (dates[ctr] > latest) latest = dates[ctr];
                             }
                             Console.WriteLine("Earliest date: {0}", earliest);
                             Console.WriteLine("Latest date: {0}", latest);
                          } );                      
      // Since a console application otherwise terminates, wait for the continuation to complete.
     continuationTask.Wait();
   }
}
// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM

open System
open System.Threading.Tasks

let firstTask =
    Task.Factory.StartNew(fun () ->
        let rnd = Random()
        let dates = Array.zeroCreate 100
        let buffer = Array.zeroCreate 8
        let mutable i = dates.GetLowerBound 0

        while i <= dates.GetUpperBound 0 do
            rnd.NextBytes buffer
            let ticks = BitConverter.ToInt64(buffer, 0)

            if ticks > DateTime.MinValue.Ticks && ticks < DateTime.MaxValue.Ticks then
                dates[i] <- DateTime ticks
                i <- i + 1

        dates)

let continuationTask =
    firstTask.ContinueWith(
        Action<Task<DateTime[]>>(fun antecedent ->
            let dates: DateTime[] = antecedent.Result
            let mutable earliest = dates[0]
            let mutable latest = earliest

            for i = dates.GetLowerBound 0 + 1 to dates.GetUpperBound 0 do
                if dates.[i] < earliest then
                    earliest <- dates.[i]

                if dates.[i] > latest then
                    latest <- dates.[i]

            printfn $"Earliest date: {earliest}"
            printfn $"Latest date: {latest}")
    )
// Since a console application otherwise terminates, wait for the continuation to complete.
continuationTask.Wait()


// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim firstTask = Task.Factory.StartNew( Function()
                               Dim rnd As New Random()
                               Dim dates(99) As Date
                               Dim buffer(7) As Byte
                               Dim ctr As Integer = dates.GetLowerBound(0)
                               Do While ctr <= dates.GetUpperBound(0)
                                  rnd.NextBytes(buffer)
                                  Dim ticks As Long = BitConverter.ToInt64(buffer, 0)
                                  If ticks <= DateTime.MinValue.Ticks Or ticks >= DateTime.MaxValue.Ticks Then Continue Do

                                  dates(ctr) = New Date(ticks)
                                  ctr += 1
                               Loop
                               Return dates
                            End Function )
                         
      Dim continuationTask As Task = firstTask.ContinueWith( Sub(antecedent)
                             Dim dates() As Date = antecedent.Result
                             Dim earliest As Date = dates(0)
                             Dim latest As Date = earliest
                             
                             For ctr As Integer = dates.GetLowerBound(0) + 1 To dates.GetUpperBound(0)
                                If dates(ctr) < earliest Then earliest = dates(ctr)
                                If dates(ctr) > latest Then latest = dates(ctr)
                             Next
                             Console.WriteLine("Earliest date: {0}", earliest)
                             Console.WriteLine("Latest date: {0}", latest)
                          End Sub)                      
      ' Since a console application otherwise terminates, wait for the continuation to complete.
      continuationTask.Wait()
   End Sub
End Module
' The example displays output like the following:
'       Earliest date: 2/11/0110 12:03:41 PM
'       Latest date: 7/29/9989 2:14:49 PM

Bir konsol uygulaması devamlılık görevi yürütülmeden önce sonlandırılabileceğinden, Wait() devamlılık işleminin örnek sona ermeden önce yürütülmesinin tamamlandığından emin olmak için yöntemi çağrılır.

Ek bir örnek için bkz. Devamlılık Görevlerini Kullanarak Görevleri Zincirleme.

Açıklamalar

Şunlara uygulanır

ContinueWith(Action<Task>, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task), scheduler As TaskScheduler) As Task

Parametreler

continuationAction: Action<Task>

tamamlandığında çalıştırılacak Task bir eylem. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülmesi için kullanılacak.

Döndürülenler

Task

Yeni bir devamlılık Task.

Özel durumlar

ObjectDisposedException

Task yok edildi.

ArgumentNullException

bağımsız continuationAction değişkenidir null.

-veya-

Bağımsız scheduler değişken null.

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,Object,TResult>

tamamlandığında çalıştırılacak Task bir işlev. Çalıştırıldığında, temsilci tamamlanmış göreve ve çağıran tarafından sağlanan durum nesnesine bağımsız değişken olarak geçirilir.

state: Object

continuation işlevi tarafından kullanılacak verileri temsil eden bir nesne.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ArgumentNullException

bağımsız continuationFunction değişkenidir null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Döndürülen Task<TResult> görev, geçerli görev tamamlanana kadar yürütülecek şekilde zamanlanmaz. parametresi aracılığıyla continuationOptions belirtilen devamlılık ölçütleri karşılanmazsa, devamlılık görevi zamanlanmış yerine iptal edilir.

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,Object,TResult>

state: Object

continuation işlevi tarafından kullanılacak verileri temsil eden bir nesne.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülecek şekilde kullanılacak.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ArgumentNullException

bağımsız scheduler değişkenidir null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

ObjectDisposedException

Sağlananlar CancellationToken zaten atılmış.

Açıklamalar

Döndürülen Task<TResult> , geçerli görev tamamlanana kadar yürütme için zamanlanmaz. parametresi aracılığıyla continuationOptions belirtilen ölçütler karşılanmazsa, devamlılık görevi zamanlanmış yerine iptal edilir.

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur ve bir değer döndürür. Devamlılık bir iptal belirteci geçirilir ve belirtilen zamanlayıcıyı kullanır.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,TResult>

Belirtilen continuationOptions. Çalıştırıldığında'ya göre çalıştırılacak bir işlev, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülecek şekilde kullanılacak.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ObjectDisposedException

Task atılmış.

-veya-

CancellationTokenSource Belirteci oluşturan zaten atılmış.

ArgumentNullException

Bağımsız continuationFunction değişken null.

-veya-

Bağımsız scheduler değişken null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Örnekler

Aşağıdaki örnekte ContinueWith yönteminin devamlılık seçenekleriyle nasıl kullanılacağı gösterilmektedir:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationOptionsDemo
{
    // Demonstrated features:
    //      TaskContinuationOptions
    //		Task.ContinueWith()
    // 		Task.Factory
    //		Task.Wait()
    // Expected results:
    // 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    //      Notice that no if statements are used.
    //		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    //		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    static void Main()
    {
        Action success = () => Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction",
                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action failure = () =>
        {
            Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error",
                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException("SIMULATED EXCEPTION");
        };

        Action<Task> commit = (antecendent) => Console.WriteLine("Task={0}, Thread={1}: Commit transaction",
                                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action<Task> rollback = (antecendent) =>
        {
            // "Observe" your antecedent's exception so as to avoid an exception
            // being thrown on the finalizer thread
            var unused = antecendent.Exception;

            Console.WriteLine("Task={0}, Thread={1}: Rollback transaction",
                  Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        };

        // Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran1 = Task.Factory.StartNew(success);

        // The following task gets scheduled only if tran1 completes successfully
        var commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran1 DOES NOT complete successfully
        var rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        commitTran1.Wait();

        // -----------------------------------------------------------------------------------

        // Failed transaction - Begin + exception + Rollback
        Console.WriteLine("\nDemonstrating a failed transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran2 = Task.Factory.StartNew(failure);

        // The following task gets scheduled only if tran2 completes successfully
        var commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran2 DOES NOT complete successfully
        var rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        rollbackTran2.Wait();
    }
}

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

// Demonstrated features:
//      TaskContinuationOptions
//		Task.ContinueWith()
// 		Task.Factory
//		Task.Wait()
// Expected results:
// 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
//      Notice that no if statements are used.
//		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
//		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
// Documentation:
//		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
let success =
    fun () ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin successful transaction"

let failure =
    fun () ->

        printfn
            $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin transaction and encounter an error"

        raise (InvalidOperationException "SIMULATED EXCEPTION")

let commit =
    fun antecendent ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Commit transaction"

let rollback =
    fun (antecendent: Task) ->

        // "Observe" your antecedent's exception so as to avoid an exception
        // being thrown on the finalizer thread
        let unused = antecendent.Exception

        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Rollback transaction"

// Successful transaction - Begin + Commit
printfn "Demonstrating a successful transaction"

// Initial task
// Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
let tran1 = Task.Factory.StartNew success

// The following task gets scheduled only if tran1 completes successfully
let commitTran1 =
    tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

// The following task gets scheduled only if tran1 DOES NOT complete successfully
let rollbackTran1 =
    tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

// For demo purposes, wait for the sample to complete
commitTran1.Wait()

// -----------------------------------------------------------------------------------

// Failed transaction - Begin + exception + Rollback
printfn "\nDemonstrating a failed transaction"

// Initial task
// Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
let tran2: Task = Task.Factory.StartNew failure

// The following task gets scheduled only if tran2 completes successfully
let commitTran2 =
    tran2.ContinueWith(Action<Task> commit, TaskContinuationOptions.OnlyOnRanToCompletion)

// The following task gets scheduled only if tran2 DOES NOT complete successfully
let rollbackTran2 =
    tran2.ContinueWith(Action<Task> rollback, TaskContinuationOptions.NotOnRanToCompletion)

// For demo purposes, wait for the sample to complete
rollbackTran2.Wait()

Imports System.Threading
Imports System.Threading.Tasks

Module ContuationOptionsDemo
    ' Demonstrated features:
    '   TaskContinuationOptions
    '   Task.ContinueWith()
    '   Task.Factory
    '   Task.Wait()
    ' Expected results:
    '   This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    '   Notice that no if statements are used.
    '   The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    '   The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    Private Sub Main()
        Dim success As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                End Sub

        Dim failure As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                    Throw New InvalidOperationException("SIMULATED EXCEPTION")
                                End Sub

        Dim commit As Action(Of Task) = Sub(antecendent)
                                            Console.WriteLine("Task={0}, Thread={1}: Commit transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                        End Sub

        Dim rollback As Action(Of Task) = Sub(antecendent)
                                              ' "Observe" your antecedent's exception so as to avoid an exception
                                              ' being thrown on the finalizer thread
                                              Dim unused = antecendent.Exception

                                              Console.WriteLine("Task={0}, Thread={1}: Rollback transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                          End Sub

        ' Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran1 As Task = Task.Factory.StartNew(success)

        ' The following task gets scheduled only if tran1 completes successfully
        Dim commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran1 DOES NOT complete successfully
        Dim rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        commitTran1.Wait()

        ' -----------------------------------------------------------------------------------


        ' Failed transaction - Begin + exception + Rollback 
        Console.WriteLine(vbLf & "Demonstrating a failed transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran2 As Task = Task.Factory.StartNew(failure)

        ' The following task gets scheduled only if tran2 completes successfully
        Dim commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran2 DOES NOT complete successfully
        Dim rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        rollbackTran2.Wait()
    End Sub
End Module

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, scheduler As TaskScheduler) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,Object,TResult>

state: Object

Devamlılık işlevi tarafından kullanılacak verileri temsil eden bir nesne.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülecek şekilde kullanılacak.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ArgumentNullException

scheduler bağımsız değişkenidirnull.

Açıklamalar

Döndürülen Task<TResult> , geçerli görev tamamlanana kadar yürütülmek üzere zamanlanmaz; tamamlanana kadar, tamamlanmasının nedeni başarıyla tamamlanması, işlenmeyen bir özel durum nedeniyle hataya neden olması veya iptal edilmesi nedeniyle erken çıkmasıdır.

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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, çağıran tarafından sağlanan durum bilgilerini ve bir iptal belirtecini alır.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);

member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,Object,TResult>

state: Object

Devamlılık işlevi tarafından kullanılacak verileri temsil eden bir nesne.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ArgumentNullException

continuationFunction bağımsız değişkenidirnull.

ObjectDisposedException

Sağlanan CancellationToken zaten atılmış.

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,TResult>

tamamlandığında çalıştırılacak Task bir işlev. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

cancellationToken: CancellationToken

Yeni CancellationToken devamlılık görevine atanacak olan.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ObjectDisposedException

Task atılmış.

-veya-

CancellationTokenSource Belirteci oluşturan zaten atılmış.

ArgumentNullException

Bağımsız continuationFunction değişken null.

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Belirtilen devamlılık seçeneklerine göre yürütülen bir devamlılık oluşturur ve bir değer döndürür.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,TResult>

içinde continuationOptionsbelirtilen koşula göre çalıştırılacak bir işlev. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

continuationOptions: TaskContinuationOptions

Devamlılık zamanlandığında ve nasıl davranacağını gösteren seçenekler. Buna gibi OnlyOnCanceledölçütlerin yanı sıra gibi yürütme seçenekleri ExecuteSynchronouslyde dahildir.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ObjectDisposedException

Task atılmış.

ArgumentNullException

Bağımsız continuationFunction değişken null.

ArgumentOutOfRangeException

continuationOptions bağımsız değişkeni için TaskContinuationOptionsgeçersiz bir değer belirtir.

Açıklamalar

Döndürülen Task<TResult> , geçerli görev tamamlanana kadar yürütme için zamanlanmaz. parametresi aracılığıyla continuationOptions belirtilen devamlılık ölçütleri karşılanmazsa, devamlılık görevi zamanlanmış yerine iptal edilir.

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state);

member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,Object,TResult>

state: Object

Devamlılık işlevi tarafından kullanılacak verileri temsil eden bir nesne.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ArgumentNullException

continuationFunction bağımsız değişkenidirnull.

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,TResult>)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);

member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult)) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,TResult>

tamamlandığında çalıştırılacak Task<TResult> bir işlev. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

Döndürülenler

Task<TResult>

Yeni bir devamlılık görevi.

Özel durumlar

ObjectDisposedException

Task atılmış.

ArgumentNullException

Bağımsız continuationFunction değişken null.

Örnekler

Aşağıdaki örnekte ContinueWith yönteminin nasıl kullanılacağı gösterilmektedir:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationSimpleDemo
{
    // Demonstrated features:
    // 		Task.Factory
    //		Task.ContinueWith()
    //		Task.Wait()
    // Expected results:
    // 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    //		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    //		A sequence of three unrelated tasks is created where tasks have different types.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    static void Main()
    {
        Action<string> action =
            (str) =>
                Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId);

        // Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)");
        Task.Factory.StartNew(() => action("alpha"))
            .ContinueWith(antecendent => action("beta"))        // Antecedent data is ignored
            .ContinueWith(antecendent => action("gamma"))
            .Wait();

        Func<int, int> negate =
            (n) =>
            {
                Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId);
                return -n;
            };

        // Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine("\nCreating a sequence of function tasks where each continuation uses the result from its antecendent");
        Task<int>.Factory.StartNew(() => negate(5))
            .ContinueWith(antecendent => negate(antecendent.Result))		// Antecedent result feeds into continuation
            .ContinueWith(antecendent => negate(antecendent.Result))
            .Wait();

        // Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine("\nCreating a sequence of tasks where you can mix and match the types");
        Task<int>.Factory.StartNew(() => negate(6))
            .ContinueWith(antecendent => action("x"))
            .ContinueWith(antecendent => negate(7))
            .Wait();
    }
}

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

// Demonstrated features:
// 		Task.Factory
//		Task.ContinueWith()
//		Task.Wait()
// Expected results:
// 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
//		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
//		A sequence of three unrelated tasks is created where tasks have different types.
// Documentation:
//		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
let action =
    fun str -> printfn $"Task={Task.CurrentId}, str=%s{str}, Thread={Thread.CurrentThread.ManagedThreadId}"

// Creating a sequence of action tasks (that return no result).
printfn "Creating a sequence of action tasks (that return no result)"

Task
    .Factory
    .StartNew(fun () -> action "alpha")
    .ContinueWith(fun antecendent -> action "beta") // Antecedent data is ignored
    .ContinueWith(fun antecendent -> action "gamma")
    .Wait()

let negate =
    fun n ->
        printfn $"Task={Task.CurrentId}, n={n}, -n={2 - n}, Thread={Thread.CurrentThread.ManagedThreadId}"
        -n

// Creating a sequence of function tasks where each continuation uses the result from its antecendent
printfn "\nCreating a sequence of function tasks where each continuation uses the result from its antecendent"

Task<int>
    .Factory.StartNew(fun () -> negate 5)
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result)) // Antecedent result feeds into continuation
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result))
    .Wait()

// Creating a sequence of tasks where you can mix and match the types
printfn "\nCreating a sequence of tasks where you can mix and match the types"

Task<int>
    .Factory.StartNew(fun () -> negate 6)
    .ContinueWith(Action<Task>(fun antecendent -> action "x"))
    .ContinueWith(fun antecendent -> negate 7)
    .Wait()

Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

    ' Demonstrated features:
    '   Task.Factory
    '   Task.ContinueWith()
    '   Task.Wait()
    ' Expected results:
    '   A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    '   A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    '   A sequence of three unrelated tasks is created where tasks have different types.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    Sub Main()
        Dim action As Action(Of String) = Sub(str) Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId)

        ' Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)")
        ' Continuations ignore antecedent data
        Task.Factory.StartNew(Sub() action("alpha")).ContinueWith(Sub(antecendent) action("beta")).ContinueWith(Sub(antecendent) action("gamma")).Wait()


        Dim negate As Func(Of Integer, Integer) = Function(n)
                                                      Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId)
                                                      Return -n
                                                  End Function

        ' Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine(vbLf & "Creating a sequence of function tasks where each continuation uses the result from its antecendent")
        Task(Of Integer).Factory.StartNew(Function() negate(5)).ContinueWith(Function(antecendent) negate(antecendent.Result)).ContinueWith(Function(antecendent) negate(antecendent.Result)).Wait()


        ' Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine(vbLf & "Creating a sequence of tasks where you can mix and match the types")
        Task(Of Integer).Factory.StartNew(Function() negate(6)).ContinueWith(Sub(antecendent) action("x")).ContinueWith(Function(antecendent) negate(7)).Wait()
    End Sub
End Module

Açıklamalar

Şunlara uygulanır

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), scheduler As TaskScheduler) As Task(Of TResult)

Tür Parametreleri

TResult

Devamlılık tarafından üretilen sonucun türü.

Parametreler

continuationFunction: Func<Task,TResult>

tamamlandığında çalıştırılacak Task bir işlev. Çalıştırıldığında, temsilci tamamlanmış göreve bağımsız değişken olarak geçirilir.

scheduler: TaskScheduler

TaskScheduler devamlılık göreviyle ilişkilendirilecek ve yürütülecek şekilde kullanılacak.

Döndürülenler

Task<TResult>

Yeni bir devamlılık Task<TResult>.

Özel durumlar

ObjectDisposedException

Task atılmış.

ArgumentNullException

Bağımsız continuationFunction değişken null.

-veya-

Bağımsız scheduler değişken null.

Açıklamalar

Şunlara uygulanır