His main interests include programming languages, virtual machines and runtimes, functional programming, and all sorts of theoretical foundations. In his spare time, Bart likes to hike in the wonderful nature around Seattle, read technical books, and catch up on his game of snooker.

Before joining Microsoft in October 2007, Bart was active in the .NET community as a Microsoft Most Valuable Professional (MVP) for C#, while completing his Bachelor of Informatics, Master of Informatics, and Master of Computer Science Engineering studies at Ghent University, Belgium.

Part I Introduction

Chapter 1 Introducing the .NET Platform 5

A Historical Perspective5

    Win32 Programming in C 6

    Raising the Abstraction Level with MFC and C++ 6

    Component-Driven Development with COM 7

    Windows Development for the Masses in Visual Basic 7

    Reaching Out to the Web with Windows DNA8

    Reaching Out to Java with J++8

    Time for Lightning8

A 10,000-Feet View of the .NET Platform 9

    The .NET Platform 9

The Common Language Infrastructure

The Multilanguage Aspect of .NET

Introducing .NET Assemblies

The Common Type System Explained

    What’s Type Safety?

    Primitive Types

    Classes, Structures, and Enumerations

    Interfaces

    Delegates

    Members

    A Note on Generics

    The Role of the Common Language Specification

Executing Managed Code

    The Assembly Manifest

    IL Code

    Metadata

    Mixing Languages

Diving into the Common Language Runtime

    Bootstrapping the Runtime

    Assembly Loading

    Application Domains

    JIT Compilation

    Native Image Generation

    Automatic Memory Management

    Exception Handling

    Code Access Security

    Interoperability Facilities

    The Base Class Library

Summary

Chapter 2 Introducing the C# Programming Language

The Evolution of C#

    C# 1.0: Managed Code Development, Take One

    C# 2.0: Enriching the Core Language Features

    C# 3.0: Bridging the Gap Between Objects and Data

    C# 4.0: Reaching Out to Dynamic Languages

A Sneak Peek at the Future

    Multiparadigm

    Language-Shaping Forces

    Compiler as a Service

    Taming the Concurrency Beast

Summary

Chapter 3 Getting Started with .NET Development Using C#

Installing the .NET Framework

    The .NET Framework Version Landscape

    .NET Framework 4

    Running the Installer

    What Got Installed?

Your First Application: Take One

    Writing the Code

    Compiling It

    Running It

    Inspecting Our Assembly with .NET Reflector

Visual Studio 2010

    Editions

    Expression

    Installing Visual Studio 2010

    A Quick Tour Through Visual Studio 2010

Your First Application: Take Two

    New Project Dialog

    Solution Explorer

    Project Properties

    Code Editor

    Build Support

    Debugging Support

    Object Browser

    Code Insight

    Integrated Help

    Designers

    Server Explorer

    Database Mappers

    Unit Testing

    Team Development

Summary

Part II C#—The Language

Chapter 4 Language Essentials

The Entry Point

    A Trivial Console Application

    Method Signatures

    Allowed Entry-Point Signatures

    Running the Sample

    Under the Hood

Keywords

    Contextual Keywords

    Syntax Highlighting in Visual Studio

A Primer on Types

    Code and Data

    Types, Objects, and Instances

    Variables

    Classes and Other Types

Built-In Types

    Integral Types

    Floating-Point Types

    The Decimal Type

    The Boolean Type

    The String Type

    Object

    Dynamic Typing

    A Word on CLS Compliance

    A Matter of Style: Aliases or Not?

Local Variables

    Declaration

    Scope

    Assignment

    Constants

    Implicitly Typed Local Variable Declarations

Intermezzo on Comments

    Single-Line Comments

    A Primer to Preprocessing Directives

    Delimited Comments

    Documentation Comments

Arrays

    Internal Representation

    Single-Dimensional Arrays

    Array Initializers

    Jagged Arrays

    Multidimensional Arrays

The Null Reference

    What’s Null Really?

    A Common Source of Bugs

Nullable Value Types

    Internal Representation

    Use in C#

    A Type Background

Summary

Chapter 5 Expressions and Operators

What Are Expressions?

    Arity of Operators

    Precedence and Associativity

    Evaluation of Subexpressions

The Evaluation Stack

Arithmetic Operators

    Integer Arithmetic

    Floating-Point Arithmetic

    Decimal Arithmetic

    Character Arithmetic

    Unary Plus and Minus

    Overflow Checking

    Arithmetic with Nullables

String Concatenation

Shift Operators

Relational Operators

    Equality for Different Types

    Lifted Operators

Logical Operators

    Integral Bitwise Logical Operators

    Use for Enumerations

    Boolean Logical Operators

    Nullable Boolean Logic

Conditional Operators

    Under the Hood

An Operator’s Result Type

    Associativity

Null-Coalescing Operator

Assignment

    Decaration Versus (Simple) Assignment

    Compound Assignment

    A Gentle Introduction to Definite Assignment

    Postfix and Prefix Increment and Decrement Operators

Summary

Chapter 6 A Primer on Types and Objects

Implicit Versus Explicit Conversions

    Cast Expressions

    The is Operator

    The as Operator

    Intermezzo: The Mythical Type Switch

The typeof Operator: A Sneak Peek at Reflection

Default Value Expression

Creating Objects with the new Operator

    Behind the Scenes of Constructors

    Object Initializers

    Collection Initializers

Member Access

    A First Look at Dynamic Typing

Invocation Expressions

    Method Invocation

    Delegate Invocation

Element Access

Summary

Chapter 7 Simple Control Flow

What Are Statements, Anyway?

Expression Statements

    Method Calls

    Assignments

    Pre- and Post-Increment/Decrement

The Empty Statement

Blocks

Declarations

Selection Statements

    The if Statement

    The switch Statement

Iteration Statements

    The while Statement

    The do...while Statement

    The for Statement

    The foreach Statement

A Peek at Iterators

Loops in the Age of Concurrency

The goto Statement

The return Statement

Summary

Chapter 8 Basics of Exceptions and Resource Management

Exception Handling

    Exceptions Are Objects

    Causes of Exceptions

    Throwing Exceptions

    Handling Exceptions

    The finally Clause

Deterministic Resource Cleanup

    Garbage Collection in a Nutshell

    Object Disposal

    The using Statement

    Implementing IDisposable

     (In)appropriate Use of IDisposable

Locking on Objects

    Under the Hood

    The lock Statement

    Intermezzo: Code Generation for Lock

    Be Careful with Locks

Summary

Chapter 9 Introducing Types

Types Revisited

Classes Versus Structs

    References Versus Values

    Heap Versus Stack

    Boxing

    The Dangers of Mutable Value Types

Type Members

    Visibility

    Static Versus Instance

    Partial Types

Summary

Chapter 10 Methods

Defining Methods

Return Type

Parameters

    Value Parameters

    Reference Parameters

    Output Parameters

    Parameter Arrays

    Optional and Named Parameters

Overloading

    Defining Method Overloads

    Method Groups

    Overload Resolution

Extension Methods

    Defining Extension Methods

    Overload Resolution

    Using Extension Methods

    How the Compiler Marks and Finds Extension Methods

Partial Methods

Extern Methods

Refactoring

Code Analysis

Summary

Chapter 11 Fields, Properties, and Indexers

Fields

    Declaring Fields

    Accessing Fields

    Initializing Fields

    Read-Only Fields

    Constants

    Volatile Fields

An Intermezzo About Enums

    Why Enums Matter

    Underlying Types

    Assigning Values to Members

    The System.Enum Type

    Flags

    Revisiting the switch Statement

    Behind the Scenes

Properties

    Declaring and Using Properties

    Auto-Implemented Properties

    How Properties Work

Indexers

    Defining Indexers

    How Indexers Are Implemented

Summary

Chapter 12 Constructors and Finalizers

Constructors

    Instance Constructors

Static Constructors

Destructors (Poorly Named Finalizers)

    Defining Finalizers in C#

    How Finalizers Are Run

    How Finalizers Are Implemented

    Disposal Before Collection: IDisposable

Summary

Chapter 13 Operator Overloading and Conversions

Operators

    Defining Operators

    How Operators Are Found

    Nullability and Lifted Operators

    Which Operators Can Be Overloaded?

    Implementing Equality Operations

    How Operators Are Translated

Conversions

    Built-In Conversions

    User-Defined Conversions

    Other Conversion Mechanisms

Summary

Chapter 14 Object-Oriented Programming

The Cornerstones of Object Orientation

    A Historical Perspective

    Encapsulation

    Inheritance

    Polymorphism

    Types in Pictures

Inheritance for Classes

    Single Inheritance for Classes

    Multiple Inheritance for Interfaces

    Blocking Inheritance

    Hiding Base Class Members

Protected Accessibility

Polymorphism and Virtual Members

    Virtual Members

    Overriding Virtual Members

    Declaring Virtual Members

    Sealing and Hiding: Take Two

    How Virtual Dispatch Works

    How Base Calls Work

Abstract Classes

Interfaces

    Defining Interfaces

    Some Design Recommendations

    Implementing Interfaces

Summary

Chapter 15 Generic Types and Methods

Life Without Generics

    A Real-World Example with Collections

    Performance Worries

Getting Started with Generics

Declaring Generic Types

Using Generic Types

Performance Intermezzo

Operations on Type Parameters

    Default Values

    Getting the Type’s Reflection Info Object

Generic Constraints

    Interface-Based Constraints

    Base Class Constraints

    Default Constructor Constraint

    Restriction to Value Types or Reference Types

Generic Methods

Co- and Contravariance

    Annoyances with Generic Types

    Broken Covariance for Array Types

    Safety Guarantees

    Generic Co- and Contravariance

    Under the Hood

    Where to Use

Summary

Chapter 16 Collection Types

Nongeneric Collection Types

    ArrayList

    Hash Tables

    Queue

    Stack

    Summary

Generic Collection Types

    List<T>

    SortedDictionary<TKey, TValue> and SortedList<TKey, TValue>

    Queue<T> and Stack<T>

Other Collection Types

Summary

Chapter 17 Delegates

Functional Programming

    Historical Perspective

    Programming with Functions

What Are Delegates?

Delegate Types

Delegate Instances

    Anonymous Function Expressions

    Closures: Captured Outer Variables

    Lambda Expressions

    Expression Trees

Invoking Delegates

Putting It Together: An Extensible Calculator

Case Study: Delegates Used in LINQ to Objects

Asynchronous Invocation

Combining Delegates

Summary

Chapter 18 Events

The Two Sides of Delegates

A Reactive Application

    Using Delegates

    Limitations on Plain Use of Delegates

    Using .NET Events

How Events Work

Raising Events, the Correct Way

Add and Remove Accessors

Detach Your Event Handlers

Recommended Event Patterns

    EventHandler and EventArgs

    EventHandler<T>

    Designing Events for Use by Derived Classes

Case Study: INotifyProperty Interfaces and UI Programming

    Events in UI Frameworks

Countdown, the GUI Way

Modern Approaches to Reactive Programming

    Events Revisited

    Pull Versus Push

    Dictionary Suggest Revisited

Summary

Chapter 19 Language Integrated Query Essentials

Life Without LINQ

    In-Memory Data

    Relational Databases

    XML

    The Birth of LINQ

LINQ by Example

    In-Memory Data

    Relational Databases

    XML

Query Expression Syntax

    Why Query Expressions?

    Getting Started

    Source Selection Using a from Clause

    Projection Using the Select Clause

    Filtering Using a where Clause

    Ordering Using the orderby Keyword

    Grouping Using the group by Clause

    Joining Using the join Clause

    Continuing a Query Expression Using the into Clause

    Bindings with the let Clause

Summary

Chapter 20 Language Integrated Query Internals

How LINQ to Objects Works

    IEnumerable<T> and IEnumerator<T> Recap

    LINQ to Objects Extension Methods

    Iterators

    Lazy Evaluation

    How Iterators Work

Standard Query Operators

    Source Generators

    Restriction

    Projection

    Ordering

    Grouping and Joining

    Aggregation

    Predicates

    Set Theoretical and Sequencing Operators

    Sequence Persistence

    Remote Versus Local with AsEnumerable

The Query Pattern

    All About Methods

    Overloading Query Expression Syntax

Parallel LINQ

    The Cost of Optimization

    AsParallel

    How PLINQ Works

    AsOrdered

    Tweaking Parallel Querying Behavior

    Parallel Enumeration with ForAll

Expression Trees

    Query Expression Translation

    Homoiconicity for Dummies

    Expression Trees for Query Expressions

    IQueryable<T>

Summary

Chapter 21 Reflection

Typing Revisited, Static and Otherwise

    The Role of Metadata

    The Multilanguage World

    Taking Multilanguage to the Next Level

    How Does All of This Relate to C# Programming?

Reflection

    System.Type

    A Primer on Application Extensibility

    Reflection for Methods, Properties, Events, and More

    Custom Attributes

Lightweight Code Generation

    Hello LCG

    A Toy Compiler for Arithmetic Expressions

Expression Trees

    Compiler-Generated Expression Trees

    The Expression Tree API

    Using the ExpressionTreeVisitor

Summary

Chapter 22 Dynamic Programming

The dynamic Keyword in C# 4.0

    The dynamic Type

    Dynamic Typing Is Contagious

    Deferred Overload Resolution

    No System.Dynamic Type

    When to Use dynamic: Case Study with IronPython

DLR Internals

    Dynamic Call Sites and Binders

    Dynamic Dispatch

    Custom Dynamic Objects with DynamicObject

    A Primer to DynamicMetaObject

    Dynamic Operations

    Overall Architecture

Office and COM Interop

    Essentials of COM Interop

    Simplified COM Interop in .NET 4

    Case Study: COM Interop with Excel and Word

Summary

Chapter 23 Exceptions

Life Without Exceptions

    Win32

    COM

    Lessons Learned

Introducing Exceptions

Exception Handling

    try Statements

    First-Chance Exceptions

    Intermezzo on Historical Debugging with IntelliTrace

    When and What to Catch

    Beyond Your Control

Throwing Exceptions

Defining Your Own Exception Types

(In)famous Exception Types

    DivideByZeroException

    OverflowException

    NullReferenceException

    IndexOutOfRangeException

    InvalidCastException

    ArrayTypeMismatchException

    TypeInitializationException

    ObjectDisposedException

    OutOfMemoryException

    StackOverflowException

    ExecutionEngineException

    ArgumentException

    ArgumentNullException

    ArgumentOutOfRangeException

    InvalidOperationException

    NotImplementedException

    NotSupportedException

    FormatException

    AggregateException

Summary

Chapter 24 Namespaces

Organizing Types in Namespaces

    Once Upon a Time

    Assemblies and Namespaces

Declaring Namespaces

    Naming Conventions

    Visibility

    Name Clashes Within Namespaces

Importing Namespaces

    Name Clashes Due to Imports

    Using Aliases

    Extern Aliases

    Extension Methods

Summary

Chapter 25 Assemblies and Application Domains

Assemblies

    Modules and Assemblies

    Types of Assemblies

    Assembly Properties

    Naming, Versioning, and Deployment

    Strong Naming

    The Global Assembly Cache

    Referencing Assemblies

    How Assemblies Get Loaded at Runtime

    Native Image Generation (NGEN)

    Visibility Aspects

    Embedded Resources

    Type Forwarding

    Reflection Flashback

Application Domains

    Creating Application Domains

    Cross-Domain Communication

    The Managed Add-In Framework

Summary

Part III Working with Base Class Libraries

Chapter 26 Base Class Library Essentials

The BCL: What, Where, and How?

    What Is Covered?

    Default Project References

    Namespaces Versus Assemblies

    The System and mscorlib Assemblies

    System.Core’s Story of Red Bits and Green Bits

The Holy System Root Namespace

    Primitive Value Types

    Working with Arrays

    The Math Class

    BigInteger: Beyond 32-bit and 64-bit Integers

    Complex Numbers

    Generating Random Numbers

    Working with Date and Time

    GUID Values

    Nullability Revisited Briefly

    The Uri Type

    Interacting with the Environment

    Leave the GC Alone (Most of the Time)

    Native Interop with IntPtr

    Lazy Initialization Using Lazy<T>

    Tuple Types

Facilities to Work with Text

    Formatting Text

    Parsing Text to Objects

    Regular Expressions

    Commonly Used String Methods

    The StringBuilder Class

    Text Encoding

Summary

Chapter 27 Diagnostics and Instrumentation

Ensuring Code Quality

    Code Analysis

    Asserts and Contracts

    Diagnostic Debugger Output

    Controlling the Debugger

    Logging Stack Traces

    Measuring Performance Using StopWatch

Instrumentation

    Using Event Logs

    Monitoring with Performance Counters

    Other Manageability Frameworks

Controlling Processes

    Querying Process Information

    Starting Processes

Summary

Chapter 28 Working with I/O

Files and Directories

    Listing Drives

    Working with Directories

    Working with Paths

    The FileInfo Class

Monitoring File System Activity

Readers and Writers

    The File Class

    TextReader and TextWriter

Streams: The Bread and Butter of I/O

    Memory Streams

    Working with Files: Take Two

    BinaryReader and BinaryWriter

    Asynchronous Read and Write Operations

    Streams Are Everywhere

A Primer to (Named) Pipes

Memory-Mapped Files in a Nutshell

Overview of Other I/O Capabilities

Summary

Chapter 29 Threading and Synchronization

Using Threads

    Explaining the Concept of Threads

    The Managed Code Story

    Where It All Starts: The Thread Class

    More About a Thread’s Life Cycle

    Managed Thread Characteristics

    Dealing with Exceptions

    Thread-Specific State

    Essential Threading Debugging

    Techniques

Thread Pools

    .NET’s Thread Pool

Synchronization Primitives

    Atomicity (or Lack Thereof) Illustrated

    Monitors and the lock Keyword

    Mutexes

    Semaphores

    More Advanced Locks

    Signaling with Events

    Interlocked Helpers

    More Synchronization Mechanisms

    BackgroundWorker

Summary

Chapter 30 Task Parallelism and Data Parallelism

Pros and Cons of Threads

    Cutting Costs

    An Ideal Number of Threads?

The Task Parallel Library

    Architecture

    Declarative Versus Imperative

    What Are Tasks?

Task Parallelism

    Creating and Starting Tasks

    Retrieving a Task’s Result

    Dealing with Errors

    Continuations

    Cancellation of Tasks

    Parallel Invocation

    Waiting for Multiple Tasks

    How the Task Scheduler Works

Data Parallelism

    Parallel For Loops

    Parallel Foreach Loops

Summary

9780672330797    TOC    12/16/2010

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.