TaskFactory Klass

Definition

Namnområde:: System.Threading.Tasks

Sammansättningar:: mscorlib.dll, System.Threading.Tasks.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Threading.Tasks.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Ger stöd för att skapa och schemalägga Task objekt.

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Arv: Object
TaskFactory

Exempel

I följande exempel används den statiska Factory egenskapen för att göra två anrop till TaskFactory.StartNew metoden. Den första fyller i en matris med namnen på filer i användarens katalog MyDocuments, medan den andra fyller i en matris med namnen på underkataloger för användarens Katalog MyDocuments. Den anropar TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) sedan metoden, som visar information om antalet filer och kataloger i de två matriserna efter att de två första aktiviteterna har slutfört körningen.

using System;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task[] tasks = new Task[2];
      String[] files = null;
      String[] dirs = null;
      String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

      tasks[0] = Task.Factory.StartNew( () => files = Directory.GetFiles(docsDirectory));
      tasks[1] = Task.Factory.StartNew( () => dirs = Directory.GetDirectories(docsDirectory));

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", dirs.Length);
                                             Console.WriteLine("   {0} files", files.Length);
                                          } );
   }
}
// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files

Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(1) As Task
      Dim files() As String = Nothing
      Dim dirs() As String = Nothing
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task.Factory.StartNew( Sub()
                                           files = Directory.GetFiles(docsDirectory)
                                        End Sub )
      tasks(1) = Task.Factory.StartNew( Sub()
                                           dirs = Directory.GetDirectories(docsDirectory)
                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", dirs.Length)
                                             Console.WriteLine("   {0} files", files.Length)
                                          End Sub)
   End Sub
End Module
' The example displays output like the following:
'       C:\Users\<username>\Documents contains:
'          24 subdirectories
'          16 files

Kommentarer

.NET innehåller två fabriker för att skapa och schemalägga uppgifter:

Klassen TaskFactory , som skapar Task och Task<TResult> objekt. Du kan anropa överlagringarna för den här metoden för att skapa och köra en uppgift som kräver argument som inte är standard.

Varning

Från och med .NET Framework 4.5 är metoden Task.Run det enklaste sättet att skapa en uppgift med standardkonfigurationsvärden och starta den omedelbart.
Klassen TaskFactory<TResult> , som skapar Task<TResult> objekt.

Med TaskFactory klassen kan du göra följande:

Skapa en uppgift och starta den direkt genom att anropa StartNew metoden.

Varning

Från och med .NET Framework 4.5 är metoden Task.Run det enklaste sättet att skapa en uppgift med standardkonfigurationsvärden och starta den omedelbart.
Skapa en uppgift som startar när någon av aktiviteterna i en matris har slutförts genom att anropa ContinueWhenAny metoden.
Skapa en aktivitet som startar när alla aktiviteter i en matris har slutförts genom att anropa ContinueWhenAll metoden.

Den statiska Task<TResult>.Factory egenskapen returnerar ett standardobjekt TaskFactory<TResult> . Du kan också anropa en av TaskFactory klasskonstruktorerna för att konfigurera de Task objekt som TaskFactory klassen skapar. I följande exempel konfigureras ett nytt TaskFactory objekt för att skapa aktiviteter som har en angiven annulleringstoken, alternativ för att skapa aktiviteter, fortsättningsalternativ och en anpassad schemaläggare.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

class Example
{
   static CancellationTokenSource cts = new CancellationTokenSource();

   static TaskFactory factory = new TaskFactory(
      cts.Token,
      TaskCreationOptions.PreferFairness,
      TaskContinuationOptions.ExecuteSynchronously,
      new CustomScheduler());

   static void Main()
   {
      var t2 = factory.StartNew(() => DoWork());
      cts.Dispose();
   }

   static void DoWork() {/*...*/ }
}

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim factory As New TaskFactory(cts.Token,
                                     TaskCreationOptions.PreferFairness,
                                     TaskContinuationOptions.ExecuteSynchronously,
                                     New CustomScheduler())

      Dim t2 = factory.StartNew(Sub() DoWork())
      cts.Dispose()
   End Sub

   Sub DoWork()
      ' ...
   End Sub
End Module

I de flesta fall behöver du inte instansiera en ny TaskFactory instans. I stället kan du använda Task.Factory egenskapen som returnerar ett fabriksobjekt som använder standardvärden. Du kan sedan anropa dess metoder för att starta nya aktiviteter eller definiera aktivitetsfortsättningar. En bild finns i exemplet.

Konstruktorer

Name	Description
TaskFactory()	Initierar en TaskFactory instans med standardkonfigurationen.
TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Initierar en TaskFactory instans med den angivna konfigurationen.
TaskFactory(CancellationToken)	Initierar en TaskFactory instans med den angivna konfigurationen.
TaskFactory(TaskCreationOptions, TaskContinuationOptions)	Initierar en TaskFactory instans med den angivna konfigurationen.
TaskFactory(TaskScheduler)	Initierar en TaskFactory instans med den angivna konfigurationen.

Egenskaper

Name	Description
CancellationToken	Hämtar standardtoken för annullering för den här aktivitetsfabriken.
ContinuationOptions	Hämtar standardalternativen för aktivitetsfortsättning för den här aktivitetsfabriken.
CreationOptions	Hämtar standardalternativen för att skapa aktiviteter för den här aktivitetsfabriken.
Scheduler	Hämtar standardschemaläggaren för den här aktivitetsfabriken.

Metoder

Name	Description
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll(Task[], Action<Task[]>)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Skapar en fortsättningsaktivitet som startar när en uppsättning angivna aktiviteter har slutförts.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny(Task[], Action<Task>)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Skapar en fortsättning Task som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Skapar en fortsättning Task<TResult> som kommer att startas när en aktivitet har slutförts i den angivna uppsättningen.
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Skapar en Task som kör en slutmetodåtgärd när en angiven IAsyncResult slutförs.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Skapar en Task som kör en slutmetodåtgärd när en angiven IAsyncResult slutförs.
FromAsync(IAsyncResult, Action<IAsyncResult>)	Skapar en Task som kör en slutmetodåtgärd när en angiven IAsyncResult slutförs.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)	Skapar ett Task som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Skapar ett Task<TResult> som representerar ett par start- och slutmetoder som överensstämmer med mönstret Asynkron programmeringsmodell.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Skapar en Task<TResult> som kör en slutmetodfunktion när en angiven IAsyncResult slutförs.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Skapar en Task<TResult> som kör en slutmetodfunktion när en angiven IAsyncResult slutförs.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Skapar en Task<TResult> som kör en slutmetodfunktion när en angiven IAsyncResult slutförs.
GetHashCode()	Fungerar som standard-hash-funktion. (Ärvd från Object)
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Skapar och startar en uppgift för den angivna åtgärdsdelegaten, annulleringstoken, alternativ för skapande och tillstånd.
StartNew(Action, CancellationToken)	Skapar och startar en uppgift för den angivna åtgärdsdelegaten och annulleringstoken.
StartNew(Action, TaskCreationOptions)	Skapar och startar en uppgift för det angivna åtgärdsdelegat- och skapandealternativet.
StartNew(Action)	Skapar och startar en uppgift för det angivna åtgärdsdelegatet.
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Skapar och startar en uppgift för den angivna åtgärdsdelegaten, tillståndet, annulleringstoken, skapandealternativen och schemaläggaren.
StartNew(Action<Object>, Object, CancellationToken)	Skapar och startar en uppgift för den angivna åtgärdsdelegaten, tillståndet och annulleringstoken.
StartNew(Action<Object>, Object, TaskCreationOptions)	Skapar och startar en uppgift för de angivna alternativen för åtgärdsdelegat, tillstånd och skapande.
StartNew(Action<Object>, Object)	Skapar och startar en uppgift för det angivna åtgärdsdelegatet och tillståndet.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Skapar och startar en aktivitet av typen `TResult` för den angivna funktionsdelegaten, tillståndet, annulleringstoken, skapandealternativen och schemaläggaren.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Skapar och startar en aktivitet av typen `TResult` för den angivna funktionsdelegaten, tillstånds- och annulleringstoken.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Skapar och startar en uppgift av typen `TResult` för det angivna funktionsdelegat-, tillstånds- och skapandealternativet.
StartNew<TResult>(Func<Object,TResult>, Object)	Skapar och startar en aktivitet av typen `TResult` för det angivna funktionsdelegatet och tillståndet.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Skapar och startar en aktivitet av typen `TResult` för den angivna funktionsdelegaten, annulleringstoken, skapandealternativen och schemaläggaren.
StartNew<TResult>(Func<TResult>, CancellationToken)	Skapar och startar en aktivitet av typen `TResult` för den angivna funktionsdelegaten och annulleringstoken.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Skapar och startar en aktivitet av typen `TResult` för de angivna alternativen för funktionsdelegat och skapande.
StartNew<TResult>(Func<TResult>)	Skapar och startar en uppgift av typen `TResult` för det angivna funktionsdelegatet.
ToString()	Returnerar en sträng som representerar det aktuella objektet. (Ärvd från Object)

Gäller för

Trådsäkerhet

Alla offentliga och skyddade medlemmar TaskFactory i är trådsäkra och kan användas samtidigt från flera trådar.

Se även

Feedback

Var den här sidan till hjälp?