C# 2008 and 2005 Threaded Programming: Beginner's Guide

TopContentAds: 

[inline:C# Threaded Programming.jpg=C# 2008 and 2005 Threaded Programming: Beginner's Guide]

What This Book Covers

Chapter 1 acknowledges the advantages of parallel programming with C# for the
coming years. It also elaborates on the challenges associated with parallel processing
and programming.
Chapter 2 focuses on the fundamentals of the operating system scheduler and how a
single application can be divided into multiple threads or different processes. It also
explains the different ways of using threads to work in clients and servers.
Chapter 3 shows how to develop applications that are able to create background threads,
start and cancel threads, and launching multiple threads using the BackgroundWorker
components. It also discusses the differences between multiple threads using
BackgroundWorker and Timers.
Chapter 4 introduces the powerful Thread class, using which one can create independent
and very flexible threads. It also discusses the differences between multiple threads, using
BackgroundWorker and employing the Thread class, and ways to create high
performance applications.
Chapter 5 focuses on debugging applications with many concurrent threads and
coordinating the entire debugging process. It also explains the differences between
single-threaded debugging and multi threading debugging for threads created using
BackgroundWorker and employing the Thread class and many tricks that help
simplifying the debugging process.
Chapter 6 takes a closer look at working with independent blocks of code when
concurrency is not allowed, managing and coordinating those using new techniques
different from the ones offered by the Thread class. It also explains how to apply parallel
algorithms to image processing, and the solutions to the most common problems when
working with components not enabled for multi threading.
Chapter 7 shows how to improve the memory usage in heavy multi threading
applications, managing and coordinating the garbage collection service, and using an
object-oriented approach for splitting jobs into well-managed pieces, easily and
dynamically. It also covers developing highly optimized multi threaded algorithms.
Chapter 8 elaborates on using object-oriented capabilities offered by the C#
programming language, using design patterns for simplifying the parallelism complexity,
and avoiding synchronization pains. It also covers the principles of thread affinity, and
how to avoid the undesirable side effects related to concurrent programming.
Chapter 9 takes a closer look at using object-oriented capabilities offered by the C#
programming language for achieving great scalability in converting single-threaded
algorithms to multi threaded scalable jobs, while avoiding the pains of multi threading. It
emphasizes the use of pools and parallelized input/output operations in many ways.
Chapter 10 focuses on providing a more responsive user interface, using synchronous
and asynchronous delegates. It explains how to combine parallelized operations with a
precise user interface feedback while avoiding some multi threading pains. It also shows
how to combine a pool of threads with a responsive user interface.
Chapter 11 walks through parallelizing the execution of code, taking advantage of
the .NET Parallel Extensions. It explains how to combine different execution techniques
with automatically parallelized structures that will be available in Visual Studio 2010.
The chapter also shows how to transform a single-threaded imaging library into a
parallelized algorithm, and how to combine the .NET Parallel Extensions with a
responsive user interface.
Chapter 12 helps you in creating a whole application from scratch with completely
multi threaded code offering a responsive user interface for every event. It demonstrates
on how to join all the pieces in a complete application, parallelize the execution as much
as possible to offer great scalability, an impressive performance, and an incredibly
responsive user interface. It shows how to combine different parallelized tasks with
multiple-window UIs, always offering the best possible performance, and the most
responsive UI.