Provides over 500 cipher examples, including real-world tasks much as creating an auto-login feature, sending HTML-formatted e-mail, investigating countersign guessability, and uploading files via a scheme interface.
Updated for MySQL 5, includes newborn chapters introducing triggers, stored procedures, and views.

From the Back Cover
Interested in decent a officer of the PHP module and MySQL database but don’t undergo where to begin? This best-selling aggregation ranks among the most complete and applicatory guides in print, concealment every of the key concepts and features, and display you how to effectively combine PHP and MySQL to physique coercive scheme sites.

The aggregation begins with a vast overview of PHP’s capabilities, play with a analyse of the artefact and plan impact on both the Windows and UNIX platforms. Next, individual chapters are devoted to base PHP concepts, including variables, datatypes, arrays, functions, progress manipulation, and processing individual input. Other key PHP topics are also covered, including PEAR, conference handling, LDAP integration, the Smarty templating engine, Web services, and PDO.

Next up is a show of MySQL’s key features. You’re prototypal guided finished MySQL’s artefact and plan process, and are presented with an launching to its hardware engines, datatypes, brass utilities, section features, and accumulation import/export facilities. New MySQL 5–specific chapters hit been additional in this edition, concealment triggers, stored procedures, and views. Along the way, you’ll acquire brainwave into PHP’s miscellanea of MySQL functions (using both the mysql and mysqli extensions), and see how to create and fulfil queries, action searches, and circularize discover key database tasks from within your Web application.

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 void

As an warning of this, in the Async CTP, Task’s GetAwaiter method returns a continuance of identify TaskAwaiter:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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:

public noise ControlAwaiter GetAwaiter(this Control control)
{
    convey newborn ControlAwaiter(control);
}

public 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:

public noise CultureAwaiter WithCurrentCulture(this Task task)
{
    convey newborn CultureAwaiter(task);
}

public 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.

The Parallel Computing Platform aggroup is conception of a super methodicalness at Microsoft convergent on technical computing, 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:

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!

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.:

private 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:

public 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:

private 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:

private 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:

private 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:

private 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:

private 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:

static 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:

private 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.:

private vacuum button1_Click(object sender, RoutedEventArgs e){    var mre = newborn ManualResetEvent(false);    SynchronizationContext.Current.Post(_ => mre.Set(), null);    mre.WaitOne(); // warning: buggy}

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.)

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:

public progress DoA(string input);
public progress DoB(string aResult);
public progress DoC(string bResult);

you could advert these functions with cipher like:

string aResult = DoA(input);
string bResult = DoB(aResult);
string cResult = DoC(bResult);

Then, presented Task-based anachronic counterparts to these functions:

public noise Task<string> DoAAsync(string input);
public noise Task<string> DoBAsync(string aResult);
public 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:

string aResult = await DoAAsync(input);
string bResult = await DoBAsync(aResult);
string 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:

public 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 first duty completes, the next 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 next function’s invocation; however, if the first duty is canceled or faults, the next duty module not be invoked, and the returned duty module instead equal the first 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:

public 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 first 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 first duty was canceled, we equilibrate the TCS task.  That meet leaves a RanToCompletion test state, message that the first 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 first 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
try
{
    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);
}
catch (Exception exc) { tcs.TrySetException(exc); }

Here we advert the next duty with the termination of the first task.  If for whatever think next 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:

public 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.

public noise Task Then(this Task first, Action next);
public noise Task Then(this Task first, Func<Task> next);
public noise Task<T2> Then<T2>(this Task first, Func<T2> next);
public noise Task<T2> Then<T2>(this Task first, Func<Task<T2>> next);

public noise Task Then<T1>(this Task<T1> first, Action<T1> next);
public noise Task Then<T1>(this Task<T1> first, Func<T1,Task> next);
public noise Task<T2> Then<T1,T2>(this Task<T1> first, Func<T1,T2> next);
public 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:

public 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();        else        {            try            {                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:

public 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:

public 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>:

static 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:

let 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!

We’re fascinated in adding hold for scheduling
cancellation.  For example:

// Create a
token maker that module Cancel() after a delay
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 multiple
times to set the retard (provided the minimal maker was not already canceled,
of course).  One could also effectively
cancel 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
possible to appendage much exceptions today:

cts.Token.Register(()
=> { intercommunicate newborn Exception(“HA!”); });

try { cts.Cancel(); } // invokes the callbacks
catch { // Caught it! }

However, if you ingest this newborn feature to cancel
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 think
=).  Feel liberated to respond these questions
if you want:

1. What do you conceive most unhandled exceptions
   flying discover of user-created minimal callbacks? 
   Should we hold this ingest case?
2. Any feedback most the generalized feature?

Thanks!