You are previewing Async in C# 5.0.

Async in C# 5.0

Cover of Async in C# 5.0 by Alex Davies Published by O'Reilly Media, Inc.
  1. Special Upgrade Offer
  2. Preface
    1. Intended Audience
    2. How to Read This Book
    3. Conventions Used in This Book
    4. Using Code Examples
    5. Safari® Books Online
    6. How to Contact Us
    7. Acknowledgments
  3. 1. Introduction
    1. Asynchronous Programming
    2. What’s So Great About Asynchronous Code?
    3. What Is Async?
    4. What Async Does
    5. Async Doesn’t Solve Everything
  4. 2. Why Programs Need to Be Asynchronous
    1. Desktop User Interface Applications
      1. An Analogy: The Cafe
    2. Web Application Server Code
      1. Another Analogy: The Restaurant Kitchen
    3. Silverlight, Windows Phone, and Windows 8
    4. Parallel Code
    5. An Example
  5. 3. Writing Asynchronous Code Manually
    1. Some Asynchronous Patterns Used in .NET
    2. The Simplest Asynchronous Pattern
    3. An Introduction to Task
    4. The Problem with Manual Asynchrony
    5. Converting the Example to Use Manual Asynchronous Code
  6. 4. Writing Async Methods
    1. Converting the Favicon Example to Async
    2. Task and await
    3. Async Method Return Types
    4. Async, Method Signatures, and Interfaces
    5. The return Statement in Async Methods
    6. Async Methods Are Contagious
    7. Async Anonymous Delegates and Lambdas
  7. 5. What await Actually Does
    1. Hibernating and Resuming a Method
    2. The State of the Method
    3. Context
    4. Where await Can’t Be Used
      1. catch and finally Blocks
      2. lock Blocks
      3. LINQ Query Expressions
      4. Unsafe Code
    5. Exception Capture
    6. Async Methods Are Synchronous Until Needed
  8. 6. The Task-Based Asynchronous Pattern
    1. What the TAP Specifies
    2. Using Task for Compute-Intensive Operations
    3. Creating a Puppet Task
    4. Interacting with Old Asynchronous Patterns
    5. Cold and Hot Tasks
    6. Up-Front Work
  9. 7. Utilities for Async Code
    1. Delaying for a Period of Time
    2. Waiting for a Collection of Tasks
    3. Waiting for Any One Task from a Collection
    4. Creating Your Own Combinators
    5. Cancelling Asynchronous Operations
    6. Returning Progress During an Asynchronous Operation
  10. 8. Which Thread Runs My Code?
    1. Before the First await
    2. During the Asynchronous Operation
    3. SynchronizationContext in Detail
    4. await and SynchronizationContext
    5. The Lifecycle of an Async Operation
    6. Choosing Not to Use SynchronizationContext
    7. Interacting with Synchronous Code
  11. 9. Exceptions in Async Code
    1. Exceptions in Async Task-Returning Methods
    2. Unobserved Exceptions
    3. Exceptions in Async void Methods
    4. Fire and Forget
    5. AggregateException and WhenAll
    6. Throwing Exceptions Synchronously
    7. finally in Async Methods
  12. 10. Parallelism Using Async
    1. await and locks
    2. Actors
    3. Using Actors in C#
    4. Task Parallel Library Dataflow
  13. 11. Unit Testing Async Code
    1. The Problem with Unit Testing in Async
    2. Writing Working Async Tests Manually
    3. Using Unit Test Framework Support
  14. 12. Async in ASP.NET Applications
    1. Advantages of Asynchronous Web Server Code
    2. Using Async in ASP.NET MVC 4
    3. Using Async in Older Versions of ASP.NET MVC
    4. Using Async in ASP.NET Web Forms
  15. 13. Async in WinRT Applications
    1. What Is WinRT?
    2. IAsyncAction and IAsyncOperation<T>
    3. Cancellation
    4. Progress
    5. Providing Asynchronous Methods in a WinRT Component
  16. 14. The Async Compiler Transform—in Depth
    1. The stub Method
    2. The State Machine Struct
    3. The MoveNext Method
      1. Your Code
      2. Transforming Returns to Completions
      3. Get to the Right Place in the Method
      4. Pausing the Method for the await
      5. Resuming after the Await
      6. Completing Synchronously
      7. Catching Exceptions
      8. More Complicated Code
    4. Writing Custom Awaitable Types
    5. Interacting with the Debugger
  17. 15. The Performance of Async Code
    1. Measuring Async Overhead
    2. Async Versus Blocking for a Long-Running Operation
    3. Optimizing Async Code for a Long-Running Operation
    4. Async Versus Manual Asynchronous Code
    5. Async Versus Blocking Without a Long-Running Operation
    6. Optimizing Async Code Without a Long-Running Operation
    7. Async Performance Summary
  18. About the Author
  19. Special Upgrade Offer
  20. Copyright
O'Reilly logo

Chapter 6. The Task-Based Asynchronous Pattern

The Task-based Asynchronous Pattern (TAP) is a set of recommendations from Microsoft for writing asynchronous APIs in .NET using Task. The document by Stephen Toub from the parallel programming team at Microsoft has good examples and is worth a read.

The pattern makes APIs that can be consumed using await, and while using async produces methods that follow the pattern, it’s often useful to use Task manually. In this chapter, I’ll explain the pattern, and techniques to work with it.

What the TAP Specifies

I’ll assume we already know how to design a good method signature for synchronous C# code:

  • It should have a few parameters, or maybe none. ref and out parameters should be avoided if possible.

  • It should have a return type, if it makes sense, which really expresses the result of the code inside the method, as opposed to a success indicator like in some C++ code.

  • It should have a name that explains the behavior of the method, without extra notation.

  • Common or expected failures should be part of the return type, while unexpected failures should throw exceptions.

Here is a well designed synchronous method, which is part of the Dns class:

public static IPHostEntry GetHostEntry(string hostNameOrAddress)

The TAP gives the same level of guidelines on designing an asynchronous method, based on your existing skills with synchronous methods. Here they are:

  • It should have the same parameters as an equivalent synchronous method would. ref and out parameters ...

The best content for your career. Discover unlimited learning on demand for around $1/day.