Introducing Visual C# 2010

Title Page

Copyright Page

Contents at a Glance

Table of Contents

About the Authors

About the Technical Reviewers

Acknowledgments

PART 1 Getting Started

Chapter 1 Introduction

Who Should Read This Book?

What Is Covered in This Book?

What Do You Need to Read This Book?

What Is the Structure of This Book?

What Is in Each Chapter?

Getting the Example Code

Finding More Information

The MSDN C# Programming Guide

Online Forums

Other Books

Summary

Chapter 2 Getting Ready

Installing the Software

Installing Visual Studio 2010

Installing SQL Server 2008

Installing the Silverlight Tools

Downloading the Sample Code and Data

Creating Your First C# Project

Creating the Project

Editing the Code

Compiling and Running the Program

Features That I Use Before Explaining Them

The using statements

The namespace statement

The class statement

The Main method

The Code Comments

The Console.WriteLine and Console.ReadLine methods

Summary

Chapter 3 Understanding C# and the .NET Framework

C# and the .NET Framework at a Glance

Introducing C#

Introducing the .NET Framework

Introducing the Common Language Runtime

Introducing the Class Library

The Relationship between C# and the .NET Framework

Using C# Code Files

Understanding Assemblies

The Key Features of C# and the .NET Framework

Understanding Object-Orientation

Understanding Type Safety

Understanding Automatic Memory Management

Understanding the Just-In-Time Compiler

Understanding Parallel Processing

Understanding Unmanaged/Native Code Support

Understanding the .NET Technology Spectrum

Understanding ASP.NET

Understanding LINQ

Understanding the Task Parallel Library

Understanding User Interfaces

Understanding ADO.NET

Understanding the Windows Communication Foundation

Understanding .NET Cross-Platform Support

Summary

PART 2 The C# Language

Chapter 4 C# Fundamentals and Keyword Reference

Language Fundamentals

A Simple C# Program

C# Syntax

Identifiers

Keywords

Literals

Operators

Punctuators

Statements

Comments

Types

Value Types

Reference Types

Definite Assignment and Null References

Common Programming Tasks

Assigning Values

Making Comparisons

Performing Selections

Using an if Statement

Using a switch Statement

Iterating Data Items

Using a for Loop

Using a foreach Loop

Using a do...while Loop

Using a while Loop

Keyword and Operator Reference

Type Keywords

bool

byte, sbyte

char

class

decimal, double, float

delegate

dynamic

enum

interface

object

string

struct

short, ushort, int, uint, long, ulong

void

var

Modifiers

public, protected, private, internal

abstract

const

event

in, out

override

readonly

sealed

static

virtual

Selection Keywords

if, else

switch, case, default

Iterator Keywords

for

foreach

do, while

Jump Keywords

break

continue

goto

return

Exception Handling Keywords

throw

try, catch, finally

Arithmetic Overflow Keywords

checked, unchecked

Synchronization Keywords

lock

Parameter Keywords

params

ref

out

Namespace Keywords

namespace

using

Literal Keywords

null

true, false

Object Keywords

is, as

new

typeof

LINQ Keywords

Other Keywords

base

get, set, value

global

implicit, explicit

operator

partial

using

this

yield

Operators

[ ] Operator

( ) Operator

Dot (.) Operator

:: Operator

+, -, *, /, % Operators

==, !=, >, >=, <, <= Operators

++, +=, --, -= Operators

&&, || Operators

&, |, ^,

121

=> Operator

=, +=, -=, *=, /=, %=, &=, >>=, <<=, ^= Operators

Summary

Chapter 5 Numeric and Boolean Types

Numeric Types

Using Numeric Literals

Using Literal Suffixes

Using Literal Prefixes

Implicit and Explicit Numeric Type Conversions

Using Overflow Checking

Using Struct Members

Common Members

Using Type-Specific Members

Using Numeric Operators

Arithmetic Operators

Unary Operators

Relational Operators

Logical Operators

Assignment Operators

Working with Very Large Integer Values

The Boolean Type

Using Boolean Literals

Using Boolean Results

Using Struct Members

Summary

Chapter 6 Classes and Objects

Creating a Basic Class

Adding Features to a Class

Adding Fields

Adding Methods

Adding a Constructor

Creating Objects from Classes

Using Objects

Reading and Modifying Fields

References to Common Objects

Using Static Fields

Calling Methods

Class Inheritance

Understanding Inheritance

Overriding Methods

Inheriting Derivations

Understanding Encapsulation

Understanding Polymorphism

Casting Objects and Type Checking

Implicit vs. Explicit Casting

Type Conversion Exceptions

Avoiding Explicit Cast Exceptions

Testing an Object’s Type

Casting Without Exceptions

Boxing and Unboxing

Using Nested Classes

Using Class Modifiers

Creating Static Classes

Creating Abstract Classes

Creating Sealed Classes

Creating Partial Classes

Using Access Modifiers

Summary

Chapter 7 Fields

Defining and Using Fields

Defining Fields

Initializing Fields

Reading and Updating Fields

Working Directly with Field Values

Allowing Other Classes to Read and Modify Properties

Exposing Properties with Field Values

Understanding Reference Type Fields

The Fourth Stage of the Life Cycle

Applying Field Modifiers

Creating Static Fields

Creating Read-Only Fields

Using the const keyword

Using the readonly Keyword

Applying Access Modifiers

Hiding Base Class Fields

Using the volatile Keyword

Summary

Chapter 8 Properties, Indexers, and Operators

Creating a Property

Creating a Field-Backed Property

Using a Property

Creating an Automatically Implemented Property

Creating an Asymmetric Property

Creating a Computed Property

Mapping a Property Type to a Field Type

Using Access Modifiers

Using Other Modifiers

Using the virtual and override Modifiers

Using the abstract Modifier

Using the sealed Keyword

Using the static Keyword

Creating an Indexer

Using Multiple Indexers

Creating a Validating Indexer

Creating an Indexer with Multiple Arguments

Creating Custom Operators

Creating Custom Unary Operators

Creating Custom Binary Operators

Creating Custom Conversion Operators

Summary

Chapter 9 Methods

Creating and Using a Simple Method

Defining the Method Name

Defining the Result Type

Defining the Parameters

Defining the Modifiers

Defining the Method Body

Using the Methods

Understanding Parameters

Using Value Parameters

Using Reference Parameters

Using Output Parameters

Using Parameter Arrays

Using Optional Parameters

Using Named Parameters

Understanding Method Bodies

Using Local Variables

Naming Variables

Understanding Variable Scope and Lifetime

Using Method Results

Understanding Method Modifiers

Using Access Modifiers

Creating Static Methods

Creating Virtual Methods

Creating Sealed Methods

Creating Abstract Methods

Overloading Methods

Hiding and Overriding Methods

Hiding Methods

Overriding Methods

Sealing Methods

Understanding Method Specialization

Special Methods

The Main Method

Constructors

Using the Default Constructor

Initializing Properties and Fields at Construction

Overloading Constructors

Calling Base Class Constructors

Controlling Access to Constructors

Creating Copy Constructors

Using Static Constructors

Creating Factory Methods

Destructors

Iterator Blocks

Using the yield Keyword

Exposing Field Iterators

Using Multiple yield Statements

Using Named Iterator Blocks

Partial Methods

Abstract Methods

Extension Methods

Summary

Chapter 10 Delegates, Events, and Anonymous Methods

Using Delegates

Using Delegates for Callbacks

Multicasting with Delegates

Delegating Selectively

Interrogating Delegates

Using Events

Defining and Publishing EventHandler Pattern Events

Creating Nongeneric Events

Creating Events Without Custom Data

Applying Modifiers to Events

Using Action and Func Delegates

Using Action Delegates

Using Func Delegates

Anonymous Methods

Capturing Outer Variables

Lambda Expressions

Summary

Chapter 11 Namespaces

Consuming Namespaces

Using Fully Qualified Names

Importing Namespaces

Creating Namespaces

Nesting Namespaces

Logically Nesting Namespaces

Spreading Namespaces Across Files

Adding Types to Existing Namespaces

Disambiguating Namespaces and Types

Disambiguation with Fully Qualified Names

Disambiguating with Aliases

Aliasing Namespaces

Resolving Type or Namespace Hiding

Summary

Chapter 12 Interfaces, Structs, and Enums

Using Interfaces

Defining and Using a Simple Interface

Defining an Interface

Implementing an Interface

Using an Interface

Specifying Interface Members

Specifying Methods

Specifying Properties

Specifying an Event

Specifying an Indexer

Deriving Interfaces

Deriving from Multiple Base Interfaces

Defining a Partial Interface

Implementing Interfaces

Implementing Multiple Interfaces

Explicitly Implementing an Interface

Inheriting Interface Implementations

Implementing an Interface in an Abstract Class

Using Structs

Defining and Instantiating a Struct

Implementing Interfaces

Differences Between Structs and Classes

Base Structs and Inheritance

Defining Fields

Defining a Struct Constructor

Copying a Struct

Using an Enum

Defining an Enum

Using an Enum

Using Underlying Types and Numeric Values

Combining Enum Values

Summary

Chapter 13 Arrays

Defining and Initializing Arrays

Getting and Setting Array Values

Using Array Initializers

Enumerating Arrays

Enumerating with a for Loop

Enumerating with a foreach Loop

Enumerating Using IEnumerator and IEnumerator

Breaking from Enumerations

Using System.Array Members

Sorting Arrays

Processing All of the Elements in an Array

Resizing and Copying an Array

Finding Items in an Array

Using Arrays with LINQ

Using Arrays as Collections

Using Multidimensional Arrays

Using Rectangular Arrays

Getting and Setting Rectangular Array Values

Using Rectangular Array Initializers

Enumerating a Rectangular Array

Creating Rectangular Arrays with Additional Dimensions

Using Jagged Arrays

Getting and Setting Jagged Array Values

Using Jagged Array Initializers

Enumerating a Jagged Array

Summary

Chapter 14 Exceptions

Handling Exceptions

Using try Statements and catch Clauses

Handling Different Exception Types

Using Specific catch Clauses

Using General catch Clauses

Omitting catch Clauses

Nesting try Statements

Using Exception Members

Using finally Clauses

Throwing Exceptions

Rethrowing Exceptions

Creating and Throwing Custom Exceptions

Throwing Meaningful Exceptions

Mapping One Exception Type to Another

Creating Exception Chains

Aggregating Exceptions

Summary

Chapter 15 Generic and Anonymous Types

Using Generic Types

Defining a Generic Class

Creating Objects from Generic Classes

Implementing and Using Generic Class Members

Defining Multiple Parameter Types

Casting from Parameterized Types

Constraining Parameterized Types

Applying Multiple Constrains to a Parameterized Type

Constraining Multiple Parameterized Types

Defining a Method-Specific Parameterized Type

Deriving from a Generic Base Class

Inheriting Type Deferral

Specifying Parameterized Types

Creating Generic Interfaces

Creating Generic Structs

Type Variance

Covariance

Contravariance

Combining Contravariance and Covariance

Using the default Keyword

Using Anonymous Types

Summary

Chapter 16 Strings and Characters

Working with Characters

Expressing Characters Using Literals

Performing Operations on Characters

Using Struct Members

Using Strings

Expressing Strings Using String Literals

Using String Escape Sequences and Verbatim Literals

Performing Operations on Strings

Comparing Strings

Combining Strings

Reading Individual Characters

Enumerating a String

Using Strings in a switch Statement

Using Regular Expressions

Using Class Members

Manipulating Strings

Searching Strings

Other Class Members

Using the StringBuilder Class

Creating a StringBuilder Object

Using a StringBuilder Object

Using the Append and Insert Methods

Using the StringBuilder Indexer

Formatting Strings

Using Composite Formatting

Other Composite Formatting Methods

Specifying Alignment

Escaping Braces

Formatting Types

Using a Format Component

Creating String Representations of Custom Types

Performing Custom Composite Formatting

Summary

Chapter 17 Attributes

Using Attributes

Applying Attributes with Parameters

Testing for an Attribute

Testing for an Attribute Applied to a Class

Testing for an Attribute Applied to a Field

Testing for an Attribute Applied to a Property

Testing for an Attribute Applied to a Method

Creating a Custom Attribute

Using a Custom Attribute

Defining Properties in a Custom Attribute

Controlling How a Custom Attribute Can Be Used

Controlling Attribute Inheritance

Summary

Chapter 18 Garbage Collection

Explicitly Running the Garbage Collector

Implementing a Destructor

Destructors vs. Finalizers

Problems with Destructors

Performance Impact

Uncertain Execution

Uncertain Ordering

Using Disposal

Using Weak References

Summary

PART 3 The .NET Class Library

Chapter 19 Collections

The ICollection Interface

Generic Lists

The IList Interface

The List Collection

Adding, Retrieving, and Removing Items

Finding List Items

Sorting List Items

Processing Items

Other List Members

The LinkedList Collection

Adding, Retrieving, and Removing Items

Finding List Items

The SortedList Collection

Adding, Retrieving, and Removing Items

Other SortedList Members

Generic Dictionaries

The IDictionary Interface

The KeyValuePair Structure

The Dictionary Collection

Adding, Retrieving, and Removing Items

Other Dictionary Members

The SortedDictionary Collection

Generic Sets

The ISet Interface

The HashSet Collection

The SortedSet Collection

Generic Queues and Stacks

The Queue Collection

The Stack Collection

Other Generic Collection Interfaces

The IComparer Interface

The IEqualityComparer Interface

Treating Arrays as Collections

Creating Constrained Collections

Read-Only Lists

Other Read-Only Collections

Legacy Collections

Summary

Chapter 20 Files, Streams, and IO

Working with Files and Directories

Using the System.IO.Directory Class

Enumerating Files and Directories

Getting and Setting Information for a File or Directory

Changing the Current Working Directory

Using the FileInfo and DirectoryInfo Classes

Using the FileInfo Class

Using the DirectoryInfo Class

Using the System.IO.File Class

Using the File Convenience Methods

Using the Stream, Reader, and Writer Methods

Using the System.IO.Path Class

Monitoring for Changes

Filtering the Monitored Files and Directories

Filtering the Triggers for a Change Event

Working with Streams, Readers, and Writers

Using Streams

Using the System.IO.Stream Class (in Detail)

Using Base Streams

Using Pass-Through Streams

Using Readers and Writers

Reading and Writing Binary Data

Reading and Writing Textual Data

Summary

Chapter 21 Networking & WCF

Requesting Data

Using WebClient Members to Configure a Request

Using WebClient Members to Retrieve Data

Getting the WebClient Response Headers

Using WebClient Events

Programming with Sockets

Creating a Simple TCP Client & Server

Creating the Server

Creating the Client

Writing a Parallel Server

The Windows Communication Foundation

Creating the WCF Server

Creating the Service Contract

Creating the WCF Client

Other Useful Network Classes

Writing a Simple Web Server

Using Connectionless Networking

Using the Domain Name System

Summary

Chapter 22 Time & Dates

Measuring Small Amounts of Time

Working with Periods of Time

Creating and Using TimeSpan Values

Performing Operations on TimeSpan Values

Formatting TimeSpan Strings

Creating Custom TimeSpan Format Strings

Working with Particular Dates and Times

Creating and Using DateTime Values

Performing Operations on DateTime Values

Formatting DateTime Strings

Creating Custom DateTime Format Strings

Summary

Chapter 23 Serialization

Using Binary Serialization

Serializing Graphs of Objects

Serializing Multiple Objects to a Single Stream

Selectively Serializing Fields

Using Serialization Callbacks

Version Tolerance

Adding Tolerance for Specific Changes

Using SOAP Serialization

Version Tolerance

Serializing Generic Objects

Using XML Serialization

Selectively Serializing Fields

Mapping Members to Elements and Attributes

Changing the Name for Attributes and Elements

Using Data Contract Serialization

Preparing a Class for Data Contract Serialization

Generating Portable XML

Generating .NET-specific XML

Generating JSON

Summary

Chapter 24 Serialization

Understanding Single- and Multi-Threaded Execution

Getting Started with Tasks

Creating a Task

Starting a Task

Waiting for a Task

Getting Results from Tasks

Passing Parameters to a Task

Getting the Status of a Task

Using the Status Properties

Canceling Tasks

Checking and Throwing in a Single Statement

Cancelling Multiple Tasks

Handling Task Exceptions

Handling an Exception in a Task Body

Handling an Exception from a Trigger Method

Handling Exceptions from Multiple Tasks

Dealing with Exceptions using Task Properties

Using a Custom Exception Escalation Policy

Chaining Tasks Together

Creating a Simple Continuation

Getting Details of the Antecedent

Providing a Continuation Result

Creating Chains of Continuations

Creating Selective Continuations

Sharing Data between Tasks

Understanding a Critical Region

Creating a Critical Region

Avoiding Synchronization

Using Concurrent Collections

Summary

Chapter 25 Asynchronous Methods and Parallel Loops

Using Asynchronous Methods

Using Pre-Built Asynchronous Methods

Asynchronously Calling Any Method

Waiting for an Asynchronous Method to Complete

Mixing Asynchronous Methods and Tasks

Using Parallel Loops

Creating a Parallel ForEach Loop

Creating a Parallel For Loop

Breaking and Stopping Parallel Loops

Summary

Chapter 26 Other Useful Features and Classes

Converting Between Types

Returning Multiple Results from Methods Using Tuples

Aliasing Generic Types

Using Nullable Types

Using the Null-Coalescing Operator

Working with the Console

Reading from and Writing to the Console

Making the Console Beep

Modifying the Appearance of the Console

Generating Random Numbers

Converting Strings to and from Bytes

Getting Environment Information

Performing Math Operations

Using Conditional Compilation

Using Visual Studio to Define Symbols

Conditionally Compiling Methods

Checking Network Connectivity

Listening for Connectivity Changes

Summary

PART 4 Data and Databases

Chapter 27 LINQ to Objects

Performing a Simple LINQ Query

Understanding LINQ to Objects Data Sources

Enumerating Results Manually

Using Results as Data Sources

Understanding Query Results

The Range Variable Type

The Result Type

Explicitly Specifying the Range Variable Type

Letting the Compiler Infer Types

Performing LINQ Operations

Filtering Data

Projecting Data

Projecting a Single Member

Projecting Anonymous Types

Projecting Derived Data

Ordering Data

Grouping Data

Grouping Using a Boolean Value

Grouping Using an Anonymous Type

Querying Grouped Data

Using Method Syntax

Understanding Deferred Execution

Reusing Queries

Referring to Variables

Forcing Immediate Execution

Converting Query Results

Using Legacy Collections as LINQ Data Sources

Explicitly Specifying the Range Variable Type

Using Cast and OfType Extension Methods

Performing Advanced LINQ Operations

Aggregating Data

Joining Data

Creating Combinations of Data

Creating Additional Range Variables

Summary

Chapter 28 Parallel LINQ

Performing a Parallel LINQ Query

Understanding PLINQ Result Ordering

Preserving Order in a PLINQ query

Forcing Parallel Execution

Performing Queries without Results

Summary

Chapter 29 LINQ to XML

Using the LINQ XML Classes

Creating XML Declaratively

Using Arbitrary Types to Create XElements

Creating Other XML Node Types

Creating Valid XML Documents

Populating an XElement or XDocument with an IEnumerable

Reading and Writing XML Files

Saving XML

Loading XML

Processing XML Declaratively

Filtering Elements by Name

Finding All Descendants

Modifying XML

Using LINQ to XML Queries

Querying XML for Data

Creating XML from LINQ Queries

Create Objects from XML

Modifying and Transforming XML Data

Adding Elements to XML

Creating a CSV File from XML

Creating XML from CSV Data

Changing and Deleting Elements

Sorting XML

Grouping XML

Using Parallel LINQ to Process XML

Summary

Chapter 30 LINQ to Entities

Getting Ready

Preparing the Database

Creating the Model

Using LINQ to Entities

Using the Data Model Context

Using Table Properties and Row Objects

Understanding the IQueryable Interface

Enumerating the Results

Navigating Using Foreign Key Relationships

Querying Using Navigation Properties

Using Navigation Data Efficiently

Performing Common Database Operations

Querying Data

Compiling Queries

Querying Views

Querying Stored Procedures

Inserting Data into the Database

Inserting Attached Objects

Updating Data in the Database

Deleting Data

Enabling Concurrency Checking

Summary

Chapter 31 LINQ to DataSet

Connecting to and Querying a Database

Setting Up the Database

Creating a Connection to the Database

Storing Connection Strings

Executing a SQL Query

Understanding the DataSet Class

Enumerating Results with DataTable and DataRow Objects

Querying DataSets with LINQ

Perform Joins on a DataSet

Comparing Data

Querying for Data Intersects

Subtracting Results

Performing Database Operations Using Cached Data

Inserting Data

Modifying Data

Deleting Data

Summary

PART 5 User Interfaces

Chapter 32 Windows Forms

Building a Stand-Alone Window Forms Program

Creating the Project

Adding the Controls

Setting the Control Properties

Configuring the Labels

Configuring the TextBoxes and NumericUpDowns

Configuring the Button

Adding the MenuStrip and StatusStrip

Setting the Control Names

Setting the Tab Order

Wiring the Controls

Wiring the Quit Menu

Wiring the TextBoxes

Wiring the Button

Setting the Icon

Testing the Program

Using Windows Forms Data Binding

Creating the Project and Creating the Data Model

Creating and Using the Object Data Source

Formatting the Grid Control

Loading the Data

Wiring the Save Button

Testing the Program

Two Program Variations

Filtering the Data with LINQ

Displaying Data Fields

Windows 7 UI Integration

Using Aero Glass

Summary

Chapter 33 Windows Presentation Foundation

Building a Stand-Alone WPF Program

Creating the Project

Adding the Controls

Setting the Control Properties

Configuring the Label Controls

Configuring the TextBox Controls

Configuring the TextBlock Control

Configuring the Button

Adding the StatusBar Item

Adding the StatusBar Item

Adding the Menu Item

Setting the Tab Order

Wiring the Controls

Wiring the Quit Menu

Wiring the TextBox Controls

Wiring the Button

Managing the Focus

Focusing on the First Control

Selecting the TextBox Text on Focus

Setting the Program Icon and Window Name

Testing the Program

Using WPF Data Binding

Formatting the DataGrid Control

Loading the Data

Wiring the Button

Testing the Program

Using WPF-Specific Features

Using WPF Animations

Creating the Project

Adding the Animation

Testing the Animation

Combining Multiple Animations

Using WPF Commands

Creating the Project

Configuring the Button Controls

Adding and Configuring the MenuItem Control

Binding the Command

Selectively Activating the Command

Using Commands to Set Control Content

Summary

Chapter 34 ASP.NET

Building a Web Forms Program

Creating the Project

Adding the Controls

Setting the Control Properties

Configuring the Labels

Configuring the TextBox Controls

Configuring the Button

Setting the Tab Order

Wiring the Button Control

Setting the Focus

Testing the Program

Using Web Forms Data Binding

Create the Project and the Entity Data Model

Adding the Web Form

Creating the Web Forms Data Source

Adding the GridView Control

Testing the Program

Using ASP.NET Dynamic Data

Creating the Project

Creating the Entity Data Model

Registering the Data Model

Testing the Program

Customizing a Dynamic Data Application

Changing the Name of a Table

Changing the Name and Visibility of a Column

Selecting Tables to Be Displayed

Customizing the Display Template

Summary

Chapter 35 Silverlight

Creating the Swimming Calculator

Creating the Project

Defining the Layout

Adding Grid Columns

Adding the StackPanel Controls

Adding the TextBox Controls

Adding the Label Controls

Adding the TextBlock Control

Adding the Button Control

Adjusting the Layout

Wiring the Button

Adding a Child Window

Using a WCF RIA Service

Creating the Project

Creating the Data Model

Creating the Domain Service Class

Creating the Silverlight Client

Adding the Data

Configuring the DataGrid Control

Configuring the ComboBox Control

Wiring the ComboBox Control

Testing the Application

Using Silverlight Out-of-Browser Support

Configuring the Out-of-Browser Support

Using a Silverlight Program Out-of-Browser

Making Installation Part of the Interface

Using Other Out-of-Browser Features

Summary

PART 6 Advanced Topics

Chapter 36 Windows Integration

Using the Windows Event Log

Reading an Event Log

Writing to an Event Log

Creating the Event Source

Writing Events

Using Elevated Privileges

Creating a Windows Service

Creating the Service Class

Adding the Service Functionality

Adding the Service Installer

Add the MSI Installer

Installing the Service

Creating the Client

Using the Windows Registry

Searching the Registry

Reading and Modifying the Registry

Summary

Chapter 37 Cryptography and Security

Encrypting and Decrypting Data

Creating and Using Encryption Keys

Encrypting Data

Decrypting Data

Using the Windows Data Protection API

Using Hash Codes

Generating a Hash Code

Verifying a Hash Code

Generating Secure Random Numbers

Working Securely with Strings

Summary

Chapter 38 Testing and Debugging

Using the Debug and Trace Classes

Using the Debug Class

Making Assertions

Disabling Debug Statements

Using Debug Listeners

Other Debug Methods

Using the Trace Class

Using Static Code Analysis

Selecting the Code Analysis Rules

Performing Static Analysis

Dealing with a Rule Violation

Suppressing a Single Occurrence

Suppressing Every Occurrence

Using Code Contracts

Installing and Enabling Code Contract Support

Writing Code Contracts

Using Precondition Contracts

Using Postcondition Contracts

Using Assertion Contracts

Using Invariant Contracts

Using the Static Checker

Using the Runtime Checker

Summary

Index