Task.RunSynchronously Metod

Definition

Namnområde:
System.Threading.Tasks
Sammansättningar:
mscorlib.dll, System.Threading.Tasks.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Threading.Tasks.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Task Kör synkront på den aktuella TaskScheduler.

Överlagringar

Name Description
RunSynchronously()

Task Kör synkront på den aktuella TaskScheduler.
RunSynchronously(TaskScheduler)

Task Kör synkront på den TaskScheduler angivna.

RunSynchronously()

Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs

Task Kör synkront på den aktuella TaskScheduler.

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

Undantag

ObjectDisposedException

Instansen Task har tagits bort.

InvalidOperationException

Är Task inte i ett giltigt tillstånd som ska startas. Den kan redan ha startats, körts eller avbrutits, eller så kan den ha skapats på ett sätt som inte stöder direkt schemaläggning.

Exempel

I följande exempel jämförs en uppgift som körs genom att anropa RunSynchronously metoden med en som körs asynkront. I båda fallen kör aktiviteterna identiska lambda-uttryck som visar aktivitets-ID:t och ID:t för tråden som aktiviteten körs på. Aktiviteten beräknar summan av heltalen mellan 1 och 1 000 000. Som utdata från exemplet visar körs uppgiften som körs genom att anropa RunSynchronously metoden i programtråden, medan den asynkrona aktiviteten inte gör det.

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

Kommentarer

Vanligtvis körs uppgifter asynkront på en trådpoolstråd och blockerar inte den anropande tråden. Uppgifter som körs genom att anropa RunSynchronously() metoden är associerade med den aktuella TaskScheduler och körs i den anropande tråden. Om målschemaläggaren inte stöder körning av den här aktiviteten i den anropande tråden schemaläggs aktiviteten för körning i schemaläggaren och den anropande tråden blockeras tills aktiviteten har slutfört körningen. Även om aktiviteten körs synkront bör den anropande tråden fortfarande anropa Wait för att hantera eventuella undantag som aktiviteten kan utlösa. Mer information om undantagshantering finns i Undantagshantering.

Uppgifter som körs genom att anropa RunSynchronously metoden instansieras genom att anropa en Task konstruktor eller Task<TResult> klasskonstruktor. Uppgiften som ska köras synkront måste vara i tillståndet Created . En uppgift kan bara startas och köras en gång. Alla försök att schemalägga en aktivitet en andra gång resulterar i ett undantag.

Se även

Gäller för

RunSynchronously(TaskScheduler)

Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs
Källa:
Task.cs

Task Kör synkront på den TaskScheduler angivna.

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)

Parametrar

scheduler
TaskScheduler

Schemaläggaren som uppgiften ska köras på infogad.

Undantag

ObjectDisposedException

Instansen Task har tagits bort.

ArgumentNullException

Argumentet scheduler är null.

InvalidOperationException

Är Task inte i ett giltigt tillstånd som ska startas. Den kan redan ha startats, körts eller avbrutits, eller så kan den ha skapats på ett sätt som inte stöder direkt schemaläggning.

Kommentarer

Uppgifter som körs genom att anropa RunSynchronously metoden instansieras genom att anropa en Task konstruktor eller Task<TResult> klasskonstruktor. Uppgiften som ska köras synkront måste vara i tillståndet Created . En uppgift kan bara startas och köras en gång. Alla försök att schemalägga en aktivitet en andra gång resulterar i ett undantag.

Om målschemaläggaren inte stöder körning av den här aktiviteten i den aktuella tråden schemaläggs aktiviteten för körning i schemaläggaren och den aktuella tråden blockeras tills aktiviteten har slutfört körningen. På grund av detta behöver den anropande tråden inte anropa en metod, till exempel Wait för att säkerställa att uppgiften har slutfört körningen. Mer information om undantagshantering för aktivitetsåtgärder finns i Undantagshantering.

Se även

Gäller för