6. Using Concurrent Collections | Multithreading in C# 5.0 Cookbook

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Multithreading in C# 5.0 Cookbook

By : Agafonov

4.6 (5)

Multithreading in C# 5.0 Cookbook

4.6 (5)

By: Agafonov

Overview of this book

In an age when computer processors are being developed to contain more and more cores, multithreading is a key factor for creating scalable, effective, and responsive applications. If you fail to do it correctly, it can lead to puzzling problems that take a huge amount of time to resolve. Therefore, having a solid understanding of multithreading is a must for the modern application developer. Multithreading in C# 5.0 Cookbook is an easy-to-understand guide to the most puzzling programming problems. This book will guide you through practical examples dedicated to various aspects of multithreading in C# on Windows and will give you a good basis of practical knowledge which you can then use to program your own scalable and reliable multithreaded applications. This book guides you through asynchronous and parallel programming from basic examples to practical, real-world solutions to complex problems. You will start from the very beginning, learning what a thread is, and then proceed to learn new concepts based on the information you get from the previous examples. After describing the basics of threading, you will be able to grasp more advanced concepts like Task Parallel Library and C# asynchronous functions. Then, we move towards parallel programming, starting with basic data structures and gradually progressing to the more advanced patterns. The book concludes with a discussion of the specifics of Windows 8 application programming, giving you a complete understanding of how Windows 8 applications are different and how to program asynchronous applications for Windows 8.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Threading Basics

1. Threading Basics

Introduction

Creating a thread in C#

Pausing a thread

Making a thread wait

Aborting a thread

Determining a thread state

Thread priority

Foreground and background threads

Passing parameters to a thread

Locking with a C# lock keyword

Locking with a Monitor construct

Handling exceptions

2. Thread Synchronization

2. Thread Synchronization

Introduction

Performing basic atomic operations

Using the Mutex construct

Using the SemaphoreSlim construct

Using the AutoResetEvent construct

Using the ManualResetEventSlim construct

Using the CountDownEvent construct

Using the Barrier construct

Using the ReaderWriterLockSlim construct

Using the SpinWait construct

3. Using a Thread Pool

3. Using a Thread Pool

Introduction

Invoking a delegate on a thread pool

Posting an asynchronous operation on a thread pool

Thread pool and the degree of parallelism

Implementing a cancellation option

Using a wait handle and timeout with a thread pool

Using a timer

Using the BackgroundWorker component

4. Using Task Parallel Library

4. Using Task Parallel Library

Introduction

Creating a task

Performing basic operations with a task

Combining tasks together

Converting the APM pattern to tasks

Converting the EAP pattern to tasks

Implementing a cancellation option

Handling exceptions in tasks

Running tasks in parallel

Tweaking tasks execution with TaskScheduler

5. Using C# 5.0

5. Using C# 5.0

Introduction

Using the await operator to get asynchronous task results

Using the await operator in a lambda expression

Using the await operator with consequent asynchronous tasks

Using the await operator for the execution of parallel asynchronous tasks execution

Handling exceptions in the asynchronous operations

Avoid using the captured synchronization context

Working around the async void method

Designing a custom awaitable type

Using the dynamic type with await

6. Using Concurrent Collections

6. Using Concurrent Collections

Introduction

Using ConcurrentDictionary

Implementing asynchronous processing using ConcurrentQueue

Changing asynchronous processing order ConcurrentStack

Creating a scalable crawler with ConcurrentBag

Generalizing asynchronous processing with BlockingCollection

7. Using PLINQ

7. Using PLINQ

Introduction

Using the Parallel class

Parallelizing a LINQ query

Tweaking the parameters of a PLINQ query

Handling exceptions in a PLINQ query

Managing data partitioning in a PLINQ query

Creating a custom aggregator for a PLINQ query

8. Reactive Extensions

8. Reactive Extensions

Introduction

Converting a collection to asynchronous Observable

Writing custom Observable

Using Subjects

Creating an Observable object

Using LINQ queries against the observable collection

Creating asynchronous operations with Rx

9. Using Asynchronous I/O

9. Using Asynchronous I/O

Introduction

Working with files asynchronously

Writing an asynchronous HTTP server and client

Working with a database asynchronously

Calling a WCF service asynchronously

10. Parallel Programming Patterns

10. Parallel Programming Patterns

Introduction

Implementing Lazy-evaluated shared states

Implementing Parallel Pipeline with BlockingCollection

Implementing Parallel Pipeline with TPL DataFlow

Implementing Map/Reduce with PLINQ

11. There's More

11. There's More

Introduction

Using a timer in a Windows Store application

Using WinRT from usual applications

Using BackgroundTask in Windows Store applications

Index

Index

Using ConcurrentDictionary

This recipe shows a very simple scenario, comparing the performance of a usual dictionary collection with the concurrent dictionary in a single-threaded environment.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter6\Recipe1.

How to do it...

To understand the difference between performance of a usual dictionary collection with the concurrent dictionary, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.

In the Program.cs file add the following using directives:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;

Add the following code snippet below the Main method:

const string Item = "Dictionary item";
public static string CurrentItem;

Add the following code snippet inside the Main method:

var concurrentDictionary = new ConcurrentDictionary...

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Multithreading in C# 5.0 Cookbook

Search

Your notes and bookmarks