Udostępnij za pośrednictwem

Task.RunSynchronously Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Threading.Tasks
Zestaw:
System.Threading.Tasks.dll
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Task Uruchamia synchronicznie w bieżącym obiekcie TaskScheduler.

Przeciążenia

RunSynchronously()

Task Uruchamia synchronicznie w bieżącym obiekcie TaskScheduler.
RunSynchronously(TaskScheduler)

Task Uruchamia synchronicznie podany TaskScheduler element.

RunSynchronously()

Źródło:
Task.cs
Źródło:
Task.cs
Źródło:
Task.cs

Task Uruchamia synchronicznie w bieżącym obiekcie TaskScheduler.

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

Wyjątki

ObjectDisposedException

Wystąpienie Task zostało usunięte.

InvalidOperationException

Element Task nie jest w prawidłowym stanie do uruchomienia. Być może została już uruchomiona, wykonana lub anulowana albo została utworzona w sposób, który nie obsługuje planowania bezpośredniego.

Przykłady

Poniższy przykład porównuje zadanie wykonane przez wywołanie RunSynchronously metody z jednym wykonanym asynchronicznie. W obu przypadkach zadania wykonują identyczne wyrażenia lambda, które wyświetlają identyfikator zadania i identyfikator wątku, na którym uruchomiono zadanie. Zadanie oblicza sumę liczb całkowitych z zakresu od 1 do 1000 000. Jak pokazuje dane wyjściowe z przykładu, zadanie wykonane przez wywołanie RunSynchronously metody jest uruchamiane w wątku aplikacji, podczas gdy zadanie asynchroniczne nie jest wykonywane.

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

Uwagi

Zwykle zadania są wykonywane asynchronicznie w wątku puli wątków i nie blokują wywołującego wątku. Zadania wykonywane przez wywołanie RunSynchronously() metody są skojarzone z bieżącym TaskScheduler elementem i są uruchamiane w wątku wywołującym. Jeśli harmonogram docelowy nie obsługuje uruchamiania tego zadania w wątku wywołującym, zadanie zostanie zaplanowane do wykonania zgodnie z harmonogramem, a wątek wywołujący będzie blokowany do momentu ukończenia wykonywania zadania. Mimo że zadanie jest uruchamiane synchronicznie, wątek wywołujący powinien nadal wywoływać obsługę Wait wszelkich wyjątków, które może zgłaszać zadanie. Aby uzyskać więcej informacji na temat obsługi wyjątków, zobacz Obsługa wyjątków.

Zadania wykonywane przez wywołanie RunSynchronously metody są tworzone przez wywołanie konstruktora Task klasy lub Task<TResult> . Zadanie do uruchomienia synchronicznie musi być w Created stanie. Zadanie można uruchomić i uruchomić tylko raz. Wszelkie próby zaplanowanie zadania po raz drugi powoduje wyjątek.

Zobacz też

Dotyczy

RunSynchronously(TaskScheduler)

Źródło:
Task.cs
Źródło:
Task.cs
Źródło:
Task.cs

Task Uruchamia synchronicznie podany TaskScheduler element.

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)

Parametry

scheduler
TaskScheduler

Harmonogram, na którym ma zostać podjęta próba uruchomienia tego zadania w tekście.

Wyjątki

ObjectDisposedException

Wystąpienie Task zostało usunięte.

ArgumentNullException

Argumentem scheduler jest null.

InvalidOperationException

Element Task nie jest w prawidłowym stanie do uruchomienia. Być może została już uruchomiona, wykonana lub anulowana albo została utworzona w sposób, który nie obsługuje planowania bezpośredniego.

Uwagi

Zadania wykonywane przez wywołanie RunSynchronously metody są tworzone przez wywołanie konstruktora Task klasy lub Task<TResult> . Zadanie do uruchomienia synchronicznie musi być w Created stanie. Zadanie można uruchomić i uruchomić tylko raz. Wszelkie próby zaplanowanie zadania po raz drugi powoduje wyjątek.

Jeśli harmonogram docelowy nie obsługuje uruchamiania tego zadania w bieżącym wątku, zadanie zostanie zaplanowane do wykonania zgodnie z harmonogramem, a bieżący wątek zostanie zablokowany do momentu ukończenia wykonywania zadania. W związku z tym wątek wywołujący nie musi wywoływać metody, takiej jak Wait , aby upewnić się, że zadanie zostało ukończone. Aby uzyskać więcej informacji na temat obsługi wyjątków dla operacji zadań, zobacz Obsługa wyjątków.

Zobacz też

Dotyczy