Pro C# 2008 and the .NET 3.5 Platform

Contents

About the Author

About the Technical Reviewer

Acknowledgments

Introduction

We’re a Team, You and I

An Overview of This Book

Diving Even Deeper with Five Free Chapters

Obtaining This Book’s Source Code

Obtaining Updates for This Book

Contacting Me

Introducing C# and the . NET Platform

The Philosophy of .NET

Understanding the Previous State of Affairs

The . NET Solution

Introducing the Building Blocks of the . NET Platform ( the CLR, CTS, and CLS)

Additional . NET- Aware Programming Languages

An Overview of . NET Assemblies

Understanding the Common Type System

Understanding the Common Language Specification

Understanding the Common Language Runtime

The Assembly/ Namespace/ Type Distinction

Exploring an Assembly Using ildasm. exe

Exploring an Assembly Using Lutz Roeder’s Reflector

Deploying the . NET Runtime

The Platform- Independent Nature of . NET

Summary

Building C# Applications

The Role of the . NET Framework 3.5 SDK

Building C# Applications Using csc. exe

Building . NET Applications Using TextPad

Building . NET Applications Using Notepad++

Building . NET Applications Using SharpDevelop

Building . NET Applications Using Visual C# 2008 Express

Building . NET Applications Using Visual Studio 2008

A Partial Catalog of Additional . NET Development Tools

Summary

Core C# Programming Constructs

Core C# Programming Constructs, Part I

The Anatomy of a Simple C# Program

An Interesting Aside: Some Additional Members of the System. Environment Class

The System. Console Class

System Data Types and C# Shorthand Notation

Understanding the System. String Type

Narrowing and Widening Data Type Conversions

C# Iteration Constructs

Decision Constructs and the Relational/ Equality Operators

Summary

Core C# Programming Constructs, Part II

Methods and Parameter Modifiers

Understanding Member Overloading

Array Manipulation in C#

Understanding the Enum Type

Understanding the Structure Type

Understanding Value Types and Reference Types

Value and Reference Types: Final Details

Understanding C# Nullable Types

Summary

Defining Encapsulated Class Types

Introducing the C# Class Type

Understanding Class Constructors

The Role of the this Keyword

Understanding the static Keyword

Defining the Pillars of OOP

C# Access Modifiers

The First Pillar: C#’s Encapsulation Services

Understanding Constant Data

Understanding Read- Only Fields

Understanding Partial Types

Documenting C# Source Code via XML

Visualizing the Fruits of Our Labor

Summary

Understanding Inheritance and Polymorphism

The Basic Mechanics of Inheritance

Revising Visual Studio Class Diagrams

The Second Pillar: The Details of Inheritance

Programming for Containment/ Delegation

The Third Pillar: C#’s Polymorphic Support

Understanding Base Class/ Derived Class Casting Rules

The Master Parent Class: System. Object

Summary

Understanding Structured Exception Handling

Ode to Errors, Bugs, and Exceptions

The Role of . NET Exception Handling

The Simplest Possible Example

Configuring the State of an Exception

System- Level Exceptions ( System. SystemException)

Application- Level Exceptions ( System. ApplicationException)

Processing Multiple Exceptions

The Finally Block

Who Is Throwing What?

The Result of Unhandled Exceptions

Debugging Unhandled Exceptions Using Visual Studio

Summary

Understanding Object Lifetime

Classes, Objects, and References

The Basics of Object Lifetime

The Role of Application Roots

Understanding Object Generations

The System. GC Type

Building Finalizable Objects

Building Disposable Objects

Building Finalizable and Disposable Types

Summary

Advanced C# Programming Constructs

Working with Interfaces

Understanding Interface Types

Defining Custom Interfaces

Implementing an Interface

Invoking Interface Members at the Object Level

Interfaces As Parameters

Interfaces As Return Values

Arrays of Interface Types

Implementing Interfaces Using Visual Studio 2008

Resolving Name Clashes via Explicit Interface Implementation

Designing Interface Hierarchies

Building Enumerable Types ( IEnumerable and IEnumerator)

Building Cloneable Objects ( ICloneable)

Building Comparable Objects ( IComparable)

Understanding Callback Interfaces

Summary

Collections and Generics

The Interfaces of the System. Collections Namespace

The Class Types of System. Collections

System. Collections. Specialized Namespace

The Boxing, Unboxing, and System. Object Relationship

The Issue of Type Safety and Strongly Typed Collections

The System. Collections. Generic Namespace

Creating Custom Generic Methods

Creating Generic Structures and Classes

Creating a Custom Generic Collection

Creating Generic Base Classes

Creating Generic Interfaces

Summary

Delegates, Events, and Lambdas

Understanding the . NET Delegate Type

Defining a Delegate in C#

The System. MulticastDelegate and System. Delegate Base Classes

The Simplest Possible Delegate Example

Retrofitting the Car Type with Delegates

A More Elaborate Delegate Example

Understanding Delegate Covariance

Creating Generic Delegates

Understanding C# Events

The Generic EventHandler< T> Delegate

Understanding C# Anonymous Methods

Understanding Method Group Conversions

The C# 2008 Lambda Operator

Summary

Indexers, Operators, and Pointers

Understanding Indexer Methods

Understanding Operator Overloading

Understanding Custom Type Conversions

Working with Pointer Types

C# Preprocessor Directives

Summary

C# 2008 Language Features

Understanding Implicitly Typed Local Variables

Understanding Automatic Properties

Understanding Extension Methods

Understanding Partial Methods

Understanding Object Initializer Syntax

Understanding Anonymous Types

Summary

An Introduction to LINQ

Understanding the Role of LINQ

A First Look at LINQ Query Expressions

LINQ and Generic Collections

LINQ and Nongeneric Collections

The Internal Representation of LINQ Query Operators

Investigating the C# LINQ Query Operators

LINQ Queries: An Island unto Themselves?

Summary

Programming with .NET Assemblies

Introducing .NET Assemblies

Defining Custom Namespaces

The Role of . NET Assemblies

Understanding the Format of a . NET Assembly

Building and Consuming a Single- File Assembly

Building and Consuming a Multifile Assembly

Understanding Private Assemblies

Understanding Shared Assemblies

Consuming a Shared Assembly

Configuring Shared Assemblies

Investigating the Internal Composition of the GAC

Understanding Publisher Policy Assemblies

Understanding the < codeBase> Element

The System. Configuration Namespace

The Machine Configuration File

Summary

Type Reflection, Late Binding, and Attribute- Based Programming

The Necessity of Type Metadata

Understanding Reflection

Building a Custom Metadata Viewer

Dynamically Loading Assemblies

Reflecting on Shared Assemblies

Understanding Late Binding

Understanding Attributed Programming

Building Custom Attributes

Assembly- Level ( and Module- Level) Attributes

Reflecting on Attributes Using Early Binding

Reflecting on Attributes Using Late Binding

Putting Reflection, Late Binding, and Custom Attributes in Perspective

Building an Extendable Application

Summary

Processes, AppDomains, and Object Contexts

Reviewing Traditional Win32 Processes

Interacting with Processes Under the . NET Platform

Understanding . NET Application Domains

Understanding Object Context Boundaries

Summarizing Processes, AppDomains, and Context

Summary

Building Multithreaded Applications

The Process/ AppDomain/ Context/ Thread Relationship

A Brief Review of the . NET Delegate

The Asynchronous Nature of Delegates

Invoking a Method Asynchronously

The System. Threading Namespace

The System. Threading. Thread Class

Programmatically Creating Secondary Threads

The Issue of Concurrency

Programming with Timer Callbacks

Understanding the CLR ThreadPool

The Role of the BackgroundWorker Component

Summary

Understanding CIL and the Role of Dynamic Assemblies

Reflecting on the Nature of CIL Programming

Examining CIL Directives, Attributes, and Opcodes

Pushing and Popping: The Stack- Based Nature of CIL

Understanding Round- Trip Engineering

Understanding CIL Directives and Attributes

. NET Base Class Library, C#, and CIL Data Type Mappings

Defining Type Members in CIL

Examining CIL Opcodes

Building a . NET Assembly with CIL

Understanding Dynamic Assemblies

Summary

Introducing the .NET Base Class Libraries

File I/O and Isolated Storage

Exploring the System. IO Namespace

The Directory( Info) and File( Info) Types

Working with the DirectoryInfo Type

Working with the Directory Type

Working with the DriveInfo Class Type

Working with the FileInfo Class

Working with the File Type

The Abstract Stream Class

Working with StreamWriters and StreamReaders

Working with StringWriters and StringReaders

Working with BinaryWriters and BinaryReaders

Programmatically “ Watching” Files

Performing Asynchronous File I/ O

Understanding the Role of Isolated Storage

A Primer on Code Access Security

An Overview of Isolated Storage

Obtaining a Store Using IsolatedStorageFile

Isolated Storage in Action: ClickOnce Deployment

Summary

Introducing Object Serialization

Understanding Object Serialization

Configuring Objects for Serialization

Choosing a Serialization Formatter

Serializing Objects Using the BinaryFormatter

Serializing Objects Using the SoapFormatter

Serializing Objects Using the XmlSerializer

Serializing Collections of Objects

Customizing the Serialization Process

Summary

ADO.NET Part I: The Connected Layer

A High- Level Definition of ADO. NET

Understanding ADO. NET Data Providers

Additional ADO. NET Namespaces

The Types of the System. Data Namespace

Abstracting Data Providers Using Interfaces

Creating the AutoLot Database

The ADO. NET Data Provider Factory Model

Understanding the Connected Layer of ADO. NET

Working with Data Readers

Building a Reusable Data Access Library

Creating a Console UI – Based Front End

Asynchronous Data Access Using SqlCommand

Understanding Database Transactions

Summary

ADO.NET Part II: The Disconnected Layer

Understanding the Disconnected Layer of ADO. NET

Understanding the Role of the DataSet

Working with DataColumns

Working with DataRows

Working with DataTables

Binding DataTable Objects to User Interfaces

Filling DataSet/ DataTable Objects Using Data Adapters

Revisiting AutoLotDAL. dll

Navigating Multitabled DataSet Objects

The Data Access Tools of Visual Studio 2008

Decoupling Autogenerated Code from the UI Layer

Summary

Programming with the LINQ APIs

The Role of LINQ to ADO. NET

Programming with LINQ to DataSet

Programming with LINQ to SQL

Generating Entity Classes Using SqlMetal. exe

Building Entity Classes Using Visual Studio 2008

Manipulating XML Documents Using LINQ to XML

Navigating an In- Memory Document

Summary

Introducing Windows Communication Foundation

A Potpourri of Distributed Computing APIs

The Role of WCF

Investigating the Core WCF Assemblies

The Visual Studio WCF Project Templates

The Basic Composition of a WCF Application

The ABCs of WCF

Building a WCF Service

Hosting the WCF Service

Building the WCF Client Application

Using the WCF Service Library Project Template

Hosting the WCF Service As a Windows Service

Invoking a Service Asynchronously

Designing WCF Data Contracts

Summary

Introducing Windows Workflow Foundation

Defining a Business Process

The Building Blocks of WF

WF Assemblies, Namespaces, and Projects

Building a Simple Workflow- Enabled Application

Examining the WF Engine Hosting Code

Invoking Web Services Within Workflows

Building a Reusable WF Code Library

A Brief Word Regarding Custom Activities

Summary

Desktop User Interfaces

Programming with Windows Forms

The Windows Forms Namespaces

Building a Simple Windows Forms Application ( IDE- Free)

The Visual Studio Windows Forms Project Template

The Anatomy of a Form

Responding to Mouse Activity

Responding to Keyboard Activity

Designing Dialog Boxes

Rendering Graphical Data Using GDI+

Building a Complete Windows Forms Application

Summary

Introducing Windows Presentation Foundation and XAML

The Motivation Behind WPF

The Various Flavors of WPF Applications

Investigating the WPF Assemblies

Building a ( XAML- Free) WPF Application

Additional Details of the Application Type

Additional Details of the Window Type

Building a ( XAML- Centric) WPF Application

Transforming Markup into a . NET Assembly

Separation of Concerns Using Code- Behind Files

The Syntax of XAML

Building WPF Applications Using Visual Studio 2008

Processing XAML at Runtime: SimpleXamlPad. exe

The Role of Microsoft Expression Blend

Summary

Programming with WPF Controls

A Survey of the WPF Control Library

Declaring Controls in XAML

Understanding the Role of Dependency Properties

Understanding Routed Events

Working with Button Types

Working with CheckBoxes and RadioButtons

Working with the ListBox and ComboBox Types

Working with Text Areas

Controlling Content Layout Using Panels

Building a Window’s Frame Using Nested Panels

Understanding WPF Control Commands

Understanding the WPF Data- Binding Model

Data Conversion Using IValueConverter

Binding to Custom Objects

Binding UI Elements to XML Documents

Summary

WPF 2D Graphical Rendering, Resources, and Themes

The Philosophy of WPF Graphical Rendering Services

Exploring the Shape- Derived Types

Working with WPF Brushes

Working with WPF Pens

Exploring the Drawing- Derived Types

The Role of UI Transformations

Understanding WPF’s Animation Services

Understanding the WPF Resource System

Defining and Applying Styles for WPF Controls

Altering a Control’s UI Using Templates

Summary

Building Web Applications with ASP. NET

Building ASP.NET Web Pages

The Role of HTTP

Understanding Web Applications and Web Servers

The Role of HTML

The Role of Client- Side Scripting

Submitting the Form Data ( GET and POST)

Building a Classic ASP Page

Problems with Classic ASP

The ASP. NET Namespaces

The ASP. NET Web Page Code Model

Details of an ASP. NET Website Directory Structure

The ASP. NET Page Compilation Cycle

The Inheritance Chain of the Page Type

Interacting with the Incoming HTTP Request

Interacting with the Outgoing HTTP Response

The Life Cycle of an ASP. NET Web Page

The Role of the Web. config File

Summary

ASP.NET Web Controls, Themes, and Master Pages

Understanding the Nature of Web Controls

The System. Web. UI. Control Type

The System. Web. UI. WebControls. WebControl Type

Major Categories of ASP. NET Web Controls

Building a Feature- Rich ASP. NET Website

The Role of the Validation Controls

Working with Themes

Positioning Controls Using HTML Tables

Summary

ASP.NET State Management Techniques

The Issue of State

ASP. NET State Management Techniques

Understanding the Role of ASP. NET View State

The Role of the Global. asax File

Understanding the Application/ Session Distinction

Working with the Application Cache

Maintaining Session Data

Understanding Cookies

The Role of the < sessionState> Element

Understanding the ASP. NET Profile API

Summary

Appendixes

COM and .NET Interoperability

The Scope of . NET Interoperability

A Simple Example of . NET to COM Interop

Investigating a . NET Interop Assembly

Understanding the Runtime Callable Wrapper

The Role of COM IDL

Using a Type Library to Build an Interop Assembly

Building a More Elaborate COM Server

Examining the Interop Assembly

Understanding COM to . NET Interoperability

The Role of the CCW

The Role of the . NET Class Interface

Building Your . NET Types

Generating the Type Library and Registering the . NET Types

Examining the Exported Type Information

Building a Visual Basic 6.0 Test Client

Summary

Platform-Independent .NET Development with Mono

The Platform- Independent Nature of . NET

Obtaining and Installing Mono

The Mono Development Tools

Building . NET Applications with Mono

Suggestions for Further Study

Summary

Index