Task<TResult> Klass

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

Källa:: Future.cs

Källa:: Task_T.cs

Källa:: Future.cs

Källa:: Future.cs

Källa:: Future.cs

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.

Representerar en asynkron åtgärd som kan returnera ett värde.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task

public class Task<TResult> : System.Threading.Tasks.Task

type Task<'Result> = class
    inherit Task

Public Class Task(Of TResult)
Inherits Task

Typparametrar

TResult

Typen av resultat som genereras av den här Task<TResult>.

Arv: Object

Task
Task<TResult>

Kommentarer

Klassen Task<TResult> representerar en enskild åtgärd som returnerar ett värde och som vanligtvis körs asynkront. Task<TResult> objekt är en av de centrala komponenterna i det aktivitetsbaserade asynkrona mönster som först introducerades i .NET Framework 4. Eftersom det arbete som utförs av ett Task<TResult> objekt vanligtvis körs asynkront på en trådpooltråd i stället för synkront på huvudprogramtråden Status , kan du använda egenskapen, liksom IsCanceledegenskaperna , IsCompletedoch IsFaulted för att fastställa tillståndet för en uppgift. Oftast används ett lambda-uttryck för att ange det arbete som uppgiften ska utföra.

Task<TResult> instanser kan skapas på flera olika sätt. Den vanligaste metoden, som är tillgänglig från och med .NET Framework 4.5, är att anropa metoden static Task.Run<TResult>(Func<TResult>) eller Task.Run<TResult>(Func<TResult>, CancellationToken). De här metoderna är ett enkelt sätt att starta en uppgift med hjälp av standardvärden och utan att hämta ytterligare parametrar. I följande exempel används Task.Run<TResult>(Func<TResult>) metoden för att starta en aktivitet som loopar och sedan visar antalet loop-iterationer:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Ett alternativ och det vanligaste sättet att starta en aktivitet i .NET Framework 4 är att anropa metoden static TaskFactory.StartNew eller TaskFactory<TResult>.StartNew. Egenskapen Task.Factory returnerar ett TaskFactory objekt och egenskapen Task<TResult>.Factory returnerar ett TaskFactory<TResult> objekt. Med överlagringar av metoden StartNew kan du skicka argument, definiera alternativ för att skapa aktiviteter och ange en schemaläggare. I följande exempel används TaskFactory<TResult>.StartNew(Func<TResult>) metoden för att starta en uppgift. Den är funktionellt likvärdig med koden i föregående exempel.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

Mer fullständiga exempel finns i Aktivitetsbaserad asynkron programmering.

Klassen Task<TResult> innehåller även konstruktorer som initierar uppgiften men som inte schemalägger den för körning. Av prestandaskäl Task.Run är metoderna och Task.Factory.StartNew de bästa mekanismerna för att skapa och schemalägga beräkningsuppgifter, men för scenarier där skapande och schemaläggning av aktiviteter måste separeras kan konstruktorerna användas och aktivitetens Start metod kan sedan användas för att schemalägga aktiviteten för körning vid ett senare tillfälle.

Från och med skrivbordsappar som riktar sig mot .NET Framework 4.6 blir kulturen i tråden som skapar och anropar en uppgift en del av trådens kontext. Oavsett den aktuella kulturen i den tråd som aktiviteten körs på är aktivitetens aktuella kultur kulturen i den anropande tråden. För appar som riktar in sig på versioner av .NET Framework före .NET Framework 4.6 är aktivitetens kultur kulturen i den tråd som aktiviteten körs på. Mer information finns i avsnittet "Kultur och aktivitetsbaserade asynkrona åtgärder" i ämnet CultureInfo . Observera att Store-appar följer Windows Runtime i inställningen och hämtar standardkulturen.

För åtgärder som inte returnerar ett värde använder Task du klassen . Om du börjar med C# 7.0 använder du strukturen för en enklare uppgift som är en värdetyp i stället för en referenstyp System.Threading.Tasks.ValueTask<TResult> .

Konstruktorer

Name	Description
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)	Initierar en ny Task<TResult> med den angivna åtgärden, tillståndet och alternativen.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken)	Initierar en ny Task<TResult> med den angivna åtgärden, tillståndet och alternativen.
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Initierar en ny Task<TResult> med den angivna åtgärden, tillståndet och alternativen.
Task<TResult>(Func<Object,TResult>, Object)	Initierar en ny Task<TResult> med den angivna funktionen och tillståndet.
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)	Initierar en ny Task<TResult> med de angivna alternativen för funktion och skapande.
Task<TResult>(Func<TResult>, CancellationToken)	Initierar en ny Task<TResult> med den angivna funktionen.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Initierar en ny Task<TResult> med de angivna alternativen för funktion och skapande.
Task<TResult>(Func<TResult>)	Initierar en ny Task<TResult> med den angivna funktionen.

Egenskaper

Name	Description
AsyncState	Hämtar tillståndsobjektet som angavs när det Task skapades, eller null om inget angavs. (Ärvd från Task)
CreationOptions	Hämtar den TaskCreationOptions som används för att skapa den här uppgiften. (Ärvd från Task)
Exception	Hämtar det AggregateException som orsakade Task slutet i förtid. Om det Task har slutförts eller ännu inte har genererat några undantag returneras `null`. (Ärvd från Task)
Factory	Hämtar en fabriksmetod för att skapa och konfigurera Task<TResult> instanser.
Id	Hämtar ett ID för den här Task instansen. (Ärvd från Task)
IsCanceled	Hämtar om den här Task instansen har slutfört körningen på grund av att den har avbrutits. (Ärvd från Task)
IsCompleted	Hämtar ett värde som anger om aktiviteten har slutförts. (Ärvd från Task)
IsCompletedSuccessfully	Hämtar om aktiviteten kördes till slutförande. (Ärvd från Task)
IsFaulted	Hämtar om den Task slutförda på grund av ett ohanterat undantag. (Ärvd från Task)
Result	Hämtar resultatvärdet för den här Task<TResult>.
Status	Hämtar uppgiften TaskStatus . (Ärvd från Task)

Metoder

Name	Description
ConfigureAwait(Boolean)	Konfigurerar en awaiter som används för att invänta detta Task<TResult>.
ConfigureAwait(ConfigureAwaitOptions)	Konfigurerar en awaiter som används för att invänta detta Task.
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och en annulleringstoken och som körs när målet Task är klart. Fortsättningen körs baserat på en uppsättning angivna villkor och använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och en annulleringstoken och som körs asynkront när målet Task är klart. (Ärvd från Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och körs när målet Task är klart. Fortsättningen körs baserat på en uppsättning angivna villkor. (Ärvd från Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och körs asynkront när målet Task är klart. Fortsättningen använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith(Action<Task,Object>, Object)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och körs när målet Task är klart. (Ärvd från Task)
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>,Object>, Object)	Skapar en fortsättning som skickas tillståndsinformation och som körs när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs enligt villkoret som anges i `continuationOptions`.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Skapar en avbruten fortsättning som körs asynkront när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Skapar en fortsättning som körs enligt villkoret som anges i `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Skapar en fortsättning som körs asynkront när målet Task<TResult> är klart.
ContinueWith(Action<Task<TResult>>)	Skapar en fortsättning som körs asynkront när måluppgiften slutförs.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs när målaktiviteten konkurrerar enligt angiven TaskContinuationOptions. Fortsättningen tar emot en annulleringstoken och använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith(Action<Task>, CancellationToken)	Skapar en fortsättning som tar emot en annulleringstoken och körs asynkront när målet Task är klart. (Ärvd från Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Skapar en fortsättning som körs när målaktiviteten slutförs enligt angiven TaskContinuationOptions. (Ärvd från Task)
ContinueWith(Action<Task>, TaskScheduler)	Skapar en fortsättning som körs asynkront när målet Task är klart. Fortsättningen använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith(Action<Task>)	Skapar en fortsättning som körs asynkront när målet Task är klart. (Ärvd från Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Skapar en fortsättning som körs när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs enligt villkoret som anges i `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Skapar en fortsättning som körs asynkront när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Skapar en fortsättning som körs enligt villkoret som anges i `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Skapar en fortsättning som körs asynkront när målet Task<TResult> är klart.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Skapar en fortsättning som körs asynkront när målet Task<TResult> är klart.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs baserat på de angivna alternativen för aktivitetsfortsättning när målet Task slutförs och returnerar ett värde. Fortsättningen tar emot tillståndsinformation från uppringaren och en annulleringstoken och använder den angivna schemaläggaren. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Skapar en fortsättning som körs asynkront när målet Task är klart och returnerar ett värde. Fortsättningen tar emot tillståndsinformation från uppringaren och en annulleringstoken. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Skapar en fortsättning som körs baserat på de angivna alternativen för aktivitetsfortsättning när målet Task är klart. Fortsättningen tar emot tillståndsinformation från uppringaren. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Skapar en fortsättning som körs asynkront när målet Task är klart. Fortsättningen tar emot tillståndsinformation från anroparen och använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Skapar en fortsättning som tar emot tillståndsinformation från anroparen och körs asynkront när målet Task slutförs och returnerar ett värde. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Skapar en fortsättning som körs enligt de angivna fortsättningsalternativen och returnerar ett värde. Fortsättningen skickas en annulleringstoken och använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Skapar en fortsättning som körs asynkront när målet Task är klart och returnerar ett värde. Fortsättningen får en annulleringstoken. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Skapar en fortsättning som körs enligt de angivna fortsättningsalternativen och returnerar ett värde. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Skapar en fortsättning som körs asynkront när målet Task är klart och returnerar ett värde. Fortsättningen använder en angiven schemaläggare. (Ärvd från Task)
ContinueWith<TResult>(Func<Task,TResult>)	Skapar en fortsättning som körs asynkront när målet Task<TResult> är klart och returnerar ett värde. (Ärvd från Task)
Dispose()	Släpper alla resurser som används av den aktuella instansen Task av klassen. (Ärvd från Task)
Dispose(Boolean)	TaskGör sig av med och frigör alla dess ohanterade resurser. (Ärvd från Task)
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
GetAwaiter()	Hämtar en inväntare som används för att invänta detta Task<TResult>.
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)
RunSynchronously()	Task Kör synkront på den aktuella TaskScheduler. (Ärvd från Task)
RunSynchronously(TaskScheduler)	Task Kör synkront på den TaskScheduler angivna. (Ärvd från Task)
Start()	TaskStartar , schemalägger den för körning till den aktuella TaskScheduler. (Ärvd från Task)
Start(TaskScheduler)	TaskStartar , schemalägger den för körning till angiven TaskScheduler. (Ärvd från Task)
ToString()	Returnerar en sträng som representerar det aktuella objektet. (Ärvd från Object)
Wait()	Väntar på att slutföra körningen Task . (Ärvd från Task)
Wait(CancellationToken)	Väntar på att slutföra körningen Task . Väntetiden avslutas om en annulleringstoken avbryts innan aktiviteten slutförs. (Ärvd från Task)
Wait(Int32, CancellationToken)	Väntar på att slutföra körningen Task . Väntetiden avslutas om ett tidsgränsintervall förflutit eller en annulleringstoken avbryts innan aktiviteten slutförs. (Ärvd från Task)
Wait(Int32)	Väntar på att slutföra körningen Task inom ett angivet antal millisekunder. (Ärvd från Task)
Wait(TimeSpan, CancellationToken)	Väntar på att slutföra körningen Task . (Ärvd från Task)
Wait(TimeSpan)	Väntar på att slutföra körningen Task inom ett angivet tidsintervall. (Ärvd från Task)
WaitAsync(CancellationToken)	Hämtar en Task<TResult> som kommer att slutföras när detta Task<TResult> har slutförts eller när den angivna CancellationToken har begärt annullering.
WaitAsync(TimeSpan, CancellationToken)	Hämtar en Task<TResult> som kommer att slutföras när detta Task<TResult> har slutförts, när den angivna tidsgränsen upphör att gälla eller när den angivna CancellationToken har begärt annullering.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Hämtar en Task<TResult> som kommer att slutföras när detta Task<TResult> har slutförts, när den angivna tidsgränsen upphör att gälla eller när den angivna CancellationToken har begärt annullering.
WaitAsync(TimeSpan, TimeProvider)	Hämtar en Task<TResult> som kommer att slutföras när detta Task<TResult> har slutförts eller när den angivna tidsgränsen upphör att gälla.
WaitAsync(TimeSpan)	Hämtar en Task<TResult> som kommer att slutföras när detta Task<TResult> har slutförts eller när den angivna tidsgränsen upphör att gälla.

Explicita gränssnittsimplementeringar

Name	Description
IAsyncResult.AsyncWaitHandle	Hämtar en WaitHandle som kan användas för att vänta tills uppgiften har slutförts. (Ärvd från Task)
IAsyncResult.CompletedSynchronously	Hämtar en indikation på om åtgärden har slutförts synkront. (Ärvd från Task)

Tilläggsmetoder

Name	Description
AsAsyncAction(Task)	Returnerar en Windows Runtime asynkron åtgärd som representerar en startad uppgift.
AsAsyncOperation<TResult>(Task<TResult>)	Returnerar en Windows Runtime asynkron åtgärd som representerar en startad aktivitet som returnerar ett resultat.
DispatcherOperationWait(Task, TimeSpan)	Väntar på den angivna tiden för att den underliggande ska DispatcherOperation slutföras.
DispatcherOperationWait(Task)	Väntar på obestämd tid för att den underliggande ska DispatcherOperation slutföras.
IsDispatcherOperationTask(Task)	Returnerar ett värde som anger om detta Task är associerat med en DispatcherOperation.

Gäller för

Trådsäkerhet

Alla medlemmar Task<TResult>i , förutom Dispose(), är trådsäkra och kan användas från flera trådar samtidigt.

Se även

Feedback

Var den här sidan till hjälp?