.NET 4.5 Parallel Extensions Cookbook

.NET 4.5 Parallel Extensions Cookbook

By : Bryan Freeman

Buy this Book

.NET 4.5 Parallel Extensions Cookbook

By: Bryan Freeman

Buy this Book

Overview of this book

.NET parallel extensions brings the power of parallel and asynchronous programming to a much wider developer audience than ever before. This book will give a developer with no multithreaded development experience the ability to write highly scalable parallel applications that take advantage of modern multicore processors.If you are an experienced .NET developer who wants to put parallel extensions to work in your applications, this book is for you. ".NET 4.5 Parallel Extensions Cookbook" is a practical, hands-on guide that provides you with a number of clear step-by-step recipes that will introduce parallelism into your applications and take advantage of modern multicore processors. This book is a crash course in using the extensions, with theory and concepts kept to a minimum. ".NET 4.5 Parallel Extensions Cookbook" offers a wide-ranging presentation of parallel development concepts, and provides a working knowledge of key technologies that are important to developers who want to take advantage of multi-core architectures. You will learn how to compose a series of producer/consumer tasks into a pipeline that can process data elements received from a real-time event stream. You will also learn how to connect the stages of pipelines together using the concurrent collections. You will learn everything you need to know to transform the multicore power found in modern processors into application performance and scalability.

.NET 4.5 Parallel Extensions Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Getting Started with Task Parallel Library

Introduction

Creating a task

Waiting for tasks to finish

Returning results from a task

Passing data to a task

Creating a child task

Lazy task execution

Handling task exceptions using try/catch block

Handling task exceptions with AggregateException.Handle

Cancelling a task

Cancelling one of many tasks

Implementing Continuations

Introduction

Continuing a task

Passing task results to a continuation

Continue "WhenAny" and "WhenAll"

Specifying when a continuation will run

Using a continuation for exception handling

Cancelling a continuation

Using a continuation to chain multiple tasks

Using a continuation to update a UI

Learning Concurrency with Parallel Loops

Introduction

Creating a basic parallel for loop

Creating a basic parallel foreach loop

Breaking a parallel loop

Stopping a parallel loop

Cancelling a parallel loop

Handling exceptions in a parallel loop

Controlling the degree of parallelism in a loop

Partitioning data in a parallel loop

Using Thread Local Storage

Parallel LINQ

Introduction

Creating a basic parallel query

Preserving order in parallel LINQ

Forcing parallel execution

Limiting parallelism in a query

Processing query results

Specifying merge options

Range projection with parallel LINQ

Handling exceptions in parallel LINQ

Cancelling a parallel LINQ query

Performing reduction operations

Creating a custom partitioner

Concurrent Collections

Introduction

Adding and removing items to BlockingCollection

Iterating a BlockingCollection with GetConsumingEnumerable

Performing LIFO operations with ConcurrentStack

Thread safe data lookups with ConcurrentDictionary

Cancelling an operation in a concurrent collection

Working with multiple producers and consumers

Creating object pool with ConcurrentStack

Adding blocking and bounding with IProducerConsumerCollection

Using multiple concurrent collections to create a pipeline

Synchronization Primitives

Introduction

Using monitor

Using a mutual exclusion lock

Using SpinLock for synchronization

Interlocked operations

Synchronizing multiple tasks with a Barrier

Using ReaderWriterLockSlim

Using WaitHandles with Mutex

Waiting for multiple threads with CountdownEvent

Using ManualResetEventSlim to spin and wait

Using SemaphoreSlim to limit access

Profiling and Debugging

Introduction

Using the Threads and Call Stack windows

Using the Parallel Stacks window

Watching values in a thread with Parallel Watch window

Detecting deadlocks with the Parallel Tasks window

Measure CPU utilization with Concurrency Visualizer

Using Concurrency Visualizer Threads view

Using Concurrency Visualizer Cores view

Async

Introduction

Creating an async method

Handling Exceptions in asynchronous code

Cancelling an asynchronous operation

Cancelling async operation after timeout period

Processing multiple async tasks as they complete

Improving performance of async solution with Task.WhenAll

Using async for file access

Checking the progress of an asynchronous task

Dataflow Library

Introduction

Reading from and writing to a dataflow block synchronously

Reading from and writing to a dataflow block asynchronously

Implementing a producer-consumer dataflow pattern

Creating a dataflow pipeline

Cancelling a dataflow block

Specifying the degree of parallelism

Unlink dataflow blocks

Using JoinBlock to read from multiple data sources

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Handling task exceptions with AggregateException.Handle

In this recipe, we will look at another way to handle System.AggregateException, by using the AggregateException.Handle method. The Handler method invokes a handler function for each exception wrapped in AggregateException.

Getting ready…

For this recipe, we need to turn off the Visual Studio 2012 Exception Assistant. The Exception Assistant appears whenever a runtime exception is thrown and intercepts the exception before it gets to our handler.

To turn off the Exception Assistant, go to the Debug menu and select Exceptions.
Uncheck the user-unhandled checkbox next to Common Language Runtime Exceptions.

How to do it…

Let's take a look at how we can use AggregateException.Handle to provide an alternate method to handling exceptions in a parallel application.

For this recipe, we will return to our WordCount6 project, and modify it to handle our exceptions in a different way. Start Visual Studio 2012 and open the WordCount6 project.

The first step is to define our handler function that will be invoked when we call AggregateException.Handle. Following the Main method of your Program class, add a new private static handler method that returns a bool. It should look as the following code snippet:

private static bool HandleWebExceptions(Exception ex)
{
    if (ex is WebException)
    {
      Console.WriteLine(("Caught WebException: {0}", ex.Message);
      return true;
    }
    else
    {
      Console.WriteLine("Caught exception: {0}", ex.Message);
      return false;
    }
}

The only other step here is to replace the body of your catch block with a call to System.AggregateException.Handle, passing in the HandleWebExceptions predicate. The updated try/catch block should look as follows:

try
{
    task1.Wait();   
    if (!task1.IsFaulted)
    {
      Console.WriteLine("Task complete. Origin of Species word count: {0}",task1.Result);
    }
}
catch (AggregateException aggEx)
{
    aggEx.Handle(HandleWebExceptions);                
}

Those are the only modifications necessary. In Visual Studio 2012, press F5 to run the project. You should see output as shown in the following screenshot:

How it works…

AggregateException.Handle() takes a predicate that you supply, and the predicate will be invoked once for every exception wrapped in System.AggregateException.

The predicate itself just needs to contain the logic to handle the various exception types that you expect, and to return true or false to indicate whether the exception was handled.

If any of the exceptions went unhandled, they will be wrapped in a new System.AggregateException and thrown.

.NET 4.5 Parallel Extensions Cookbook

By : Bryan Freeman

.NET 4.5 Parallel Extensions Cookbook

By: Bryan Freeman

Overview of this book

Related Content you might be interested in

Current Title:

.NET 4.5 Parallel Extensions Cookbook

Handling task exceptions with AggregateException.Handle

Getting ready…

How to do it…

How it works…