Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Sie können das aufgabenbasierte asynchrone Muster (TAP) auf drei Arten implementieren: mithilfe der C#- und Visual Basic-Compiler in Visual Studio, manuell oder über eine Kombination aus Compiler und manuellen Methoden. In den folgenden Abschnitten werden die einzelnen Methoden ausführlich erläutert. Sie können das TAP-Muster verwenden, um sowohl computegebundene als auch E/A-gebundene asynchrone Vorgänge zu implementieren. Im Abschnitt "Workloads " werden die einzelnen Vorgangstypen erläutert.
Generieren von TAP-Methoden
Verwenden der Compiler
Ab .NET Framework 4.5 gilt jede Methode, die mit dem async SchlüsselwortAsync (in Visual Basic) zugeschrieben wird, als asynchrone Methode, und die C#- und Visual Basic-Compiler führen die erforderlichen Transformationen aus, um die Methode asynchron mithilfe von TAP zu implementieren. Eine asynchrone Methode sollte ein System.Threading.Tasks.Task oder ein System.Threading.Tasks.Task<TResult> Objekt zurückgeben. Für letzteres sollte der Textkörper der Funktion einen TResultzurückgeben, und der Compiler stellt sicher, dass dieses Ergebnis über das resultierende Aufgabenobjekt verfügbar gemacht wird. Entsprechend werden alle Ausnahmen, die im Text der Methode nicht behandelt werden, zur Ausgabeaufgabe gemarshallt und führen dazu, dass die resultierende Aufgabe im Zustand TaskStatus.Faulted endet. Die Ausnahme dieser Regel ist, wenn ein OperationCanceledException (oder abgeleiteter Typ) nicht behandelt wird, in diesem Fall endet der resultierende Vorgang im TaskStatus.Canceled Zustand.
Manuelles Generieren von TAP-Methoden
Sie können das TAP-Muster manuell implementieren, um die Implementierung besser zu steuern. Der Compiler nutzt den öffentlichen Oberflächenbereich, der über den System.Threading.Tasks-Namespace verfügbar gemacht wird, und unterstützende Typen im System.Runtime.CompilerServices-Namespace. Um das TAP selbst zu implementieren, erstellen Sie ein TaskCompletionSource<TResult> Objekt, führen Sie den asynchronen Vorgang aus, und wenn dieser abgeschlossen ist, rufen Sie die SetResult, SetException oder SetCanceled Methode oder die Try Version einer dieser Methoden auf. Wenn Sie eine TAP-Methode manuell implementieren, müssen Sie die resultierende Aufgabe abschließen, wenn der dargestellte asynchrone Vorgang abgeschlossen ist. Beispiel:
public static Task<int> ReadTask(this Stream stream, byte[] buffer, int offset, int count, object state)
{
var tcs = new TaskCompletionSource<int>();
stream.BeginRead(buffer, offset, count, ar =>
{
try { tcs.SetResult(stream.EndRead(ar)); }
catch (Exception exc) { tcs.SetException(exc); }
}, state);
return tcs.Task;
}
<Extension()>
Public Function ReadTask(stream As Stream, buffer() As Byte,
offset As Integer, count As Integer,
state As Object) As Task(Of Integer)
Dim tcs As New TaskCompletionSource(Of Integer)()
stream.BeginRead(buffer, offset, count, Sub(ar)
Try
tcs.SetResult(stream.EndRead(ar))
Catch exc As Exception
tcs.SetException(exc)
End Try
End Sub, state)
Return tcs.Task
End Function
Hybridansatz
Möglicherweise ist es hilfreich, das TAP-Muster manuell zu implementieren und die Kernlogik für die Implementierung an den Compiler zu delegieren. Sie können z. B. den Hybridansatz verwenden, wenn Sie Argumente außerhalb einer vom Compiler generierten asynchronen Methode überprüfen möchten, damit Ausnahmen dem direkten Aufrufer der Methode escapen können, anstatt über das System.Threading.Tasks.Task Objekt verfügbar gemacht zu werden:
public Task<int> MethodAsync(string input)
{
if (input == null) throw new ArgumentNullException("input");
return MethodAsyncInternal(input);
}
private async Task<int> MethodAsyncInternal(string input)
{
// code that uses await goes here
return value;
}
Public Function MethodAsync(input As String) As Task(Of Integer)
If input Is Nothing Then Throw New ArgumentNullException("input")
Return MethodAsyncInternal(input)
End Function
Private Async Function MethodAsyncInternal(input As String) As Task(Of Integer)
' code that uses await goes here
return value
End Function
Ein weiterer Fall, in dem eine solche Delegierung nützlich ist, ist, wenn Sie schnelle Pfadoptimierung implementieren und eine zwischengespeicherte Aufgabe zurückgeben möchten.
Arbeitsbelastungen
Sie können sowohl computegebundene als auch E/A-gebundene asynchrone Vorgänge als TAP-Methoden implementieren. Wenn TAP-Methoden jedoch öffentlich aus einer Bibliothek verfügbar gemacht werden, sollten sie nur für Arbeitslasten bereitgestellt werden, die I/O-gebundene Vorgänge umfassen (sie können auch Berechnungen umfassen, sollten aber nicht rein rechnerisch sein). Wenn eine Methode rein computegebunden ist, sollte sie nur als synchrone Implementierung verfügbar gemacht werden. Der verwendende Code kann dann entscheiden, ob ein Aufruf dieser synchronen Methode in eine Aufgabe eingebettet werden soll, um die Arbeit auf einen anderen Thread zu verlagern oder Parallelität zu erreichen. Und wenn eine Methode I/O-gebunden ist, sollte sie nur als asynchrone Implementierung verfügbar gemacht werden.
Computegebundene Aufgaben
Die System.Threading.Tasks.Task Klasse eignet sich ideal für die Darstellung rechenintensiver Vorgänge. Standardmäßig nutzt sie spezielle Unterstützung innerhalb der ThreadPool Klasse, um eine effiziente Ausführung zu ermöglichen, und bietet außerdem erhebliche Kontrolle darüber, wann, wo und wie asynchrone Berechnungen ausgeführt werden.
Sie können computegebundene Aufgaben auf folgende Weise generieren:
Verwenden Sie in .NET Framework 4.5 und höheren Versionen (einschließlich .NET Core und .NET 5+) die statische Task.Run Methode als Verknüpfung zu TaskFactory.StartNew. Sie können Run verwenden, um eine computegebundene Aufgabe, die auf den Threadpool ausgerichtet ist, auf einfache Weise zu starten. Dies ist der bevorzugte Mechanismus zum Starten einer computegebundenen Aufgabe. Verwenden Sie
StartNewnur direkt, wenn Sie eine genauere Kontrolle über den Vorgang wünschen.Verwenden Sie in .NET Framework 4 die TaskFactory.StartNew Methode, die eine Stellvertretung (in der Regel eine Action<T> oder eine Func<TResult>) akzeptiert, die asynchron ausgeführt werden soll. Wenn Sie einen Action<T> Delegaten bereitstellen, gibt die Methode ein System.Threading.Tasks.Task Objekt zurück, das die asynchrone Ausführung dieses Delegaten darstellt. Wenn Sie einen Func<TResult> Delegaten angeben, gibt die Methode ein System.Threading.Tasks.Task<TResult> Objekt zurück. Überladungen der StartNew Methode akzeptieren ein Abbruchtoken (CancellationToken), Aufgabenerstellungsoptionen (TaskCreationOptions) und einen Aufgabenplaner (TaskScheduler), die alle eine differenzierte Kontrolle über die Planung und Ausführung des Vorgangs bieten. Eine Factoryinstanz, die auf den aktuellen Aufgabenplaner abzielt, ist als statische Eigenschaft (Factory) der Task Klasse verfügbar, z. B.:
Task.Factory.StartNew(…).Verwenden Sie die Konstruktoren des
TaskTyps und dieStartMethode, wenn Sie den Vorgang separat generieren und planen möchten. Öffentliche Methoden dürfen nur Aufgaben zurückgeben, die bereits gestartet wurden.Verwenden Sie die Überladungen der Task.ContinueWith-Methode. Diese Methode erstellt einen neuen Vorgang, der geplant wird, wenn eine andere Aufgabe abgeschlossen wird. Einige der ContinueWith-Überladungen akzeptieren ein Abbruchtoken, Fortsetzungsmöglichkeiten und einen Aufgabenplaner für eine bessere Steuerung der Planung und Ausführung der Fortsetzungsaufgabe.
Verwenden Sie die TaskFactory.ContinueWhenAll Und TaskFactory.ContinueWhenAny Methoden. Diese Methoden erstellen einen neuen Vorgang, der geplant wird, wenn alle oder eine der angegebenen Aufgaben abgeschlossen ist. Diese Methoden stellen auch Überladungen bereit, um die Planung und Ausführung dieser Aufgaben zu steuern.
Bei rechengebundenen Vorgängen kann das System die Ausführung eines geplanten Vorgangs verhindern, wenn er eine Abbruchanforderung empfängt, bevor er mit der Ausführung der Aufgabe beginnt. Wenn Sie beispielsweise ein Abbruchtoken (CancellationToken Objekt) bereitstellen, können Sie dieses Token an den asynchronen Code übergeben, der das Token überwacht. Sie können das Token auch einer der zuvor erwähnten Methoden wie StartNew oder Run bereitstellen, damit die Task Laufzeit das Token ebenfalls überwachen kann.
Betrachten Sie beispielsweise eine asynchrone Methode, mit der ein Bild gerendert wird. Der Text der Aufgabe kann das Abbruchtoken abrufen, sodass während des Renderns die Ausführung des Codes vorzeitig beendet werden kann, falls eine Abbruchanforderung empfangen wird. Wenn die Abbruchanforderung vor dem Rendern eingeht, sollten Sie den Renderingvorgang verhindern:
internal Task<Bitmap> RenderAsync(
ImageData data, CancellationToken cancellationToken)
{
return Task.Run(() =>
{
var bmp = new Bitmap(data.Width, data.Height);
for(int y=0; y<data.Height; y++)
{
cancellationToken.ThrowIfCancellationRequested();
for(int x=0; x<data.Width; x++)
{
// render pixel [x,y] into bmp
}
}
return bmp;
}, cancellationToken);
}
Friend Function RenderAsync(data As ImageData, cancellationToken As _
CancellationToken) As Task(Of Bitmap)
Return Task.Run(Function()
Dim bmp As New Bitmap(data.Width, data.Height)
For y As Integer = 0 to data.Height - 1
cancellationToken.ThrowIfCancellationRequested()
For x As Integer = 0 To data.Width - 1
' render pixel [x,y] into bmp
Next
Next
Return bmp
End Function, cancellationToken)
End Function
Rechenintensive Vorgänge enden in einem Canceled Status, wenn mindestens eine der folgenden Bedingungen zutrifft:
Eine Abbruchanforderung wird über das CancellationToken-Objekt übermittelt, das als Argument für die Erstellungsmethode bereitgestellt wird (z. B.
StartNewoderRun), bevor die Aufgabe in den Running-Zustand übergeht.Eine OperationCanceledException-Ausnahme wird im Text einer solchen Aufgabe nicht behandelt, diese Ausnahme enthält das gleiche CancellationToken, das an die Aufgabe übergeben wird und dieses Token stellt dar, dass der Abbruch angefordert wird.
Wenn eine andere Ausnahme im Textkörper der Aufgabe nicht behandelt wird, endet die Aufgabe im Faulted Zustand, und alle Versuche, auf die Aufgabe zu warten oder auf das Ergebnis zuzugreifen, führt dazu, dass eine Ausnahme ausgelöst wird.
E/A-gebundene Tasks
Verwenden Sie den TaskCompletionSource<TResult> Typ, um eine Aufgabe zu erstellen, die nicht direkt von einem Thread für die gesamte Ausführung unterstützt werden soll. Dieser Typ macht eine Task Eigenschaft verfügbar, die eine zugeordnete Task<TResult> Instanz zurückgibt. Der Lebenszyklus dieser Aufgabe wird durch TaskCompletionSource<TResult> Methoden wie SetResult, SetException, , SetCanceled, und deren TrySet Varianten gesteuert.
Angenommen, Sie möchten eine Aufgabe erstellen, die nach einem bestimmten Zeitraum abgeschlossen wird. Sie können beispielsweise eine Aktivität auf der Benutzeroberfläche verzögern. Die System.Threading.Timer-Klasse ermöglicht es bereits, einen Delegaten nach einem angegebenen Zeitraum asynchron aufzurufen, und mit TaskCompletionSource<TResult> lässt sich eine Task<TResult>-Front für den Timer erstellen, wie im folgenden Beispiel:
public static Task<DateTimeOffset> Delay(int millisecondsTimeout)
{
TaskCompletionSource<DateTimeOffset> tcs = null;
Timer timer = null;
timer = new Timer(delegate
{
timer.Dispose();
tcs.TrySetResult(DateTimeOffset.UtcNow);
}, null, Timeout.Infinite, Timeout.Infinite);
tcs = new TaskCompletionSource<DateTimeOffset>(timer);
timer.Change(millisecondsTimeout, Timeout.Infinite);
return tcs.Task;
}
Public Function Delay(millisecondsTimeout As Integer) As Task(Of DateTimeOffset)
Dim tcs As TaskCompletionSource(Of DateTimeOffset) = Nothing
Dim timer As Timer = Nothing
timer = New Timer(Sub(obj)
timer.Dispose()
tcs.TrySetResult(DateTimeOffset.UtcNow)
End Sub, Nothing, Timeout.Infinite, Timeout.Infinite)
tcs = New TaskCompletionSource(Of DateTimeOffset)(timer)
timer.Change(millisecondsTimeout, Timeout.Infinite)
Return tcs.Task
End Function
Die Task.Delay Methode wird zu diesem Zweck bereitgestellt und kann innerhalb einer anderen asynchronen Methode verwendet werden, beispielsweise um eine asynchrone Abfrageschleife zu implementieren.
public static async Task Poll(Uri url, CancellationToken cancellationToken,
IProgress<bool> progress)
{
while(true)
{
await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
bool success = false;
try
{
await DownloadStringAsync(url);
success = true;
}
catch { /* ignore errors */ }
progress.Report(success);
}
}
Public Async Function Poll(url As Uri, cancellationToken As CancellationToken,
progress As IProgress(Of Boolean)) As Task
Do While True
Await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken)
Dim success As Boolean = False
Try
await DownloadStringAsync(url)
success = true
Catch
' ignore errors
End Try
progress.Report(success)
Loop
End Function
Die TaskCompletionSource<TResult> Klasse verfügt nicht über ein nicht generisches Gegenstück.
Task<TResult> leitet sich von Task ab, sodass Sie das generische TaskCompletionSource<TResult>-Objekt für I/O-gebundene Methoden verwenden können, die einfach eine Aufgabe zurückgeben. Um dies zu erreichen, können Sie eine Quelle mit einem Dummy-TResult (Boolean) verwenden. Das ist eine gute Standardmöglichkeit, aber wenn Sie darüber besorgt sind, dass der Benutzer der Task sie in eine Task<TResult> umwandeln wird, können Sie stattdessen einen privaten TResult-Typ verwenden). Die Methode im vorherigen Beispiel gibt z. B Delay . die aktuelle Uhrzeit zusammen mit dem resultierenden Offset (Task<DateTimeOffset>) zurück. Wenn ein solcher Ergebniswert nicht erforderlich ist, könnte die Methode stattdessen wie folgt codiert werden (beachten Sie die Änderung des Rückgabetyps und die Änderung des Arguments in TrySetResult):
public static Task<bool> Delay(int millisecondsTimeout)
{
TaskCompletionSource<bool> tcs = null;
Timer timer = null;
timer = new Timer(delegate
{
timer.Dispose();
tcs.TrySetResult(true);
}, null, Timeout.Infinite, Timeout.Infinite);
tcs = new TaskCompletionSource<bool>(timer);
timer.Change(millisecondsTimeout, Timeout.Infinite);
return tcs.Task;
}
Public Function Delay(millisecondsTimeout As Integer) As Task(Of Boolean)
Dim tcs As TaskCompletionSource(Of Boolean) = Nothing
Dim timer As Timer = Nothing
Timer = new Timer(Sub(obj)
timer.Dispose()
tcs.TrySetResult(True)
End Sub, Nothing, Timeout.Infinite, Timeout.Infinite)
tcs = New TaskCompletionSource(Of Boolean)(timer)
timer.Change(millisecondsTimeout, Timeout.Infinite)
Return tcs.Task
End Function
Gemischte rechengebundene und E/A-gebundene Aufgaben
Asynchrone Methoden sind nicht nur auf rechengebundene oder E/A-gebundene Vorgänge beschränkt, sondern können eine Mischung der beiden darstellen. Tatsächlich werden mehrere asynchrone Vorgänge häufig in größeren gemischten Vorgängen kombiniert. Beispielsweise hat die RenderAsync Methode in einem vorherigen Beispiel einen rechenintensiven Vorgang ausgeführt, um ein Bild basierend auf einigen Eingaben imageDatazu rendern. Dies imageData kann von einem Webdienst stammen, auf den Sie asynchron zugreifen:
public async Task<Bitmap> DownloadDataAndRenderImageAsync(
CancellationToken cancellationToken)
{
var imageData = await DownloadImageDataAsync(cancellationToken);
return await RenderAsync(imageData, cancellationToken);
}
Public Async Function DownloadDataAndRenderImageAsync(
cancellationToken As CancellationToken) As Task(Of Bitmap)
Dim imageData As ImageData = Await DownloadImageDataAsync(cancellationToken)
Return Await RenderAsync(imageData, cancellationToken)
End Function
In diesem Beispiel wird auch veranschaulicht, wie ein einzelnes Abbruchtoken durch mehrere asynchrone Vorgänge geleitet werden kann. Weitere Informationen finden Sie im Abschnitt zur Verwendung von Abbruchtokens unter Verwenden des aufgabenbasierten asynchronen Musters.
Siehe auch
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
