TPL en traditionele .NET asynchrone programmering
.NET biedt de volgende twee standaardpatronen voor het uitvoeren van I/O-gebonden en asynchrone asynchrone bewerkingen:
Asynchroon programmeermodel (APM), waarin asynchrone bewerkingen worden vertegenwoordigd door een paar begin-/eindmethoden. Bijvoorbeeld: FileStream.BeginRead en Stream.EndRead.
Asynchroon patroon (EAP) op basis van gebeurtenissen, waarin asynchrone bewerkingen worden vertegenwoordigd door een methode/gebeurtenispaar met de naam
<OperationName>Asyncen<OperationName>Completed. Bijvoorbeeld: WebClient.DownloadStringAsync en WebClient.DownloadStringCompleted.
De TPL (Task Parallel Library) kan op verschillende manieren worden gebruikt in combinatie met een van de asynchrone patronen. U kunt zowel APM- als EAP-bewerkingen beschikbaar maken als Task objecten voor bibliotheekgebruikers, of u kunt de APM-patronen beschikbaar maken, maar objecten gebruiken Task om ze intern te implementeren. In beide scenario's kunt u met behulp van Task objecten de code vereenvoudigen en profiteren van de volgende nuttige functionaliteit:
Registreer callbacks, in de vorm van taakvervolgingen, op elk moment nadat de taak is gestart.
Coördineer meerdere bewerkingen die worden uitgevoerd als reactie op een
Begin_methode met behulp van de ContinueWhenAll en ContinueWhenAny methoden of de WaitAll methoden WaitAny .Asynchrone I/O-gebonden en rekengebonden bewerkingen in hetzelfde
Taskobject inkapselen.Controleer de status van het
Taskobject.Marshal de status van een bewerking naar een
Taskobject met behulp van TaskCompletionSource<TResult>.
APM-bewerkingen verpakken in een taak
Zowel de als System.Threading.Tasks.TaskFactory<TResult> de System.Threading.Tasks.TaskFactory klassen bieden verschillende overbelastingen van de TaskFactory.FromAsync en TaskFactory<TResult>.FromAsync methoden waarmee u een APM begin-/eindmethodepaar in een of Task<TResult> meer Task exemplaren kunt inkapselen. De verschillende overbelastingen zijn geschikt voor elk begin-/eindmethodepaar dat van nul tot drie invoerparameters heeft.
Voor paren met End methoden die een waarde retourneren (een Function in Visual Basic), gebruikt u de methoden in TaskFactory<TResult> die een Task<TResult>. Voor End methoden die ongeldigheid retourneren (een Sub in Visual Basic), gebruikt u de methoden in TaskFactory die een Taskmaken.
Voor die paar gevallen waarin de Begin methode meer dan drie parameters of parameters bevat of out parameters bevatref, worden extra FromAsync overbelastingen verstrekt die alleen de End methode inkapselen.
In het volgende voorbeeld ziet u de handtekening voor de FromAsync overbelasting die overeenkomt met de FileStream.BeginRead en FileStream.EndRead methoden.
public Task<TResult> FromAsync<TArg1, TArg2, TArg3>(
Func<TArg1, TArg2, TArg3, AsyncCallback, object, IAsyncResult> beginMethod, //BeginRead
Func<IAsyncResult, TResult> endMethod, //EndRead
TArg1 arg1, // the byte[] buffer
TArg2 arg2, // the offset in arg1 at which to start writing data
TArg3 arg3, // the maximum number of bytes to read
object state // optional state information
)
Public Function FromAsync(Of TArg1, TArg2, TArg3)(
ByVal beginMethod As Func(Of TArg1, TArg2, TArg3, AsyncCallback, Object, IAsyncResult),
ByVal endMethod As Func(Of IAsyncResult, TResult),
ByVal dataBuffer As TArg1,
ByVal byteOffsetToStartAt As TArg2,
ByVal maxBytesToRead As TArg3,
ByVal stateInfo As Object)
Deze overbelasting heeft als volgt drie invoerparameters. De eerste parameter is een Func<T1,T2,T3,T4,T5,TResult> gemachtigde die overeenkomt met de handtekening van de FileStream.BeginRead methode. De tweede parameter is een Func<T,TResult> gemachtigde die een IAsyncResultTResult. Omdat EndRead een geheel getal wordt geretourneerd, wordt door de compiler het type TResult as Int32 en het type van de taak afgeleid als Task. De laatste vier parameters zijn identiek aan de parameters in de FileStream.BeginRead methode:
De buffer waarin de bestandsgegevens moeten worden opgeslagen.
De offset in de buffer waar gegevens moeten worden geschreven.
De maximale hoeveelheid gegevens die uit het bestand moet worden gelezen.
Een optioneel object waarin door de gebruiker gedefinieerde statusgegevens worden opgeslagen om door te geven aan de callback.
ContinueWith gebruiken voor de callback-functionaliteit
Als u toegang tot de gegevens in het bestand nodig hebt, in plaats van alleen het aantal bytes, is de FromAsync methode niet voldoende. Gebruik in plaats daarvan Task, waarvan Result de eigenschap de bestandsgegevens bevat. U kunt dit doen door een vervolg toe te voegen aan de oorspronkelijke taak. De voortzetting voert het werk uit dat doorgaans door de AsyncCallback gedelegeerde wordt uitgevoerd. Deze wordt aangeroepen wanneer de antecedent is voltooid en de gegevensbuffer is gevuld. (Het FileStream object moet worden gesloten voordat het wordt geretourneerd.)
In het volgende voorbeeld ziet u hoe u een Task retourneert die hetEndReadBeginRead/paar van de FileStream klasse inkapselt.
const int MAX_FILE_SIZE = 14000000;
public static Task<string> GetFileStringAsync(string path)
{
FileInfo fi = new FileInfo(path);
byte[] data = null;
data = new byte[fi.Length];
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, data.Length, true);
//Task<int> returns the number of bytes read
Task<int> task = Task<int>.Factory.FromAsync(
fs.BeginRead, fs.EndRead, data, 0, data.Length, null);
// It is possible to do other work here while waiting
// for the antecedent task to complete.
// ...
// Add the continuation, which returns a Task<string>.
return task.ContinueWith((antecedent) =>
{
fs.Close();
// Result = "number of bytes read" (if we need it.)
if (antecedent.Result < 100)
{
return "Data is too small to bother with.";
}
else
{
// If we did not receive the entire file, the end of the
// data buffer will contain garbage.
if (antecedent.Result < data.Length)
Array.Resize(ref data, antecedent.Result);
// Will be returned in the Result property of the Task<string>
// at some future point after the asynchronous file I/O operation completes.
return new UTF8Encoding().GetString(data);
}
});
}
Const MAX_FILE_SIZE As Integer = 14000000
Shared Function GetFileStringAsync(ByVal path As String) As Task(Of String)
Dim fi As New FileInfo(path)
Dim data(fi.Length - 1) As Byte
Dim fs As FileStream = New FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, data.Length, True)
' Task(Of Integer) returns the number of bytes read
Dim myTask As Task(Of Integer) = Task(Of Integer).Factory.FromAsync(
AddressOf fs.BeginRead, AddressOf fs.EndRead, data, 0, data.Length, Nothing)
' It is possible to do other work here while waiting
' for the antecedent task to complete.
' ...
' Add the continuation, which returns a Task<string>.
Return myTask.ContinueWith(Function(antecedent)
fs.Close()
If (antecedent.Result < 100) Then
Return "Data is too small to bother with."
End If
' If we did not receive the entire file, the end of the
' data buffer will contain garbage.
If (antecedent.Result < data.Length) Then
Array.Resize(data, antecedent.Result)
End If
' Will be returned in the Result property of the Task<string>
' at some future point after the asynchronous file I/O operation completes.
Return New UTF8Encoding().GetString(data)
End Function)
End Function
De methode kan vervolgens als volgt worden aangeroepen.
Task<string> t = GetFileStringAsync(path);
// Do some other work:
// ...
try
{
Console.WriteLine(t.Result.Substring(0, 500));
}
catch (AggregateException ae)
{
Console.WriteLine(ae.InnerException.Message);
}
Dim myTask As Task(Of String) = GetFileStringAsync(path)
' Do some other work
' ...
Try
Console.WriteLine(myTask.Result.Substring(0, 500))
Catch ex As AggregateException
Console.WriteLine(ex.InnerException.Message)
End Try
Aangepaste statusgegevens opgeven
In typische IAsyncResult bewerkingen, als uw AsyncCallback gemachtigde een aantal aangepaste statusgegevens vereist, moet u deze doorgeven via de laatste parameter in de Begin methode, zodat de gegevens kunnen worden verpakt in het IAsyncResult object dat uiteindelijk wordt doorgegeven aan de callback-methode. Dit is doorgaans niet vereist wanneer de FromAsync methoden worden gebruikt. Als de aangepaste gegevens bekend zijn bij de voortzetting, kunnen deze rechtstreeks in de vervolgdelegatie worden vastgelegd. Het volgende voorbeeld lijkt op het vorige voorbeeld, maar in plaats van de Result eigenschap van de antecedent te onderzoeken, onderzoekt de voortzetting de aangepaste statusgegevens die rechtstreeks toegankelijk zijn voor de gemachtigde van de gebruiker van de voortzetting.
public Task<string> GetFileStringAsync2(string path)
{
FileInfo fi = new FileInfo(path);
byte[] data = new byte[fi.Length];
MyCustomState state = GetCustomState();
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, data.Length, true);
// We still pass null for the last parameter because
// the state variable is visible to the continuation delegate.
Task<int> task = Task<int>.Factory.FromAsync(
fs.BeginRead, fs.EndRead, data, 0, data.Length, null);
return task.ContinueWith((antecedent) =>
{
// It is safe to close the filestream now.
fs.Close();
// Capture custom state data directly in the user delegate.
// No need to pass it through the FromAsync method.
if (state.StateData.Contains("New York, New York"))
{
return "Start spreading the news!";
}
else
{
// If we did not receive the entire file, the end of the
// data buffer will contain garbage.
if (antecedent.Result < data.Length)
Array.Resize(ref data, antecedent.Result);
// Will be returned in the Result property of the Task<string>
// at some future point after the asynchronous file I/O operation completes.
return new UTF8Encoding().GetString(data);
}
});
}
Public Function GetFileStringAsync2(ByVal path As String) As Task(Of String)
Dim fi = New FileInfo(path)
Dim data(fi.Length - 1) As Byte
Dim state As New MyCustomState()
Dim fs As New FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, data.Length, True)
' We still pass null for the last parameter because
' the state variable is visible to the continuation delegate.
Dim myTask As Task(Of Integer) = Task(Of Integer).Factory.FromAsync(
AddressOf fs.BeginRead, AddressOf fs.EndRead, data, 0, data.Length, Nothing)
Return myTask.ContinueWith(Function(antecedent)
fs.Close()
' Capture custom state data directly in the user delegate.
' No need to pass it through the FromAsync method.
If (state.StateData.Contains("New York, New York")) Then
Return "Start spreading the news!"
End If
' If we did not receive the entire file, the end of the
' data buffer will contain garbage.
If (antecedent.Result < data.Length) Then
Array.Resize(data, antecedent.Result)
End If
'/ Will be returned in the Result property of the Task<string>
'/ at some future point after the asynchronous file I/O operation completes.
Return New UTF8Encoding().GetString(data)
End Function)
End Function
Meerdere FromAsync-taken synchroniseren
De statische ContinueWhenAll methoden ContinueWhenAny bieden extra flexibiliteit wanneer ze worden gebruikt in combinatie met de FromAsync methoden. In het volgende voorbeeld ziet u hoe u meerdere asynchrone I/O-bewerkingen start en wacht totdat alle bewerkingen zijn voltooid voordat u de voortzetting uitvoert.
public Task<string> GetMultiFileData(string[] filesToRead)
{
FileStream fs;
Task<string>[] tasks = new Task<string>[filesToRead.Length];
byte[] fileData = null;
for (int i = 0; i < filesToRead.Length; i++)
{
fileData = new byte[0x1000];
fs = new FileStream(filesToRead[i], FileMode.Open, FileAccess.Read, FileShare.Read, fileData.Length, true);
// By adding the continuation here, the
// Result of each task will be a string.
tasks[i] = Task<int>.Factory.FromAsync(
fs.BeginRead, fs.EndRead, fileData, 0, fileData.Length, null)
.ContinueWith((antecedent) =>
{
fs.Close();
// If we did not receive the entire file, the end of the
// data buffer will contain garbage.
if (antecedent.Result < fileData.Length)
Array.Resize(ref fileData, antecedent.Result);
// Will be returned in the Result property of the Task<string>
// at some future point after the asynchronous file I/O operation completes.
return new UTF8Encoding().GetString(fileData);
});
}
// Wait for all tasks to complete.
return Task<string>.Factory.ContinueWhenAll(tasks, (data) =>
{
// Propagate all exceptions and mark all faulted tasks as observed.
Task.WaitAll(data);
// Combine the results from all tasks.
StringBuilder sb = new StringBuilder();
foreach (var t in data)
{
sb.Append(t.Result);
}
// Final result to be returned eventually on the calling thread.
return sb.ToString();
});
}
Public Function GetMultiFileData(ByVal filesToRead As String()) As Task(Of String)
Dim fs As FileStream
Dim tasks(filesToRead.Length - 1) As Task(Of String)
Dim fileData() As Byte = Nothing
For i As Integer = 0 To filesToRead.Length
fileData(&H1000) = New Byte()
fs = New FileStream(filesToRead(i), FileMode.Open, FileAccess.Read, FileShare.Read, fileData.Length, True)
' By adding the continuation here, the
' Result of each task will be a string.
tasks(i) = Task(Of Integer).Factory.FromAsync(AddressOf fs.BeginRead,
AddressOf fs.EndRead,
fileData,
0,
fileData.Length,
Nothing).
ContinueWith(Function(antecedent)
fs.Close()
'If we did not receive the entire file, the end of the
' data buffer will contain garbage.
If (antecedent.Result < fileData.Length) Then
ReDim Preserve fileData(antecedent.Result)
End If
'Will be returned in the Result property of the Task<string>
' at some future point after the asynchronous file I/O operation completes.
Return New UTF8Encoding().GetString(fileData)
End Function)
Next
Return Task(Of String).Factory.ContinueWhenAll(tasks, Function(data)
' Propagate all exceptions and mark all faulted tasks as observed.
Task.WaitAll(data)
' Combine the results from all tasks.
Dim sb As New StringBuilder()
For Each t As Task(Of String) In data
sb.Append(t.Result)
Next
' Final result to be returned eventually on the calling thread.
Return sb.ToString()
End Function)
End Function
FromAsync-taken voor alleen de end-methode
Voor sommige gevallen waarin voor de Begin methode meer dan drie invoerparameters zijn vereist of waarin ref parameters out zijn vereist, kunt u bijvoorbeeld de FromAsync overbelastingen gebruiken die alleen de End methode vertegenwoordigenTaskFactory<TResult>.FromAsync(IAsyncResult, Func<IAsyncResult,TResult>). Deze methoden kunnen ook worden gebruikt in elk scenario waarin u een IAsyncResult wordt doorgegeven en deze in een taak wilt inkapselen.
static Task<String> ReturnTaskFromAsyncResult()
{
IAsyncResult ar = DoSomethingAsynchronously();
Task<String> t = Task<string>.Factory.FromAsync(ar, _ =>
{
return (string)ar.AsyncState;
});
return t;
}
Shared Function ReturnTaskFromAsyncResult() As Task(Of String)
Dim ar As IAsyncResult = DoSomethingAsynchronously()
Dim t As Task(Of String) = Task(Of String).Factory.FromAsync(ar, Function(res) CStr(res.AsyncState))
Return t
End Function
FromAsync-taken starten en annuleren
De taak die door een FromAsync methode wordt geretourneerd, heeft de status en WaitingForActivation wordt op een bepaald moment door het systeem gestart nadat de taak is gemaakt. Als u start probeert aan te roepen voor een dergelijke taak, wordt er een uitzondering gegenereerd.
U kunt een FromAsync taak niet annuleren omdat de onderliggende .NET-API's momenteel geen ondersteuning bieden voor het annuleren van bestanden of netwerk-I/O. U kunt annuleringsfunctionaliteit toevoegen aan een methode waarmee een FromAsync aanroep wordt ingekapseld, maar u kunt alleen reageren op de annulering voordat FromAsync deze is aangeroepen of nadat deze is voltooid (bijvoorbeeld in een vervolgtaak).
Sommige klassen die ondersteuning bieden voor EAP, WebClientondersteunen bijvoorbeeld annulering en u kunt die systeemeigen annuleringsfunctionaliteit integreren met behulp van annuleringstokens.
Complexe EAP-bewerkingen beschikbaar maken als taken
De TPL biedt geen methoden die specifiek zijn ontworpen om een asynchrone bewerking op basis van gebeurtenissen in te kapselen op dezelfde manier als de FromAsync reeks methoden het IAsyncResult patroon verpakken. De TPL biedt echter wel de System.Threading.Tasks.TaskCompletionSource<TResult> klasse, die kan worden gebruikt om elke willekeurige set bewerkingen als een Task<TResult>. De bewerkingen kunnen synchroon of asynchroon zijn en zijn mogelijk I/O-afhankelijk of rekengebonden, of beide.
In het volgende voorbeeld ziet u hoe u een TaskCompletionSource<TResult> set asynchrone bewerkingen WebClient beschikbaar maakt voor clientcode als basis Task<TResult>. Met de methode kunt u een matrix met web-URL's en een term of naam invoeren waarnaar moet worden gezocht. Vervolgens wordt het aantal keren geretourneerd dat de zoekterm op elke site voorkomt.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
public class SimpleWebExample
{
public Task<string[]> GetWordCountsSimplified(string[] urls, string name,
CancellationToken token)
{
TaskCompletionSource<string[]> tcs = new TaskCompletionSource<string[]>();
WebClient[] webClients = new WebClient[urls.Length];
object m_lock = new object();
int count = 0;
List<string> results = new List<string>();
// If the user cancels the CancellationToken, then we can use the
// WebClient's ability to cancel its own async operations.
token.Register(() =>
{
foreach (var wc in webClients)
{
if (wc != null)
wc.CancelAsync();
}
});
for (int i = 0; i < urls.Length; i++)
{
webClients[i] = new WebClient();
#region callback
// Specify the callback for the DownloadStringCompleted
// event that will be raised by this WebClient instance.
webClients[i].DownloadStringCompleted += (obj, args) =>
{
// Argument validation and exception handling omitted for brevity.
// Split the string into an array of words,
// then count the number of elements that match
// the search term.
string[] words = args.Result.Split(' ');
string NAME = name.ToUpper();
int nameCount = (from word in words.AsParallel()
where word.ToUpper().Contains(NAME)
select word)
.Count();
// Associate the results with the url, and add new string to the array that
// the underlying Task object will return in its Result property.
lock (m_lock)
{
results.Add(String.Format("{0} has {1} instances of {2}", args.UserState, nameCount, name));
// If this is the last async operation to complete,
// then set the Result property on the underlying Task.
count++;
if (count == urls.Length)
{
tcs.TrySetResult(results.ToArray());
}
}
};
#endregion
// Call DownloadStringAsync for each URL.
Uri address = null;
address = new Uri(urls[i]);
webClients[i].DownloadStringAsync(address, address);
} // end for
// Return the underlying Task. The client code
// waits on the Result property, and handles exceptions
// in the try-catch block there.
return tcs.Task;
}
}
Imports System.Collections.Generic
Imports System.Net
Imports System.Threading
Imports System.Threading.Tasks
Public Class SimpleWebExample
Dim tcs As New TaskCompletionSource(Of String())
Dim token As CancellationToken
Dim results As New List(Of String)
Dim m_lock As New Object()
Dim count As Integer
Dim addresses() As String
Dim nameToSearch As String
Public Function GetWordCountsSimplified(ByVal urls() As String, ByVal str As String,
ByVal token As CancellationToken) As Task(Of String())
addresses = urls
nameToSearch = str
Dim webClients(urls.Length - 1) As WebClient
' If the user cancels the CancellationToken, then we can use the
' WebClient's ability to cancel its own async operations.
token.Register(Sub()
For Each wc As WebClient In webClients
If wc IsNot Nothing Then
wc.CancelAsync()
End If
Next
End Sub)
For i As Integer = 0 To urls.Length - 1
webClients(i) = New WebClient()
' Specify the callback for the DownloadStringCompleted
' event that will be raised by this WebClient instance.
AddHandler webClients(i).DownloadStringCompleted, AddressOf WebEventHandler
Dim address As New Uri(urls(i))
' Pass the address, and also use it for the userToken
' to identify the page when the delegate is invoked.
webClients(i).DownloadStringAsync(address, address)
Next
' Return the underlying Task. The client code
' waits on the Result property, and handles exceptions
' in the try-catch block there.
Return tcs.Task
End Function
Public Sub WebEventHandler(ByVal sender As Object, ByVal args As DownloadStringCompletedEventArgs)
If args.Cancelled = True Then
tcs.TrySetCanceled()
Return
ElseIf args.Error IsNot Nothing Then
tcs.TrySetException(args.Error)
Return
Else
' Split the string into an array of words,
' then count the number of elements that match
' the search term.
Dim words() As String = args.Result.Split(" "c)
Dim name As String = nameToSearch.ToUpper()
Dim nameCount = (From word In words.AsParallel()
Where word.ToUpper().Contains(name)
Select word).Count()
' Associate the results with the url, and add new string to the array that
' the underlying Task object will return in its Result property.
SyncLock (m_lock)
results.Add(String.Format("{0} has {1} instances of {2}", args.UserState, nameCount, nameToSearch))
count = count + 1
If (count = addresses.Length) Then
tcs.TrySetResult(results.ToArray())
End If
End SyncLock
End If
End Sub
End Class
Zie EAP-patronen verpakken in een taak voor een volledig voorbeeld, waaronder aanvullende afhandeling van uitzonderingen en laat zien hoe u de methode aanroept vanuit clientcode.
Houd er rekening mee dat elke taak die door een TaskCompletionSource<TResult> taak wordt gemaakt, hiermee wordt gestart TaskCompletionSource . Daarom mag de gebruikerscode de Start methode voor die taak niet aanroepen.
Het APM-patroon implementeren met behulp van taken
In sommige scenario's kan het wenselijk zijn om het IAsyncResult patroon rechtstreeks beschikbaar te maken met behulp van begin-/eindmethodeparen in een API. U kunt bijvoorbeeld consistentie onderhouden met bestaande API's of u hebt mogelijk geautomatiseerde hulpprogramma's waarvoor dit patroon is vereist. In dergelijke gevallen kunt u objecten gebruiken Task om te vereenvoudigen hoe het APM-patroon intern wordt geïmplementeerd.
In het volgende voorbeeld ziet u hoe u taken gebruikt voor het implementeren van een APM begin-/eindmethodepaar voor een langlopende rekenmethode.
class Calculator
{
public IAsyncResult BeginCalculate(int decimalPlaces, AsyncCallback ac, object state)
{
Console.WriteLine("Calling BeginCalculate on thread {0}", Thread.CurrentThread.ManagedThreadId);
Task<string> f = Task<string>.Factory.StartNew(_ => Compute(decimalPlaces), state);
if (ac != null) f.ContinueWith((res) => ac(f));
return f;
}
public string Compute(int numPlaces)
{
Console.WriteLine("Calling compute on thread {0}", Thread.CurrentThread.ManagedThreadId);
// Simulating some heavy work.
Thread.SpinWait(500000000);
// Actual implementation left as exercise for the reader.
// Several examples are available on the Web.
return "3.14159265358979323846264338327950288";
}
public string EndCalculate(IAsyncResult ar)
{
Console.WriteLine("Calling EndCalculate on thread {0}", Thread.CurrentThread.ManagedThreadId);
return ((Task<string>)ar).Result;
}
}
public class CalculatorClient
{
static int decimalPlaces = 12;
public static void Main()
{
Calculator calc = new Calculator();
int places = 35;
AsyncCallback callBack = new AsyncCallback(PrintResult);
IAsyncResult ar = calc.BeginCalculate(places, callBack, calc);
// Do some work on this thread while the calculator is busy.
Console.WriteLine("Working...");
Thread.SpinWait(500000);
Console.ReadLine();
}
public static void PrintResult(IAsyncResult result)
{
Calculator c = (Calculator)result.AsyncState;
string piString = c.EndCalculate(result);
Console.WriteLine("Calling PrintResult on thread {0}; result = {1}",
Thread.CurrentThread.ManagedThreadId, piString);
}
}
Class Calculator
Public Function BeginCalculate(ByVal decimalPlaces As Integer, ByVal ac As AsyncCallback, ByVal state As Object) As IAsyncResult
Console.WriteLine("Calling BeginCalculate on thread {0}", Thread.CurrentThread.ManagedThreadId)
Dim myTask = Task(Of String).Factory.StartNew(Function(obj) Compute(decimalPlaces), state)
myTask.ContinueWith(Sub(antecedent) ac(myTask))
End Function
Private Function Compute(ByVal decimalPlaces As Integer)
Console.WriteLine("Calling compute on thread {0}", Thread.CurrentThread.ManagedThreadId)
' Simulating some heavy work.
Thread.SpinWait(500000000)
' Actual implementation left as exercise for the reader.
' Several examples are available on the Web.
Return "3.14159265358979323846264338327950288"
End Function
Public Function EndCalculate(ByVal ar As IAsyncResult) As String
Console.WriteLine("Calling EndCalculate on thread {0}", Thread.CurrentThread.ManagedThreadId)
Return CType(ar, Task(Of String)).Result
End Function
End Class
Class CalculatorClient
Shared decimalPlaces As Integer
Shared Sub Main()
Dim calc As New Calculator
Dim places As Integer = 35
Dim callback As New AsyncCallback(AddressOf PrintResult)
Dim ar As IAsyncResult = calc.BeginCalculate(places, callback, calc)
' Do some work on this thread while the calculator is busy.
Console.WriteLine("Working...")
Thread.SpinWait(500000)
Console.ReadLine()
End Sub
Public Shared Sub PrintResult(ByVal result As IAsyncResult)
Dim c As Calculator = CType(result.AsyncState, Calculator)
Dim piString As String = c.EndCalculate(result)
Console.WriteLine("Calling PrintResult on thread {0}; result = {1}",
Thread.CurrentThread.ManagedThreadId, piString)
End Sub
End Class
De StreamExtensions-voorbeeldcode gebruiken
Het StreamExtensions.cs-bestand , in de opslagplaats voor parallelle uitbreidingen van .NET Standard, bevat verschillende referentie-implementaties die Task gebruikmaken van objecten voor asynchrone bestands- en netwerk-I/O.
