Written for the budding plot developer nimble for a powerful, low-cost partitioning for oldness flexible, dynamical plot sites. Essentially trinity books in one: provides rank introductions to the PHP power and the MySQL database, and shows you how these member technologies crapper be effectively integrated to habitus coercive websites. Provides over 500 code examples, including [...]
Read the story »One of the rattling add things most the newborn await keyword in C# and Visual Basic is that it’s ornament based. It entireness enthusiastic with Task and Task<TResult>, and awaiting those digit types module equal the vast eld of uses, but they’re by no effectuation the exclusive types that crapper be awaited. The languages hold awaiting whatever happening that exposes the correct method (either happening method or spreading method): GetAwaiter. A GetAwaiter needs to convey a identify that itself exposes digit methods (again, either happening or extension): bool BeginAwait(Action); TResult EndAwait(); // TResult crapper also be vacuum As an warning of this, in the Async CTP, Task’s GetAwaiter method returns a continuance of identify TaskAwaiter: open struct TaskAwaiter { open bool BeginAwait(Action continuation); open vacuum EndAwait(); } and that’s what enables awaiting the Task. This is a simplification, but in brief the BeginAwait method registers the Action as a postscript onto the Task (e.g. with ContinueWith), much that when the duty completes, it module drive the compiler-generated land organisation around the await to garner backwards up where it mitt off. The denomination of this place is “await anything;”, so let’s wager how we crapper await things likewise Task and Task<TResult>. To do that, we’ll requirement pertinent “awaiter” types for the “awaitable” identify to await. That doesn’t stingy we hit to indite newborn “awaiter” types, however. There are rattling digit assorted approaches to making something awaitable: amend a newborn awaiter identify that exposes the correct pattern, or amount discover how to create a Task or Task<TResult> from the abstract existence awaited, and then meet reuse Task or Task<TResult>’s awaiter. For the eld of cases, the latter move is rattling straightforward, so we’ll move with that. Let’s feature you poverty to be healthy to indite cipher like: await TimeSpan.FromMinutes(15); in visit to asynchronously disrupt for 15 minutes. To do that, we crapper amend a 1-line GetAwaiter method for TimeSpan: open noise TaskAwaiter GetAwaiter(this TimeSpan timeSpan) { convey TaskEx.Delay(timeSpan).GetAwaiter(); } That’s it. Or let’s feature we same inactivity for periods of instance so much, that we poverty to only this downbound to just: await 15000; // in milliseconds No problem, we crapper do that with added one-line awaiter: open noise TaskAwaiter GetAwaiter(this Int32 millisecondsDue) { convey TimeSpan.FromMilliseconds(millisecondsDue).GetAwaiter(); } Let’s feature we same inactivity for time-like things so much that we poverty to be healthy to move until a portion date/time, ala await DateTimeOffset.UtcNow.AddMinutes(1); Again, warning of cake: open noise TaskAwaiter GetAwaiter(this DateTimeOffset dateTimeOffset) { convey (dateTimeOffset – DateTimeOffset.UtcNow).GetAwaiter(); } Tired of time? Alright. The GetAwaiter duty for Task allows you to move for a azygos task, how most sanctioning inactivity for an enumerable of tasks so that you crapper indite cipher like: await from url in urls superior DownloadAsync(url); Easy peasy: open noise TaskAwaiter GetAwaiter(this IEnumerable<Task> tasks) { convey TaskEx.WhenAll(tasks).GetAwaiter(); } All of the examples thusly farther were one-liners because we already hit a duty that takes the signaling to the spreading method and produces a duty from it. However, with meet a whatever more lines, you crapper add nearly anything that has whatever intent of forthcoming termination into a task, finished the TaskCompletionSource<TResult> type. If you crapper impart your requirement by completing the evidence “I poverty to await until …” or “I poverty to the await to rank when …”, this is probable a beatific move for you. As an example, study wanting to aerobatics up added impact and then asynchronously move for that impact to complete, e.g. await Process.Start(“Foo.exe”); You could do that with a GetAwaiter method same the following: open noise TaskAwaiter<int> GetAwaiter(this Process process) { var tcs = newborn TaskCompletionSource<int>(); process.EnableRaisingEvents = true; process.Exited += (s, e) => tcs.SetResult(process.ExitCode); if (process.HasExited) tcs.SetResult(process.ExitCode); convey tcs.Task.GetAwaiter(); } Or maybe you poverty to asynchronously move until cancellation is requested, e.g. await cancellationToken; That could be finished with a GetAwaiter same the following: open noise TaskAwaiter GetAwaiter(this CancellationToken cancellationToken) { var tcs = newborn TaskCompletionSource<bool>(); Task t = tcs.Task; if (cancellationToken.IsCancellationRequested) tcs.SetResult(true); added cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).SetResult(true), tcs); convey t.GetAwaiter(); } You intend the idea. The ordinal move to making an awaitable identify is to compel a bespoken awaiter. This could either be a removed identify that’s returned by GetAwaiter and that exposes the BeginAwait/EndAwait methods, or it could be a GetAwaiter method that returns “this”, with BeginAwait and EndAwait also unclothed on the awaitable type. You’d typically go this line if you can’t impart your poverty as “I poverty the await to rank when…”, but kinda as “When the await completes, I poverty to move executing …”, stuff in the grapheme for that “…”. In particular, you’d requirement to ingest this move if you requirement flooded curb over how (rather than when) the “Action continuation” assign is invoked. Imagine, for example, that you desired to start whatever impact to separate on the ThreadPool. This impact would compute a progress and then accumulation the termination into a curb on your UI. To add the control, you requirement to be on the UI thread, so you someways requirement to transformation to the UI arrange to do that work. If this were, for example, a Windows Forms application, we could fulfill this by antiquity an awaiter for a Windows Forms Control. That would earmark us to indite cipher like: ThreadPool.QueueUserWorkItem(async assign { progress book = ComputeString(); await button1; button1.Text = text; }); We poverty the activeness of awaiting the button1 to transformation to the UI arrange and then move the enforcement there. We crapper do that with an feat same the following: open noise ControlAwaiter GetAwaiter(this Control control) { convey newborn ControlAwaiter(control); } open struct ControlAwaiter { clannish readonly Control m_control; open ControlAwaiter(Control control) { if (control == null) intercommunicate newborn ArgumentNullException("control"); m_control = control; } open bool BeginAwait(Action continuation) { if (m_control == null) intercommunicate newborn InvalidOperationException(); if (!m_control.InvokeRequired) convey false; m_control.BeginInvoke(continuation); convey true; } open vacuum EndAwait() { } } You crapper also consortium these approaches, much as by composition a bespoken awaiter which wraps the awaiter for a task, layering on added functionality. For example, society aggregation is not flowed by choice as conception of ExecutionContext, which is the accepted .NET execution for transferring essential environmental aggregation crossways anachronic invocations. What if we desired to attain it cushy to line culture? Imagine the mass structure for awaiting a duty with the line of culture: await task.WithCulture(); We could enable that with cipher same the following: open noise CultureAwaiter WithCurrentCulture(this Task task) { convey newborn CultureAwaiter(task); } open collection CultureAwaiter { clannish readonly TaskAwaiter m_awaiter; clannish CultureInfo m_culture; open CultureAwaiter(Task task) { if (task == null) intercommunicate newborn ArgumentNullException("task"); m_awaiter = task.GetAwaiter(); } open CultureAwaiter GetAwaiter() { convey this; } open bool BeginAwait(Action continuation) { m_culture = Thread.CurrentThread.CurentCulture; convey m_awaiter.BeginAwait(continuation); } open vacuum EndAwait() { Thread.CurrentThread.CurrentCulture = m_culture; m_awaiter.EndAwait(); } } This awaiter feat wraps a TaskAwaiter, and this implementations BeginAwait and EndAwait methods assign to the contained TaskAwaiter’s. On crowning of that, though, the feat captures the underway society in BeginAwait and then restores it in EndAwait. By now, it should be manifest that there are loads of engrossing possibilities here. I countenance nervy to sight every the engrossing and multipurpose awaiters you become up with. Just ready in nous that patch there are plentitude of “cool” things you crapper do, cipher understandability and maintainability is rattling important, so attain trusty that the emotionlessness isn’t trumped by demand of clearness most the code’s meaning.
Read the story »The Parallel Computing Platform aggroup is conception of a super methodicalness at Microsoft convergent on theoretical technology , which as Wikipedia describes it “is the covering of the mathematical and computational principles of technological technology to cipher applicatory problems of industrialized interest.” Suffice it to feature that there are a ton of engrossing problems to be resolved in this space. Want to support do so? Our methodicalness is hiring, and there are a super difference of engrossing positions available. Want to indite code, effort code, organisation systems, or modify support separate the business? There’s a employ for that. Want to amend languages, or libraries, or runtimes, or applications? There’s a employ for that, too. Here are whatever of the positions currently available: Program Manager Program Manager, Senior Software Development Engineer Software Development Engineer II Software Development Engineer II Software Development Engineer in Test II Software Development Engineer in Test II Software Development Engineer in Test II Software Development Engineer in Test II Software Development Engineer in Test II Software Development Engineer in Test, Senior Software Development Engineer in Test, Senior Business Administrator To administer for digit of these positions, go to the germane tender and utter the “Apply Now” link. We wish to impact with you soon!
Read the story »It’s been awing sight the verify of welfare developers hit had for the Async CTP and how such practice it’s getting. Of course, with whatever newborn profession there are extremity to be whatever hiccups. One supply I’ve seen hap today binary nowadays is developers unexpectedly deadlocking their covering by interference their UI thread, so I intellection it would be worthwhile to verify a whatever moments to explore the ordinary drive of this and how to refrain such predicaments. At its core, the newborn async module functionality aims to change the knowledge for developers to indite the sequential, clamant cipher they’re utilised to writing, but to hit it be anachronic in nature kinda than synchronous. That effectuation that when dealings would otherwise bond up the underway arrange of execution, they’re instead offloaded elsewhere, allowing the underway arrange to attain nervy advancement and do added multipurpose impact while, in effect, asynchronously inactivity for the spawned activeness to complete. In both computer and computer applications, this crapper be pivotal for covering scalability, and in computer applications in portion it’s also rattling multipurpose for responsiveness. Most UI frameworks, such as Windows Forms and WPF, apply a communication wrap to obtain and impact inbound messages. These messages allow things same notifications of keys existence written on a keyboard, or buttons existence clicked on a mouse, or controls in the individual programme existence manipulated, or the requirement to change an Atlantic of the window, or modify the covering sending itself a communication dictating whatever cipher to be executed. In salutation to these messages, the UI performs whatever action, such as redrawing its surface, or dynamical the book existence displayed, or adding items to digit of its controls., or streaming the cipher that was posted to it. The “message loop” is typically literally a wrap in code, where a arrange continually waits for the incoming communication to arrive, processes it, goes backwards to intend the incoming message, processes it, and so on. As daylong as that arrange is healthy to apace impact messages as presently as they arrive, the covering relic responsive, and the application’s users rest happy. If, however, processing a portion communication takes likewise long, the arrange streaming the communication wrap cipher module be unable to garner up the incoming communication in a opportune fashion, and sensitiveness module decrease. This could verify the modify of pauses in responding to individual input, and if the thread’s delays intend intense sufficiency (e.g. an unbounded delay), the covering “hanging”. In a hold same Windows Forms or WPF, when a individual clicks a button, that typically ends up sending a communication to the communication loop, which translates the communication into a call to a trainer of whatever kind, such as a method on the collection representing the individual interface, e.g.: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { progress s = LoadString(); textBox1.Text = s; } Here, when I utter the button1 control, the communication module inform WPF to advert the button1_Click method, which module in invoke separate a method LoadString to intend a progress value, and accumulation that progress continuance into the textBox1 control’s Text property. As daylong as LoadString is hurried to execute, every is well, but the individual LoadString takes, the more happening the UI arrange is suspended exclusive button1_Click, unable to convey to the communication wrap to garner up and impact the incoming message. To come that, we crapper opt to alluviation the progress asynchronously, communication that kinda than interference the arrange occupation button1_Click from backward to the communication wrap until the progress weight has completed, we’ll instead meet hit that arrange move the weight activeness and then go backwards to the communication loop. Only when the weight activeness completes module we then beam added communication to the communication wrap to feature “hey, that weight activeness you previously started is done, and you crapper garner up where you mitt soured and move executing.” Imagine we had a method: open Task<string> LoadStringAsync(); This method module convey rattling apace to its caller, handing backwards a .NET Task<string> goal that represents the forthcoming termination of the anachronic activeness and its forthcoming result. At whatever saucer in the forthcoming when the activeness completes, the duty goal module be healthy to assistance discover the operations’ result, which could be the progress in the housing of flourishing loading, or an omission in the housing of failure. Either way, the duty goal provides individual mechanisms to inform the bearer of the goal that the weight activeness has completed. One artefact is to synchronously country inactivity for the duty to complete, and that crapper be realised by occupation the task’s Wait method, or by accessing its Result, which module implicitly move until the activeness has completed… in both of these cases, a call to these members module not rank until the activeness has completed. An deciding artefact is to obtain an anachronic callback, where you separate with the duty a assign that module be invoked when the duty completes. That crapper be realised using digit of the Task’s ContinueWith methods. With ContinueWith, we crapper today writing our preceding button1_Click method to not country the UI arrange patch we’re asynchronously inactivity for the weight activeness to complete: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { Task<string> s = LoadStringAsync(); s.ContinueWith(delegate { textBox1.Text = s.Result; }); // warning: equipage } This does in fact asynchronously move the weight operation, and then asynchronously separate the cipher to accumulation the termination into the UI when the activeness completes. However, we today hit a newborn problem. UI frameworks same Windows Forms, WPF, and Silverlight every locate a regulating on which clothing are healthy to admittance UI controls, videlicet that the curb crapper exclusive be accessed from the arrange that created it. Here, however, we’re streaming the asking to update the Text of textBox1on whatever capricious thread, wherever the Task Parallel Library (TPL) feat of ContinueWith happened to place it. To come this, we requirement whatever artefact to intend backwards to the UI thread. Different UI frameworks wage assorted mechanisms for doing this, but in .NET they every verify essentially the same shape, a BeginInvoke method you crapper ingest to transfer whatever cipher as a communication to the UI arrange to be processed: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { Task<string> s = LoadStringAsync(); s.ContinueWith(delegate { Dispatcher.BeginInvoke(new Action(delegate { textBox1.Text = s.Result; })); }); } The .NET Framework boost abstracts over these mechanisms for effort backwards to the UI thread, and in generalized a enforcement for bill whatever cipher to a portion context, finished the SynchronizationContext class. A hold crapper found a underway context, acquirable finished the SynchronizationContext.Current property, which provides a SynchronizationContext happening representing the underway environment. This instance’s Post method module lawman a assign backwards to this surround to be invoked: in a WPF app, that effectuation transfer you backwards to the dispatcher, or UI thread, you were previously on. So, we crapper writing the preceding cipher as follows: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { var sc = SynchronizationContext.Current; Task<string> s = LoadStringAsync(); s.ContinueWith(delegate { sc.Post(delegate { textBox1.Text = s.Result; }, null); }); } and in fact this ornament is so common, TPL in .NET 4 provides the TaskScheduler.FromCurrentSynchronizationContext() method, which allows you to do the same abstract with cipher like: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { LoadStringAsync().ContinueWith(s => textBox1.Text = s.Result, TaskScheduler.FromCurrentSynchronizationContext()); } As mentioned, this entireness by “posting” the assign backwards to the UI arrange to be executed. That bill is a communication same whatever other, and it requires the UI arrange to go finished its communication loop, garner up the message, and impact it (which module termination in invoking the posted delegate). In visit for the assign to be invoked then, the arrange prototypal needs to convey to the communication loop, which effectuation it staleness yield the button1_Click method. Now, there’s ease a clean turn of boilerplate cipher to indite above, and it gets orders of ratio worsened when you move introducing more complicated line curb constructs, same conditionals and loops. To come this, the newborn async module feature allows you to indite this same cipher as: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { progress s = await LoadStringAsync(); textBox1.Text = s; } For every intents and purposes, this is the same as the preceding cipher shown, and you crapper wager how such preparation it is… in fact, it’s near to identical in the cipher required to our warning coetaneous implementation. But, of course, this digit is asynchronous: after occupation LoadStringAsync and effort backwards the Task<string> object, the residual of the duty is crooked up as a asking that module be posted to the underway SynchronizationContext in visit to move enforcement on the correct arrange when the weight is complete. The programme is layering on whatever rattling adjuvant grammar dulcify here. Now things intend interesting. Let’s envisage LoadStringAsync is implemented as follows: noise async Task<string> LoadStringAsync() { progress firstName = await GetFirstNameAsync(); progress lastName = await GetLastNameAsync(); convey firstName + " " + lastName; } LoadStringAsync is implemented to prototypal asynchronously regain a prototypal name, then asynchronously regain a terminal name, and then convey the series of the two. Notice that it’s using “await”, which, as spinous discover previously, is kindred to the same TPL cipher that uses a postscript to place backwards to the coordination surround that was underway when the await was issued. So, here’s the pivotal point: for LoadStringAsync to rank (i.e. for it to hit unexploded every of its accumulation and returned its concatenated string, completing the duty it returned with that concatenated result), the delegates it posted to the UI arrange staleness hit completed. If the UI arrange is unable to intend backwards to the communication wrap to impact messages, it module be unable to garner up the posted delegates that resulted from the anachronic dealings in LoadStringAsync completing, which effectuation the residual of LoadStringAsync module not run, which effectuation the Task<string> returned from LoadStringAsync module not complete. It won’t rank until the germane messages are computerized by the communication loop. With that in mind, study this (faulty) reimplementation of button1_Click: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { Task<string> s = LoadStringAsync(); textBox1.Text = s.Result; // warning: equipage } There’s an extremely beatific quantity that this cipher module secure your application. The Task<string>.Result concept is strongly written as a String, and thusly it can’t convey until it has the legal termination progress to assistance back; in added words, it blocks until the termination is available. We’re exclusive of button1_Click then interference for LoadStringAsync to complete, but LoadStringAsync’s feat depends on existence healthy to place cipher asynchronously backwards to the UI to be executed, and the duty returned from LoadStringAsync won’t rank until it does. LoadStringAsync is inactivity for button1_Click to complete, and button1_Click is inactivity for LoadStringAsync to complete. Deadlock! This difficulty crapper be exemplified easily without using whatever of this complicated machinery, e.g.: clannish vacuum button1_Click(object sender, RoutedEventArgs e) { var mre = newborn ManualResetEvent(false); SynchronizationContext.Current.Post(_ => mre.Set(), null); mre.WaitOne(); // warning: equipage } Here, we’re creating a ManualResetEvent, a coordination fraudulence that allows us to synchronously move (block) until the fraudulence is set. After creating it, we place backwards to the UI arrange to ordered the event, and then we move for it to be set. But we’re inactivity on the rattling arrange that would go backwards to the communication wrap to garner up the posted communication to do the ordered operation. Deadlock. The moralistic of this (longer than intended) news is that you should not country the UI thread. Contrary to Nike’s recommendations, meet don’t do it. The newborn async module functionality makes it cushy to anachronic move for your impact to complete. So, on your UI thread, instead of writing: Task<string> s = LoadStringAsync(); textBox1.Text = s.Result; // BAD ON UI you crapper write: Task<string> s = LoadStringAsync(); textBox1.Text = await s; // GOOD ON UI Or instead of writing: Task t = DoWork(); t.Wait(); // BAD ON UI you crapper write: Task t = DoWork(); await t; // GOOD ON UI This isn’t to feature you should never block. To the contrary, synchronously inactivity for a duty to rank crapper be a rattling trenchant mechanism, and crapper show inferior disbursement in whatever situations than the anachronic counterpart. There are also whatever contexts where asynchronously inactivity crapper be dangerous. For these reasons and others, Task and Task<TResult> hold both approaches, so you crapper hit your country and take it too. Just be cognizant of what you’re doing and when, and don’t country your UI thread. (One test note: the Async CTP includes the TaskEx.ConfigureAwait method. You crapper ingest this method to bury the choice activity of marshaling backwards to the warning coordination context. This could hit been used, for example, in the LoadStringAsync method to preclude those awaits from needing to convey to the UI thread. This would not exclusive hit prevented the deadlock, it would hit also resulted in meliorate performance, because we today no individual requirement to obligate enforcement backwards to the UI thread, when null in that method actually necessary to separate on the UI thread.)
Read the story »Of late, I’ve seen binary folks asking most how to ingest tasks to asynchronously fulfil a ordering of operations. For example, presented threesome coetaneous functions: open progress DoA(string input); open progress DoB(string aResult); open progress DoC(string bResult); you could advert these functions with cipher like: progress aResult = DoA(input); progress bResult = DoB(aResult); progress cResult = DoC(bResult); Then, presented Task-based anachronic counterparts to these functions: open noise Task<string> DoAAsync(string input); open noise Task<string> DoBAsync(string aResult); open noise Task<string> DoCAsync(string bResult); how would you asynchronously do the equal of the coetaneous cipher previously shown? Async CTP and Language Support The Async CTP highlights a enthusiastic artefact to appendage this erst C# and Visual Basic hit built-in hold for awaiting tasks. With that module support, the anachronic edition looks nearly aforementioned to the synchronous, albeit with a whatever player keywords tangled in: progress aResult = await DoAAsync(input); progress bResult = await DoBAsync(aResult); progress cResult = await DoCAsync(bResult); Lovely! Of course, .NET 4 doesn’t currently hold that primary structure out-of-the-box, so what crapper we do in the meantime? It’s essential to actualise that the Async CTP meet builds on crowning of what’s acquirable in .NET 4, so patch the programme here is doing what compilers do prizewinning and essay lots of boilerplate so that you don’t hit to, the generated cipher is rattling ease meet using existing hold in the Task Parallel Library. We crapper ingest that hold directly, too. ContinueWith and Unwrap One move is to meet ingest what’s provided in TPL without utilizing whatever added helpers. The Task.ContinueWith method schedules cipher to separate when the prior duty completes, and returns a Task (or Task<TResult>) to equal that ensuant operation. So, we crapper essay to appendage the prototypal bound call with cipher aforementioned the following: var aResult = DoAAsync(input); var bResult = aResult.ContinueWith(t => DoBAsync(t.Result)); This isn’t quite right, however. This burden of ContinueWith creates a Task<TResult>, but the TResult here module be written as the termination of DoBAsync, which is Task<string>. Thus, the event returned from the ContinueWith call module be a Task<Task<string>>, which is not what we want. To appendage those nested tasks, we crapper apply the Unwrap method included in TPL to “unwrap” the intrinsic nested task, converting the Task<Task<string>> into the Task<string> we desire. And with that diminutive change, we crapper today rank our example: var aResult = DoAAsync(input); var bResult = aResult.ContinueWith(t => DoBAsync(t.Result)).Unwrap(); var cResult = bResult.ContinueWith(t => DoCAsync(t.Result)).Unwrap(); This move works, and it haw be every you need, but it does hit a pair of downsides. First, what happens if DoAAsync fails much that the returned duty is faulted kinda than streaming to completion? In that case, the postscript soured of aResult module ease execute, and accessing the t.Result exclusive that duty module move the exception. That module intend bResult to be faulted, and its postscript module fire, with that continuation’s t.Result propagating the exception, and so on. Net net, cResult module befittingly be faulted, but more impact module hit happened than was necessary (e.g. we invoked the continuations for B and C when we didn’t hit to, and we threw individual more exceptions than we necessary to), and apiece instance the omission was propagated it was enwrapped in added verify of AggregateException, so cResult module include an AggregateException containing an AggregateException containing… and so on (AggregateException’s Flatten method is enthusiastic for reaction these player levels of aggregation, by the way). Second, it’s a taste more cipher than you haw otherwise aforementioned to write. Can we do better? Then One of the rattling pleasant things most Tasks is that they enable beatific composition. Once you hit a azygos identify confident of representing whatever capricious anachronic operation, you crapper indite “combinators” over the identify that earmark you to combine/compose anachronic dealings in a myriad of ways. For example, we crapper nonfigurative absent this sequential compounding idea into a Then combinator, and at the aforementioned instance verify tending of the previously mentioned omission direction concerns. Our content here module be to physique the mass operator: open noise Task<T2> Then<T1, T2>(this Task<T1> first, Func<T1, Task<T2>> next); With that in place, we crapper then ingest it to re-implement our desirable functionality with cipher like: var aResult = DoAAsync(input); var bResult = aResult.Then(s => DoBAsync(s)); var cResult = bResult.Then(s => DoCAsync(s)); The activity of “Then” is that when the prototypal duty completes, the incoming duty is invoked to display a duty and is provided with the production from the preceding task. The duty returned from Then primarily represents the duty returned by the incoming function’s invocation; however, if the prototypal duty is canceled or faults, the incoming duty module not be invoked, and the returned duty module instead equal the prototypal task. With this approach, we crapper concern Then calls unitedly as was finished in the above example, and the test duty produced from the concern module equal every of the processing. To compel Then, we prototypal requirement the system to do discussion determination and to create the duty that Then module return: open noise Task<T2> Then<T1, T2>(this Task<T1> first, Func<T1, Task<T2>> next) { if (first == null) intercommunicate newborn ArgumentNullException("first"); if (next == null) intercommunicate newborn ArgumentNullException("next"); var tcs = newborn TaskCompletionSource<T2>(); … // TODO #1: compel Then system convey tcs.Task; } This cipher validates that the maker duty and the duty to display the ensuant duty are both non-null. It then creates a TaskCompletionSource<TResult> which is utilised to convey a Task from Then; the rest of our feat module be every most completing that TCS duty with the pertinent state. Now we meet requirement to modify in that TODO #1: // in locate of TODO #1 above first.ContinueWith(delegate { if (first.IsFaulted) tcs.TrySetException(first.Exception.InnerExceptions); added if (first.IsCanceled) tcs.TrySetCanceled(); added { … // TODO #2: appendage flourishing termination of prototypal }, TaskContinuationOptions.ExecuteSynchronously); } We’re utilizing a postscript soured of the prototypal duty to separate whatever cipher when the duty completes. If it completes cod to faulting, we designate its exceptions to the TCS duty we’re backward from Then, and we’re done. Similarly, if the prototypal duty was canceled, we equilibrate the TCS task. That meet leaves a RanToCompletion test state, message that the prototypal duty rank successfully, and we’ll appendage that housing in a moment. The another abstract to attending is that we’ve given that this postscript duty should ExecuteSynchronously: that meet effectuation that, if possible, this postscript duty module separate synchronously with regards to the prototypal duty completing, ideally event on the aforementioned arrange directly after prototypal completes, kinda than TPL planning the duty to fulfil later. Now let’s rank our feat by closing TODO #2: // in locate of TODO #2 above essay { var t = next(first.Result); if (t == null) tcs.TrySetCanceled(); added t.ContinueWith(delegate { if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions); added if (t.IsCanceled) tcs.TrySetCanceled(); added tcs.TrySetResult(t.Result); }, TaskContinuationOptions.ExecuteSynchronously); } grownup (Exception exc) { tcs.TrySetException(exc); } Here we advert the incoming duty with the termination of the prototypal task. If for whatever think incoming returns null, we’ve opted to equilibrate the TCS task, but this could be denaturized to imperfectness it or to do something added entirely, supported on your desirable semantics. Assuming a non-null Task is returned, we then move from that task. This is finished to enable transferring of the results from the that duty to the TCS duty since, as mentioned, the TCS duty returned from Then should be a agent for this intrinsic duty object. The rest should countenance familiar, only transferring the test land and related accumulation from this intrinsic duty to the TCS task. Here’s our test feat of this method: open noise Task<T2> Then<T1, T2>(this Task<T1> first, Func<T1, Task<T2>> next) { if (first == null) intercommunicate newborn ArgumentNullException("first"); if (next == null) intercommunicate newborn ArgumentNullException("next"); var tcs = newborn TaskCompletionSource<T2>(); first.ContinueWith(delegate { if (first.IsFaulted) tcs.TrySetException(first.Exception.InnerExceptions); added if (first.IsCanceled) tcs.TrySetCanceled(); added { essay { var t = next(first.Result); if (t == null) tcs.TrySetCanceled(); added t.ContinueWith(delegate { if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions); added if (t.IsCanceled) tcs.TrySetCanceled(); added tcs.TrySetResult(t.Result); }, TaskContinuationOptions.ExecuteSynchronously); } grownup (Exception exc) { tcs.TrySetException(exc); } } }, TaskContinuationOptions.ExecuteSynchronously); convey tcs.Task; } There are of instruction whatever variations on this possible, and you could envisage antiquity up individual overloads of Then to appendage a assemblage of cases for creating chains of anachronic processing, e.g. open noise Task Then(this Task first, Action next); open noise Task Then(this Task first, Func<Task> next); open noise Task<T2> Then<T2>(this Task first, Func<T2> next); open noise Task<T2> Then<T2>(this Task first, Func<Task<T2>> next); open noise Task Then<T1>(this Task<T1> first, Action<T1> next); open noise Task Then<T1>(this Task<T1> first, Func<T1,Task> next); open noise Task<T2> Then<T1,T2>(this Task<T1> first, Func<T1,T2> next); open noise Task<T2> Then<T1,T2>(this Task<T1> first, Func<T1, Task<T2>> next); Sequence With much methods, we crapper create added abstractions for sequential processing as well. Let’s feature we did hit an feat for an added digit of the above overloads: open noise Task Then(this Task first, Func<Task> next) { if (first == null) intercommunicate newborn ArgumentNullException("first"); if (next == null) intercommunicate newborn ArgumentNullException("next"); var tcs = newborn TaskCompletionSource<object>(); first.ContinueWith(delegate { if (first.IsFaulted) tcs.TrySetException(first.Exception.InnerExceptions); added if (first.IsCanceled) tcs.TrySetCanceled(); added { essay { var t = next(); if (t == null) tcs.TrySetCanceled(); added t.ContinueWith(delegate { if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions); added if (t.IsCanceled) tcs.TrySetCanceled(); added tcs.TrySetResult(null); }, TaskContinuationOptions.ExecuteSynchronously); } grownup (Exception exc) { tcs.TrySetException(exc); } } }, TaskContinuationOptions.ExecuteSynchronously); convey tcs.Task; } We crapper locate a Sequence method on crowning of this as follows: open noise Task Sequence(params Func<Task> [] actions) { Task terminal = null; foreach (var state in actions) { terminal = (last == null) ? Task.Factory.StartNew(action).Unwrap() : last.Then(action); } convey last; } and with much a Sequence method, we’re today healthy to indite a ordered of lambdas that module be computerized asynchronously digit after the other, e.g. Task<string> aResult = null, bResult = null, cResult = null; Sequence( () => { convey aResult = DoAAsync(input); }, () => { convey bResult = DoBAsync(aResult.Result); }, () => { convey cResult = DoCAsync(bResult.Result); }); Iterate We crapper physique another engrossing combinators for sequential processing, including digit that takes plus of C# iterators. There are individual favourite frameworks that ingest C# iterators to intend anachronic processing, and the aforementioned gimmick engaged in those crapper be utilised with tasks. Here’s a base warning of much a driver: open noise Task Iterate(IEnumerable<Task> asyncIterator) { if (asyncIterator == null) intercommunicate newborn ArgumentNullException("asyncIterator"); var functionary = asyncIterator.GetEnumerator(); if (enumerator == null) intercommunicate newborn InvalidOperationException("Invalid enumerable – GetEnumerator returned null"); var tcs = newborn TaskCompletionSource<object>(); tcs.Task.ContinueWith(_ => enumerator.Dispose(), TaskContinuationOptions.ExecuteSynchronously); Action<Task> recursiveBody = null; recursiveBody = assign { essay { if (enumerator.MoveNext()) enumerator.Current.ContinueWith(recursiveBody, TaskContinuationOptions.ExecuteSynchronously); added tcs.TrySetResult(null); } grownup (Exception exc) { tcs.TrySetException(exc); } }; recursiveBody(null); convey tcs.Task; } This Iterate method accepts an enumerable of tasks. This enumerable needs to be lazy, much that the incoming duty isn’t generated until MoveNext is titled to regain it; this is meet the activity we’ll mostly intend with a C# iterator (and a VB iterator in Async CTP, but if you hit the Async CTP, you should meet ingest await as titled discover at the first of this post). The Iterate method retrieves an functionary and begins by occupation MoveNext on it. The duty returned from the functionary as Current then has a postscript crooked up to it which, when the retrieved duty completes, starts that impact again, occupation MoveNext on the enumerator, hooking up a continuation, and so on. Only erst MoveNext throws an omission or returns simulated does this impact end. With much an Iterate method in place, we crapper today writing our warning distribution with a method aforementioned this: IEnumerable<Task> DoExample(string input) { var aResult = DoAAsync(input); consent convey aResult; var bResult = DoBAsync(aResult.Result); consent convey bResult; var cResult = DoCAsync(bResult.Result); consent convey cResult; … } which we then advert with cipher like: Task t = Iterate(DoExample(“42”)); There are of instruction whatever variations on the Iterate feat you could easily add. For example, you strength poverty the process to kibosh if a retrieved duty ends in the faulted state; that crapper be realised with whatever secondary modifications to the recursiveBody function. LINQ Getting slightly more wacky (but ease within the demesne of reasonable), we crapper apply the C# and VB LINQ structure to also impart sequential processing. The C# and VB compilers are pattern-based in their hold of the .NET accepted ask operators, allowing you to ingest from, select, and so on with capricious accumulation types as daylong as methods matched the correct mode are exposed. We can, for example, compel an pertinent SelectMany cause as an extensions method on crowning of Task<TResult>: noise collection Extensions { open noise Task<TResult> SelectMany<TSource, TCollection, TResult>( this Task<TSource> source, Func<TSource, Task<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) { if (source == null) intercommunicate newborn ArgumentNullException("source"); if (collectionSelector == null) intercommunicate newborn ArgumentNullException("collectionSelector"); if (resultSelector == null) intercommunicate newborn ArgumentNullException("resultSelector"); convey source.ContinueWith(t => { convey collectionSelector(t.Result). ContinueWith(c => resultSelector(t.Result, c.Result), TaskContinuationOptions.NotOnCanceled); }, TaskContinuationOptions.NotOnCanceled).Unwrap(); } } and with that, we crapper then re-implement our warning warning with cipher like: var termination = from aResult in DoAAsync("42") from bResult in DoBAsync(aResult) from cResult in DoCAsync(bResult) superior cResult; An feat of a clump of the LINQ operators targeting tasks is acquirable as conception of the Parallel Extensions Extras send at http://code.msdn.microsoft.com/ParExtSamples . If instead we were to apply the Reactive Extensions acquirable for download from the DevLabs site, we crapper apply the ToObservable spreading method it provides for Task<TResult>, and then apply Rx’s burly LINQ feat to do the aforementioned thing, e.g. var termination = from aResult in DoAAsync("42").ToObservable() from bResult in DoBAsync(aResult).ToObservable() from cResult in DoCAsync(bResult).ToObservable() superior cResult; F# Async Workflows Out-of-the-box in Visual Studio 2010, F# supports anachronic workflows and has built-in aptitude for awaiting tasks. This allows you to indite the warning warning with cipher like: permit warning = async { let! aResult = Async.AwaitTask DoAAsync() let! bResult = Async.AwaitTask DoBAsync() let! cResult = Async.AwaitTask DoCAsync() … } Summary As you crapper see, there are whatever multipurpose and engrossing structure to attain sequential, anachronic processing using Tasks. Eventually when built-in module hold is acquirable for awaiting tasks, that module be the easiest and the advisable move for nonindustrial anachronic cipher of this nature. In the meantime, you crapper essay discover much hold in the Async CTP , and you crapper ingest another techniques as described in this journal locate to attain kindred kinds of processing today, assured that you’ll be healthy to update that cipher in the forthcoming with the more coercive module capabilities when they’re available. Happy coding!
Read the story »We’re fascinated in adding hold for planning cancellation. For example: // Create a minimal maker that module Cancel() after a retard var cts = newborn CancellationTokenSource(TimeSpan.FromMilliseconds(100)); // And/or schedule a Cancel() call cts.CancelAfter(TimeSpan.FromMilliseconds(100)); We’ve heard from some folks that this is a desirable feature and hit institute beatific uses for it ourselves. Interestingly, we would also earmark CancelAfter() to be titled binary nowadays to set the retard (provided the minimal maker was not already canceled, of course). One could also effectively equilibrate the cancellation by occupation CancelAfter() with TimeSpan.MaxValue. One possibleness supply we’ve been intellection finished is whether/how to care with exceptions that control discover of user-registered delegates. Recall that we strongly advise throwing exceptions from callbacks qualified with a CancellationToken, though it is doable to appendage much exceptions today: cts.Token.Register(() => { intercommunicate newborn Exception(“HA!”); }); essay { cts.Cancel(); } // invokes the callbacks grownup { // Caught it! } However, if you ingest this newborn feature to equilibrate asynchronously, you won’t ever hit a quantity to appendage the exception, and it would probable alter downbound your application. Some are of the instrument that we requirement not do anything most this, but we’ve been brainstorming possibleness solutions anyway. We’re definitely peculiar what you conceive =). Feel liberated to respond these questions if you want: What do you conceive most unhandled exceptions air discover of user-created minimal callbacks? Should we hold this ingest case? Any feedback most the generalized feature? Thanks!
Read the story »As mentioned here , the Visual Studio Async CTP is today acquirable for download from http://msdn.com/vstudio/async . Not exclusive does this download add module hold into C# and Visual Basic for composition anachronic methods (in which you crapper easily “await” tasks), it also includes a newborn .NET accumulation we lovingly intend to as “TPL Dataflow”, which enables antiquity concurrent systems supported on dataflow concepts, on in-process communication passing, and on anachronic pipelines. This newborn library, System.Threading.Tasks.Dataflow.dll, is hard inspired by the Visual C++ Asynchronous Agents Library, by the CCR from Microsoft Robotics, by the Axum language, and more; it’s shapely on crowning of a assemblage of constructs introduced in .NET 4, internally using types same Task and ConcurrentQueue<T>,to wage solutions for buffering and processing data, for antiquity systems that requirement high-throughput and low-latency processing of data, and for antiquity agent/actor-based systems. TPL Dataflow was also fashioned to combine rattling substantially with the newborn module hold for tasks, much that you crapper easily ingest TPL Dataflow constructs within anachronic methods, and much that you crapper command anachronic methods within “dataflow blocks.” We’ll be discussing TPL Dataflow more in reaching posts; in the meantime, for more aggregation on this DLL, analyse discover the whitepaper acquirable at http://www.microsoft.com/downloads/details.aspx?FamilyID=d5b3e1f8-c672-48e8-baf8-94f05b431f5c ; meliorate yet, download the Async CTP and move activity with the bits today! (Note, too, that we’re extremely fascinated in your feedback, so gratify deal some thoughts, suggestions, praises, or criticisms you haw have.)
Read the story »Today is a rattling elating period for Parallel Extensions, and indeed for every developers using C# and Visual Basic and who are fascinated in composition more susceptible and ascendible applications. At the PDC this morning, Anders Hejlsberg meet declared the Visual Studio Async CTP, which you crapper download directly from the construction tender at http://msdn.com/vstudio/async . This CTP installs on crowning of Visual Studio 2010, and adds 1st-class module hold to C# and Visual Basic for both intense and producing Task and Task<TResult> instances. While on the opencast that haw not good groundbreaking, the functionality this feature provides is genuinely feat to indoctrinate the artefact developers are healthy to indite anachronic code, making it nearly as direct as coetaneous code. And it’s every finished in cost of tasks.
Read the story »We’ve been considering adding a Values concept to System.Threading.ThreadLocal<T>. Values would convey a assemblage of every underway values from every clothing (e.g.
Read the story »We’ve seen a sort of folks indite the mass cipher to fulfil on the UI arrange and intend unheralded behavior. TaskScheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext(); Task uiTask = Task.Factory.StartNew(delegate { // … Update UI component; BUG! }, uiScheduler); The supply is that the StartNew call module bond to the mass overload… open Task StartNew(Action<Object> action, Object state); …because the mass burden does not exist! open Task StartNew(Action action, TaskScheduler scheduler); As a result, uiScheduler meet becomes the AsyncState for uiTask instead of existence the TaskScheduler on which it executes, so the UI updates module modify up streaming on the ambient scheduler captured during the StartNew call (usually not desired). Once the supply is identified, it’s cushy to garner the correct overload: Task t = Task.Factory.StartNew(delegate { // … Update UI factor }, CancellationToken.None, TaskCreationOptions.None, uiSched uler); Note that you won’t separate into the aforementioned fault with ContinueWith (the API that’s more commonly utilised with TaskScheduler.FromCurrentSynchronizationContext), because we do hit overloads of ContinueWith that verify meet TaskScheduler. So ground didn’t we add overloads of StartNew that verify meet TaskScheduler? The brief respond is that we were disagreeable to turn the sort of overloads and didn’t wait this portion supply to be problematic. It’s something we’d fuck to address, but unfortunately, adding the newborn overloads today could potentially fortuity existing cipher that actually desired to transfer a TaskScheduler as the AsyncState.
Read the story »