Task.RunSynchronously Metode

  • Referensi

Definisi

Ruang nama:
System.Threading.Tasks
Rakitan:
System.Threading.Tasks.dll
Rakitan:
System.Runtime.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Task Menjalankan secara sinkron pada saat iniTaskScheduler.

Overload

RunSynchronously(TaskScheduler)

Task Menjalankan secara sinkron pada yang TaskScheduler disediakan.
RunSynchronously()

Task Menjalankan secara sinkron pada saat iniTaskScheduler.

RunSynchronously(TaskScheduler)

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Task Menjalankan secara sinkron pada yang TaskScheduler disediakan.

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)

Parameter

scheduler
TaskScheduler

Penjadwal untuk mencoba menjalankan tugas ini sebaris.

Pengecualian

ObjectDisposedException

Instans Task telah dibuang.

ArgumentNullException

Argumennya scheduler adalah null.

InvalidOperationException

Task tidak dalam status valid untuk dimulai. Ini mungkin telah dimulai, dijalankan, atau dibatalkan, atau mungkin telah dibuat dengan cara yang tidak mendukung penjadwalan langsung.

Keterangan

Tugas yang dijalankan dengan memanggil RunSynchronously metode ini dibuat dengan memanggil Task konstruktor kelas atau Task<TResult> . Tugas yang akan dijalankan secara sinkron harus dalam status Created . Tugas mungkin dimulai dan dijalankan hanya sekali. Setiap upaya untuk menjadwalkan tugas untuk kedua kalinya menghasilkan pengecualian.

Jika penjadwal target tidak mendukung menjalankan tugas ini pada utas saat ini, tugas akan dijadwalkan untuk dieksekusi pada penjadwal, dan utas saat ini akan memblokir sampai tugas selesai dieksekusi. Karena itu, utas panggilan tidak perlu memanggil metode seperti Wait untuk memastikan bahwa tugas telah menyelesaikan eksekusi. Untuk informasi selengkapnya tentang penanganan pengecualian untuk operasi tugas, lihat Penanganan Pengecualian.

Lihat juga

Berlaku untuk

RunSynchronously()

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Task Menjalankan secara sinkron pada saat iniTaskScheduler.

public:
 void RunSynchronously();
public void RunSynchronously ();
member this.RunSynchronously : unit -> unit
Public Sub RunSynchronously ()

Pengecualian

ObjectDisposedException

Instans Task telah dibuang.

InvalidOperationException

Task tidak dalam status valid untuk dimulai. Ini mungkin telah dimulai, dijalankan, atau dibatalkan, atau mungkin telah dibuat dengan cara yang tidak mendukung penjadwalan langsung.

Contoh

Contoh berikut membandingkan tugas yang dijalankan dengan memanggil RunSynchronously metode dengan tugas yang dijalankan secara asinkron. Dalam kedua kasus, tugas menjalankan ekspresi lambda identik yang menampilkan ID tugas dan ID utas tempat tugas dijalankan. Tugas menghitung jumlah bilangan bulat antara 1 dan 1.000.000. Seperti yang ditunjukkan oleh output dari contoh, tugas yang dijalankan dengan memanggil RunSynchronously metode berjalan pada utas aplikasi, sementara tugas asinkron tidak.

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

Keterangan

Biasanya, tugas dijalankan secara asinkron pada utas kumpulan utas dan tidak memblokir utas panggilan. Tugas yang dijalankan dengan memanggil RunSynchronously() metode dikaitkan dengan saat ini TaskScheduler dan dijalankan pada utas panggilan. Jika penjadwal target tidak mendukung menjalankan tugas ini pada utas panggilan, tugas akan dijadwalkan untuk dieksekusi pada penjadwal, dan utas panggilan akan diblokir hingga tugas selesai dieksekusi. Meskipun tugas berjalan secara sinkron, utas panggilan masih harus memanggil Wait untuk menangani pengecualian apa pun yang mungkin dilemparkan tugas. Untuk informasi selengkapnya tentang penanganan pengecualian, lihat Penanganan Pengecualian.

Tugas yang dijalankan dengan memanggil RunSynchronously metode ini dibuat dengan memanggil Task konstruktor kelas atau Task<TResult> . Tugas yang akan dijalankan secara sinkron harus dalam status Created . Tugas mungkin dimulai dan dijalankan hanya sekali. Setiap upaya untuk menjadwalkan tugas untuk kedua kalinya menghasilkan pengecualian.

Lihat juga

Berlaku untuk