Task.RunSynchronously Yöntem

Tanım

Ad Alanı:

System.Threading.Tasks

Bütünleştirilmiş Kod:

System.Runtime.dll

geçerli TaskTaskSchedulerüzerinde zaman uyumlu olarak çalıştırır.

Aşırı Yüklemeler

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.

RunSynchronously()

Kaynak:

Task.cs

geçerli TaskTaskSchedulerüzerinde zaman uyumlu olarak çalıştırır.

public:
 void RunSynchronously();

public void RunSynchronously ();

member this.RunSynchronously : unit -> unit

Public Sub RunSynchronously ()

Özel durumlar

ObjectDisposedException

Örnek Task atılmıştır.

InvalidOperationException

Task başlatılacak geçerli bir durumda değil. Önceden başlatılmış, yürütülmüş veya iptal edilmiş veya doğrudan zamanlamayı desteklemeyen bir şekilde oluşturulmuş olabilir.

Örnekler

Aşağıdaki örnek, yöntemini çağırarak RunSynchronously yürütülen bir görevi zaman uyumsuz olarak yürütülen bir görevle karşılaştırır. Her iki durumda da görevler, görevin çalıştığı iş parçacığının kimliğini ve görev kimliğini görüntüleyen aynı lambda ifadelerini yürütür. Görev, 1 ile 1.000.000 arasındaki tamsayıların toplamını hesaplar. Örnekteki çıktıda gösterildiği gibi, yöntemi çağrılarak RunSynchronously yürütülen görev uygulama iş parçacığında çalıştırılır, ancak zaman uyumsuz görev çalışmaz.

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

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Application executing on thread {0}",
                        Thread.CurrentThread.ManagedThreadId);
      var asyncTask = Task.Run( () => {  Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
                                                           Task.CurrentId,
                                                           Thread.CurrentThread.ManagedThreadId);
                                         long sum = 0;
                                         for (int ctr = 1; ctr <= 1000000; ctr++ )
                                            sum += ctr;
                                         return sum;
                                      });
      var syncTask = new Task<long>( () =>  { Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
                                                                 Task.CurrentId,
                                                                 Thread.CurrentThread.ManagedThreadId);
                                              long sum = 0;
                                              for (int ctr = 1; ctr <= 1000000; ctr++ )
                                                 sum += ctr;
                                              return sum;
                                            });
      syncTask.RunSynchronously();
      Console.WriteLine();
      Console.WriteLine("Task {0} returned {1:N0}", syncTask.Id, syncTask.Result);
      Console.WriteLine("Task {0} returned {1:N0}", asyncTask.Id, asyncTask.Result);
   }
}
// The example displays the following output:
//       Application executing on thread 1
//       Task 1 (syncTask) executing on Thread 1
//       Task 2 (asyncTask) executing on Thread 3
//       1 status: RanToCompletion
//       2 status: RanToCompletion
//
//       Task 2 returned 500,000,500,000
//       Task 1 returned 500,000,500,000

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

printfn $"Application executing on thread {Thread.CurrentThread.ManagedThreadId}"

let asyncTask =
    Task.Run(fun () ->
        printfn $"Task {Task.CurrentId} (asyncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
        let mutable sum = 0L

        for i = 1 to 1000000 do
            sum <- sum + int64 i

        sum)

let syncTask =
    new Task<int64>(fun () ->
        printfn $"Task {Task.CurrentId} (syncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
        let mutable sum = 0L

        for i = 1 to 1000000 do
            sum <- sum + int64 i

        sum)

syncTask.RunSynchronously()
printfn $"\nTask {syncTask.Id} returned {syncTask.Result:N0}"
printfn $"Task {asyncTask.Id} returned {asyncTask.Result:N0}"

// The example displays the following output:
//       Application executing on thread 1
//       Task 1 (syncTask) executing on Thread 1
//       Task 2 (asyncTask) executing on Thread 3
//       1 status: RanToCompletion
//       2 status: RanToCompletion
//
//       Task 2 returned 500,000,500,000
//       Task 1 returned 500,000,500,000

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Console.WriteLine("Application executing on thread {0}",
                        Thread.CurrentThread.ManagedThreadId)
      Dim asyncTask = Task.Run( Function()
                                   Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
                                                     Task.CurrentId,
                                                     Thread.CurrentThread.ManagedThreadId)
                                   Dim sum As Long = 0
                                   For ctr As Integer = 1 To 1000000
                                      sum += ctr
                                   Next
                                   Return sum
                                End Function)
      Dim syncTask As New Task(Of Long)( Function()
                                            Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
                                                              Task.CurrentId,
                                                              Thread.CurrentThread.ManagedThreadId)
                                            Dim sum As Long = 0
                                            For ctr As Integer = 1 To 1000000
                                               sum += ctr
                                            Next
                                            Return sum
                                         End Function)
      syncTask.RunSynchronously()
      Console.WriteLine()
      Console.WriteLine("Task {0} returned {1:N0}", syncTask.Id, syncTask.Result)
      Console.WriteLine("Task {0} returned {1:N0}", asyncTask.Id, asyncTask.Result)
   End Sub
End Module
' The example displays the following output:
'       Application executing on thread 1
'       Task 1 (syncTask) executing on Thread 1
'       Task 2 (asyncTask) executing on Thread 3
'       1 status: RanToCompletion
'       2 status: RanToCompletion
'
'       Task 2 returned 500,000,500,000
'       Task 1 returned 500,000,500,000

Açıklamalar

Normalde, görevler iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülür ve çağıran iş parçacığını engellemez. yöntemi çağrılarak RunSynchronously() yürütülen görevler geçerli TaskScheduler ile ilişkilendirilir ve çağıran iş parçacığında çalıştırılır. Hedef zamanlayıcı bu görevi çağıran iş parçacığında çalıştırmayı desteklemiyorsa, görev zamanlayıcıda yürütülecek şekilde zamanlanır ve görev yürütme tamamlanana kadar çağıran iş parçacığı engellenir. Görev zaman uyumlu olarak çalışsa da, çağıran iş parçacığı yine de görevin atabileceği özel durumları işlemek için çağırmalıdır Wait . Özel durum işleme hakkında daha fazla bilgi için bkz. Özel Durum İşleme.

yöntemi çağrılarak yürütülen görevlerin RunSynchronously örneği, veya TaskTask<TResult> sınıf oluşturucu çağrılarak oluşturulur. Zaman uyumlu olarak çalıştırılacak görevin durumunda olması Created gerekir. Bir görev başlatılabilir ve yalnızca bir kez çalıştırılabilir. Bir görevi ikinci kez zamanlama girişimleri özel durumla sonuçlanır.

Ayrıca bkz.

• Özel Durum İşleme (Görev Paralel Kitaplığı)

RunSynchronously(TaskScheduler)

Kaynak:

Task.cs

sağlanan Task üzerinde TaskScheduler zaman uyumlu olarak çalıştırır.

public:
 void RunSynchronously(System::Threading::Tasks::TaskScheduler ^ scheduler);

public void RunSynchronously (System.Threading.Tasks.TaskScheduler scheduler);

member this.RunSynchronously : System.Threading.Tasks.TaskScheduler -> unit

Public Sub RunSynchronously (scheduler As TaskScheduler)

Parametreler

scheduler

TaskScheduler

Bu görevi satır içinde çalıştırmayı deneyecek zamanlayıcı.

Özel durumlar

ObjectDisposedException

Örnek Task atılmıştır.

ArgumentNullException

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

InvalidOperationException

Task başlatılacak geçerli bir durumda değil. Önceden başlatılmış, yürütülmüş veya iptal edilmiş veya doğrudan zamanlamayı desteklemeyen bir şekilde oluşturulmuş olabilir.

Açıklamalar

yöntemi çağrılarak yürütülen görevlerin RunSynchronously örneği, veya TaskTask<TResult> sınıf oluşturucu çağrılarak oluşturulur. Zaman uyumlu olarak çalıştırılacak görevin durumunda olması Created gerekir. Bir görev başlatılabilir ve yalnızca bir kez çalıştırılabilir. Bir görevi ikinci kez zamanlama girişimleri özel durumla sonuçlanır.

Hedef zamanlayıcı bu görevin geçerli iş parçacığında çalıştırılmasını desteklemiyorsa, görev zamanlayıcıda yürütülecek şekilde zamanlanır ve görev yürütme tamamlanana kadar geçerli iş parçacığı bunu engeller. Bu nedenle, çağıran iş parçacığının, görevin yürütülmesinin tamamlandığından emin olmak için gibi Wait bir yöntemi çağırması gerekmez. Görev işlemleri için özel durum işleme hakkında daha fazla bilgi için bkz. Özel Durum İşleme.

Ayrıca bkz.

• TaskScheduler
• Özel Durum İşleme (Görev Paralel Kitaplığı)