Task.RunSynchronously Метод

Определение

Пространство имен:
System.Threading.Tasks
Сборки:
mscorlib.dll, System.Threading.Tasks.dll
Сборки:
netstandard.dll, System.Runtime.dll
Сборка:
System.Threading.Tasks.dll
Сборка:
System.Runtime.dll
Сборка:
mscorlib.dll
Сборка:
netstandard.dll

Task Выполняется синхронно в текущемTaskScheduler.

Перегрузки

Имя Описание
RunSynchronously()

Task Выполняется синхронно в текущемTaskScheduler.
RunSynchronously(TaskScheduler)

Task Выполняется синхронно на предоставленном объектеTaskScheduler.

RunSynchronously()

Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs

Task Выполняется синхронно в текущемTaskScheduler.

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

Исключения

ObjectDisposedException

Экземпляр Task был удален.

InvalidOperationException

Не Task находится в допустимом состоянии для запуска. Возможно, он уже был запущен, выполнен или отменен или создан таким образом, что он не поддерживает прямое планирование.

Примеры

В следующем примере сравнивается задача, выполняемая путем вызова RunSynchronously метода с одним выполненным асинхронно. В обоих случаях задачи выполняют одинаковые лямбда-выражения, отображающие идентификатор задачи и идентификатор потока, в котором выполняется задача. Задача вычисляет сумму целых чисел от 1 до 1000 000. Как показано в выходных данных из примера, задача, выполняемая путем вызова RunSynchronously метода, выполняется в потоке приложения, а асинхронная задача не выполняется.

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

Комментарии

Обычно задачи выполняются асинхронно в потоке пула потоков и не блокируют вызывающий поток. Задачи, выполняемые путем вызова RunSynchronously() метода, связаны с текущим TaskScheduler и выполняются в вызывающем потоке. Если целевой планировщик не поддерживает выполнение этой задачи в вызывающем потоке, задача будет запланирована для выполнения на планировщике, и вызывающий поток будет блокироваться до завершения выполнения задачи. Несмотря на то, что задача выполняется синхронно, вызывающий поток должен по-прежнему вызывать Wait любые исключения, которые может вызывать задача. Дополнительные сведения об обработке исключений см. в разделе "Обработка исключений".

Задачи, выполняемые путем RunSynchronously вызова метода, создаются путем вызова Task конструктора или Task<TResult> класса. Задача, выполняемая синхронно, должна находиться в Created состоянии. Задача может быть запущена и запущена только один раз. Любые попытки запланировать задачу во второй раз приводят к исключению.

См. также раздел

Применяется к

RunSynchronously(TaskScheduler)

Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs
Исходный код:
Task.cs

Task Выполняется синхронно на предоставленном объектеTaskScheduler.

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)

Параметры

scheduler
TaskScheduler

Планировщик, на котором нужно выполнить эту задачу.

Исключения

ObjectDisposedException

Экземпляр Task был удален.

ArgumentNullException

Аргумент scheduler имеет значение null.

InvalidOperationException

Не Task находится в допустимом состоянии для запуска. Возможно, он уже был запущен, выполнен или отменен или создан таким образом, что он не поддерживает прямое планирование.

Комментарии

Задачи, выполняемые путем RunSynchronously вызова метода, создаются путем вызова Task конструктора или Task<TResult> класса. Задача, выполняемая синхронно, должна находиться в Created состоянии. Задача может быть запущена и запущена только один раз. Любые попытки запланировать задачу во второй раз приводят к исключению.

Если целевой планировщик не поддерживает выполнение этой задачи в текущем потоке, задача будет запланирована для выполнения планировщика, а текущий поток будет блокироваться до завершения выполнения задачи. Из-за этого вызывающий поток не должен вызывать метод, например Wait , чтобы убедиться, что задача завершена. Дополнительные сведения об обработке исключений для операций задач см. в разделе "Обработка исключений".

См. также раздел

Применяется к