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

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

在 Task 当前 TaskScheduler节点上同步运行。

重载

名称	说明
RunSynchronously()	在 Task 当前 TaskScheduler节点上同步运行。
RunSynchronously(TaskScheduler)	在 Task 提供的服务器上 TaskScheduler 同步运行。

RunSynchronously()

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

在 Task 当前 TaskScheduler节点上同步运行。

public:
 void RunSynchronously();

public void RunSynchronously();

member this.RunSynchronously : unit -> unit

Public Sub RunSynchronously ()

例外

ObjectDisposedException

实例 Task 已释放。

InvalidOperationException

未 Task 处于要启动的有效状态。它可能已启动、执行或取消，或者可能以不支持直接计划的方式创建。

示例

以下示例将调用 RunSynchronously 方法执行的任务与异步执行的一个任务进行比较。在这两种情况下，任务都执行相同的 lambda 表达式，这些表达式显示任务运行的任务 ID 和线程的 ID。该任务计算 1 到 1,000,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)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Source:: 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 处于要启动的有效状态。它可能已启动、执行或取消，或者可能以不支持直接计划的方式创建。

注解

如果目标计划程序不支持在当前线程上运行此任务，则任务将计划在计划程序上执行，并且当前线程将在任务完成执行之前阻止。因此，调用线程不需要调用方法，例如 Wait 确保任务已完成执行。有关任务操作的异常处理的详细信息，请参阅异常处理。

另请参阅

适用于

反馈

此页面是否有帮助？