Accelerated C# 2010

Title Page

Copyright Page

Dedication Page

Contents at a Glance

Table of Contents

About the Author

About the Technical Reviewer

Acknowledgments

Preface

About This Book

Chapter 1: C# Preview

Differences Between C# and C++

C#

C++

CLR Garbage Collection

Example of a C# Program

Overview of Features Added in C# 2.0

Overview of Features Added in C# 3.0

Overview of New C# 4.0 Features

Summary

Chapter 2: C# and the CLR

The JIT Compiler in the CLR

Assemblies and the Assembly Loader

Minimizing the Working Set of the Application

Naming Assemblies

Loading Assemblies

Metadata

Cross-Language Compatibility

Summary

Chapter 3: C# Syntax Overview

C# Is a Strongly Typed Language

Expressions

Statements and Expressions

Types and Variables

Value Types

Enumerations

Flags Enumerations

Reference Types

Default Variable Initialization

Implicitly Typed Local Variables

THE COMPLEXITY OF ADDING NEW KEYWORDS TO THE LANGUAGE

Type Conversion

Array Covariance

Boxing Conversion

as and is Operators

Generics

Namespaces

Defining Namespaces

Using Namespaces

Control Flow

if-else, while, do-while, and for

switch

foreach

break, continue, goto, return, and throw

Summary

Chapter 4: Classes, Structs, and Objects

Class Definitions

Fields

Constructors

Methods

Static Methods

Instance Methods

Properties

Declaring Properties

Accessors

Read-Only and Write-Only Properties

Auto-Implemented Properties

Encapsulation

Accessibility

Interfaces

Inheritance

Accessibility of Members

Implicit Conversion and a Taste of Polymorphism

Member Hiding

The base Keyword

sealed Classes

abstract Classes

Nested Classes

Indexers

partial Classes

partial Methods

Static Classes

THE SINGLETON PATTERN

Reserved Member Names

Reserved Names for Properties

Reserved Names for Indexers

Reserved Names for Destructors

Reserved Names for Events

Value Type Definitions

Constructors

The Meaning of this

Finalizers

Interfaces

Anonymous Types

Object Initializers

Boxing and Unboxing

When Boxing Occurs

Efficiency and Confusion

System.Object

Equality and What It Means

The IComparable Interface

Creating Objects

The new Keyword

Using new with Value Types

Using new with Class Types

Field Initialization

Static (Class) Constructors

Instance Constructor and Creation Ordering

Destroying Objects

Finalizers

Deterministic Destruction

Exception Handling

Disposable Objects

The IDisposable Interface

The using Keyword

Method Parameter Types

Value Arguments

ref Arguments

out Parameters

param Arrays

Method Overloading

Optional Arguments

Named Arguments

Inheritance and Virtual Methods

Virtual and Abstract Methods

override and new Methods

sealed Methods

A Final Few Words on C# Virtual Methods

Inheritance, Containment, and Delegation

Choosing Between Interface and Class Inheritance

Delegation and Composition vs. Inheritance

Summary

Chapter 5: Interfaces and Contracts

Interfaces Define Types

Defining Interfaces

INTERFACES DEFINE CONTRACTS

What Can Be in an Interface?

Interface Inheritance and Member Hiding

Implementing Interfaces

Implicit Interface Implementation

Explicit Interface Implementation

Overriding Interface Implementations in Derived Classes

Beware of Side Effects of Value Types Implementing Interfaces

PREFER THE CONVERT CLASS OVER ICONVERTIBLE

Interface Member Matching Rules

Explicit Interface Implementation with Value Types

Versioning Considerations

Contracts

Contracts Implemented with Classes

Interface Contracts

Choosing Between Interfaces and Classes

Summary

Chapter 6: Overloading Operators

Just Because You Can Doesn’t Mean You Should

Types and Formats of Overloaded Operators

Operators Shouldn’t Mutate Their Operands

Does Parameter Order Matter?

Overloading the Addition Operator

Operators That Can Be Overloaded

Comparison Operators

Conversion Operators

THE FLOATING POINT ENIGMA

Boolean Operators

Summary

Chapter 7: Exception Handling and Exception Safety

How the CLR Treats Exceptions

Mechanics of Handling Exceptions in C#

Throwing Exceptions

Changes with Unhandled Exceptions Starting with .NET 2.0

Syntax Overview of the try, catch, and finally Statements

Rethrowing Exceptions and Translating Exceptions

Exceptions Thrown in finally Blocks

Exceptions Thrown in Finalizers

Exceptions Thrown in Static Constructors

Who Should Handle Exceptions?

Avoid Using Exceptions to Control Flow

Achieving Exception Neutrality

Basic Structure of Exception-Neutral Code

Constrained Execution Regions

Critical Finalizers and SafeHandle

Creating Custom Exception Classes

Working with Allocated Resources and Exceptions

Providing Rollback Behavior

Summary

Chapter 8: Working with Strings

String Overview

String Literals

Format Specifiers and Globalization

Object.ToString, IFormattable, and CultureInfo

Creating and Registering Custom CultureInfo Types

Format Strings

Console.WriteLine and String.Format

Examples of String Formatting in Custom Types

ICustomFormatter

Comparing Strings

Working with Strings from Outside Sources

StringBuilder

Searching Strings with Regular Expressions

Searching with Regular Expressions

Searching and Grouping

Replacing Text with Regex

Regex Creation Options

Summary

Chapter 9: Arrays, Collection Types, and Iterators

Introduction to Arrays

Implicitly Typed Arrays

Type Convertibility and Covariance

Sortability and Searchability

Synchronization

Vectors vs. Arrays

Multidimensional Rectangular Arrays

Multidimensional Jagged Arrays

Collection Types

Comparing ICollection with ICollection

Collection Synchronization

Lists

Dictionaries

Sets

System.Collections.ObjectModel

Efficiency

IEnumerable, IEnumerator, IEnumerable, and IEnumerator

Types That Produce Collections

Iterators

Forward, Reverse, and Bidirectional Iterators

Collection Initializers

Summary

Chapter 10: Delegates, Anonymous Functions, and Events

Overview of Delegates

Delegate Creation and Use

Single Delegate

Delegate Chaining

Iterating Through Delegate Chains

Unbound (Open Instance) Delegates

Events

Anonymous Methods

Captured Variables and Closures

Beware the Captured Variable Surprise

Anonymous Methods as Delegate Parameter Binders

The Strategy Pattern

Summary

Chapter 11: Generics

Difference Between Generics and C++ Templates

Efficiency and Type Safety of Generics

GENERIC TYPE PLACEHOLDER NAMING CONVENTIONS

Generic Type Definitions and Constructed Types

Generic Classes and Structs

Generic Interfaces

Generic Methods

Generic Delegates

Generic Type Conversion

Default Value Expression

Nullable Types

Constructed Types Control Accessibility

Generics and Inheritance

Constraints

Constraints on Nonclass Types

Co- and Contravariance

Covariance

Contravariance

Invariance

Variance and Delegates

Generic System Collections

Generic System Interfaces

Select Problems and Solutions

Conversion and Operators within Generic Types

Creating Constructed Types Dynamically

Summary

Chapter 12: Threading in C#

Threading in C# and .NET

Starting Threads

Passing Data to New Threads

Using ParameterizedThreadStart

The IOU Pattern and Asynchronous Method Calls

States of a Thread

Terminating Threads

Halting Threads and Waking Sleeping Threads

Waiting for a Thread to Exit

Foreground and Background Threads

Thread-Local Storage

How Unmanaged Threads and COM Apartments Fit In

Synchronizing Work Between Threads

Lightweight Synchronization with the Interlocked Class

INTERLOCKED METHODS ON SMP SYSTEMS

SpinLock Class

Monitor Class

Beware of Boxing

Pulse and Wait

Locking Objects

ReaderWriterLock

ReaderWriterLockSlim

Mutex

Semaphore

Events

Win32 Synchronization Objects and WaitHandle

Using ThreadPool

Asynchronous Method Calls

Timers

Concurrent Programming

Task Class

Parallel Class

Easy Entry to the Thread Pool

Thread-Safe Collection Classes

Summary

Chapter 13: In Search of C# Canonical Forms

Reference Type Canonical Forms

Default to sealed Classes

Use the Non-Virtual Interface (NVI) Pattern

Is the Object Cloneable?

Is the Object Disposable?

Does the Object Need a Finalizer?

What Does Equality Mean for This Object?

Reference Types and Identity Equality

Value Equality

Overriding Object.Equals for Reference Types

If You Override Equals, Override GetHashCode Too

Does the Object Support Ordering?

Is the Object Formattable?

Is the Object Convertible?

Prefer Type Safety at All Times

Using Immutable Reference Types

Value Type Canonical Forms

Override Equals for Better Performance

Do Values of This Type Support Any Interfaces?

Implement Type-Safe Forms of Interface Members and Derived Methods

Summary

Checklist for Reference Types

Checklist for Value Types

Chaper 14: Extension Methods

Introduction to Extension Methods

How Does the Compiler Find Extension Methods?

Under the Covers

Code Readability versus Code Understandability

Recommendations for Use

Consider Extension Methods Over Inheritance

Isolate Extension Methods in Separate Namespace

Changing a Type’s Contract Can Break Extension Methods

Transforms

Operation Chaining

Custom Iterators

Borrowing from Functional Programming

The Visitor Pattern

Summary

Chaper 15: Lambda Expressions

Introduction to Lambda Expressions

Lambda Expressions and Closures

Closures in C# 1.0

Closures in C# 2.0

Lambda Statements

Expression Trees

Operating on Expressions

Functions as Data

Useful Applications of Lambda Expressions

Iterators and Generators Revisited

More on Closures (Variable Capture) and Memoization

Currying

Anonymous Recursion

Summary

Chaper 16: LINQ: Language Integrated Query

A Bridge to Data

Query Expressions

Extension Methods and Lambda Expressions Revisited

Standard Query Operators

C# Query Keywords

The from Clause and Range Variables

The join Clause

The where Clause and Filters

The orderby Clause

The select Clause and Projection

The let Clause

The group Clause

The into Clause and Continuations

The Virtues of Being Lazy

C# Iterators Foster Laziness

Subverting Laziness

Executing Queries Immediately

Expression Trees Revisited

Techniques from Functional Programming

Custom Standard Query Operators and Lazy Evaluation

Replacing foreach Statements

Summary

Chaper 17: Dynamic Types

What does dynamic Mean?

How Does dynamic Work?

The Great Unification

Call Sites

Objects with Custom Dynamic Behavior

Efficiency

Boxing with Dynamic

Dynamic Conversions

Implicit Dynamic Expressions Conversion

Dynamic Overload Resolution

Dynamic Inheritance

You Cannot Derive from dynamic

You Cannot Implement dynamic Interfaces

You Can Derive From Dynamic Base Types

Duck Typing in C#

Limitations of dynamic Types

ExpandoObject: Creating Objects Dynamically

Summary

Index