Pro C# 5.0 and the .Net 4.5 Framework

Cover
Contents at a Glance
Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Part I: Introducing C# and the .NET Platform
Part II: Core C# Programming
Part III: Object-Oriented Programming with C#
Part IV: Advanced C# Programming
Part V: Programming with .NET Assemblies
Part VI: Introducing the .NET Base Class Libraries
Part VII: Windows Presentation Foundation
Part VIII: ASP.NET Web Forms
The Philosophy of .NET
An Initial Look at the .NET Platform
Some Key Benefits of the .NET Platform
Introducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)
The Role of the Base Class Libraries
What C# Brings to the Table
Managed vs. Unmanaged Code
Additional .NET-Aware Programming Languages
Life in a Multilanguage World
An Overview of .NET Assemblies
The Role of the Common Intermediate Language
The Role of .NET Type Metadata
The Role of the Assembly Manifest
Understanding the Common Type System
CTS Class Types
CTS Interface Types
CTS Structure Types
CTS Enumeration Types
CTS Delegate Types
CTS Type Members
Intrinsic CTS Data Types
Understanding the Common Language Specification
Ensuring CLS Compliance
Understanding the Common Language Runtime
The Assembly/Namespace/Type Distinction
The Role of the Microsoft Root Namespace
Accessing a Namespace Programmatically
Referencing External Assemblies
Exploring an Assembly Using ildasm.exe
Viewing CIL Code
Viewing Type Metadata
Viewing Assembly Metadata (a.k.a. the Manifest)
The Platform-Independent Nature of .NET
A Brief Word Regarding Windows 8 Applications
Building Applications
The Role of .NET Under Windows 8
Summary
Building C# Applications
The Role of the .NET Framework 4.5 SDK
The Developer Command Prompt
Building C# Applications Using csc.exe
Specifying Input and Output Targets
Referencing External Assemblies
Referencing Multiple External Assemblies
Compiling Multiple Source Files
Working with C# Response Files
Building .NET Applications Using Notepad++
Building .NET Applications Using SharpDevelop
Building a Simple Test Project
Building .NET Applications Using Visual C# Express
Some Unique Features of Visual C# Express
Building .NET Applications Using Visual Studio
Some Unique Features of Visual Studio
Targeting the .NET Framework Using the New Project Dialog Box
Using the Solution Explorer Utility
The Class View Utility
The Object Browser Utility
Integrated Support for Code Refactoring
Code Snippets and Surround with Technology
The Visual Class Designer
The Integrated .NET Framework 4.5 SDK Documentation System
Summary
Core C# Programming Constructs, Part I
The Anatomy of a Simple C# Program
Variations on the Main() Method
Specifying an Application Error Code
Processing Command-Line Arguments
Specifying Command-Line Arguments with Visual Studio
An Interesting Aside: Some Additional Members of the System.Environment Class
The System.Console Class
Basic Input and Output with the Console Class
Formatting Console Output
Formatting Numerical Data
Formatting Numerical Data Beyond Console Applications
System Data Types and Corresponding C# Keywords
Variable Declaration and Initialization
Intrinsic Data Types and the new Operator
The Data Type Class Hierarchy
Members of Numerical Data Types
Members of System.Boolean
Members of System.Char
Parsing Values from String Data
System.DateTime and System.TimeSpan
The System.Numerics.dll Assembly
Working with String Data
Basic String Manipulation
String Concatenation
Escape Characters
Defining Verbatim Strings
Strings and Equality
Strings Are Immutable
The System.Text.StringBuilder Type
Narrowing and Widening Data Type Conversions
The checked Keyword
Setting Project-Wide Overflow Checking
The unchecked Keyword
Understanding Implicitly Typed Local Variables
Restrictions on Implicitly Typed Variables
Implicit Typed Data Is Strongly Typed Data
Usefulness of Implicitly Typed Local Variables
C# Iteration Constructs
The for Loop
The foreach Loop
The while and do/while Looping Constructs
Decision Constructs and the Relational/Equality Operators
The if/else Statement
Equality and Relational Operators
Conditional Operators
The switch Statement
Summary
Core C# Programming Constructs, Part II
Methods and Parameter Modifiers
The Default by Value Parameter-Passing Behavior
The out Modifier
The ref Modifier
The params Modifier
Defining Optional Parameters
Invoking Methods Using Named Parameters
Understanding Method Overloading
Understanding C# Arrays
C# Array Initialization Syntax
Implicitly Typed Local Arrays
Defining an Array of Objects
Working with Multidimensional Arrays
Arrays As Arguments or Return Values
The System.Array Base Class
Understanding the enum Type
Controlling the Underlying Storage for an enum
Declaring enum Variables
The System.Enum Type
Dynamically Discovering an enum’s Name/Value Pairs
Understanding the Structure Type
Creating Structure Variables
Understanding Value Types and Reference Types
Value Types, References Types, and the Assignment Operator
Value Types Containing Reference Types
Passing Reference Types by Value
Passing Reference Types by Reference
Final Details Regarding Value Types and Reference Types
Understanding C# Nullable Types
Working with Nullable Types
The ?? Operator
Summary
Understanding Encapsulation
Introducing the C# Class Type
Allocating Objects with the new Keyword
Understanding Constructors
The Role of the Default Constructor
Defining Custom Constructors
The Default Constructor Revisited
The Role of the this Keyword
Chaining Constructor Calls Using this
Observing Constructor Flow
Revisiting Optional Arguments
Understanding the static Keyword
Defining Static Field Data
Defining Static Methods
Defining Static Constructors
Defining Static Classes
Defining the Pillars of OOP
The Role of Encapsulation
The Role of Inheritance
The Role of Polymorphism
C# Access Modifiers
The Default Access Modifiers
Access Modifiers and Nested Types
The First Pillar: C#’s Encapsulation Services
Encapsulation Using Traditional Accessors and Mutators
Encapsulation Using .NET Properties
Using Properties Within a Class Definition
Read-Only and Write-Only Properties
Revisiting the static Keyword: Defining Static Properties
Understanding Automatic Properties
Interacting with Automatic Properties
Regarding Automatic Properties and Default Values
Understanding Object Initialization Syntax
Calling Custom Constructors with Initialization Syntax
Initializing Inner Types
Working with Constant Field Data
Understanding Read-Only Fields
Static Read-Only Fields
Understanding Partial Types
Summary
Understanding Inheritance and Polymorphism
The Basic Mechanics of Inheritance
Specifying the Parent Class of an Existing Class
Regarding Multiple Base Classes
The sealed Keyword
Revising Visual Studio Class Diagrams
The Second Pillar of OOP: The Details of Inheritance
Controlling Base Class Creation with the base Keyword
Keeping Family Secrets: The protected Keyword
Adding a Sealed Class
Programming for Containment/Delegation
Understanding Nested Type Definitions
The Third Pillar of OOP: C#’s Polymorphic Support
The virtual and override Keywords
Overriding Virtual Members Using the Visual Studio IDE
Sealing Virtual Members
Understanding Abstract Classes
Understanding the Polymorphic Interface
Understanding Member Shadowing
Understanding Base Class/Derived Class Casting Rules
The C# as Keyword
The C# is Keyword
The Master Parent Class: System.Object
Overriding System.Object.ToString()
Overriding System.Object.Equals()
Overriding System.Object.GetHashCode()
Testing Your Modified Person Class
The Static Members of System.Object
Summary
Understanding Structured Exception Handling
Ode to Errors, Bugs, and Exceptions
The Role of .NET Exception Handling
The Building Blocks of .NET Exception Handling
The System.Exception Base Class
The Simplest Possible Example
Throwing a General Exception
Catching Exceptions
Configuring the State of an Exception
The TargetSite Property
The StackTrace Property
The HelpLink Property
The Data Property
System-Level Exceptions (System.SystemException)
Application-Level Exceptions (System.ApplicationException)
Building Custom Exceptions, Take One
Building Custom Exceptions, Take Two
Building Custom Exceptions, Take Three
Processing Multiple Exceptions
General catch Statements
Rethrowing Exceptions
Inner Exceptions
The finally Block
Who Is Throwing What?
The Result of Unhandled Exceptions
Debugging Unhandled Exceptions Using Visual Studio
Summary
Working with Interfaces
Understanding Interface Types
Interface Types vs. Abstract Base Classes
Defining Custom Interfaces
Implementing an Interface
Invoking Interface Members at the Object Level
Obtaining Interface References: The as Keyword
Obtaining Interface References: The is Keyword
Interfaces As Parameters
Interfaces As Return Values
Arrays of Interface Types
Implementing Interfaces Using Visual Studio
Explicit Interface Implementation
Designing Interface Hierarchies
Multiple Inheritance with Interface Types
The IEnumerable and IEnumerator Interfaces
Building Iterator Methods with the yield Keyword
Building a Named Iterator
The ICloneable Interface
A More Elaborate Cloning Example
The IComparable Interface
Specifying Multiple Sort Orders with IComparer
Custom Properties and Custom Sort Types
Summary
Collections and Generics
The Motivation for Collection Classes
The System.Collections Namespace
A Survey of System.Collections.Specialized Namespace
The Problems of Nongeneric Collections
The Issue of Performance
The Issue of Type Safety
A First Look at Generic Collections
The Role of Generic Type Parameters
Specifying Type Parameters for Generic Classes/Structures
Specifying Type Parameters for Generic Members
Specifying Type Parameters for Generic Interfaces
The System.Collections.Generic Namespace
Understanding Collection Initialization Syntax
Working with the List Class
Working with the Stack Class
Working with the Queue Class
Working with the SortedSet Class
The System.Collections.ObjectModel Namespace
Working with ObservableCollection
Creating Custom Generic Methods
Inference of Type Parameters
Creating Custom Generic Structures and Classes
The default Keyword in Generic Code
Constraining Type Parameters
Examples Using the where Keyword
The Lack of Operator Constraints
Summary
Delegates, Events, and Lambda Expressions
Understanding the .NET Delegate Type
Defining a Delegate Type in C#
The System.MulticastDelegate and System.Delegate Base Classes
The Simplest Possible Delegate Example
Investigating a Delegate Object
Sending Object State Notifications Using Delegates
Enabling Multicasting
Removing Targets from a Delegate’s Invocation List
Method Group Conversion Syntax
Understanding Generic Delegates
The Generic Action<> and Func<> Delegates
Understanding C# Events
The C# event Keyword
Events Under the Hood
Listening to Incoming Events
Simplifying Event Registration Using Visual Studio
Creating Custom Event Arguments
The Generic EventHandler Delegate
Understanding C# Anonymous Methods
Accessing Local Variables
Understanding Lambda Expressions
Dissecting a Lambda Expression
Processing Arguments Within Multiple Statements
Lambda Expressions with Multiple (or Zero) Parameters
Retrofitting the CarEvents Example Using Lambda Expressions
Summary
Advanced C# Language Features
Understanding Indexer Methods
Indexing Data Using String Values
Overloading Indexer Methods
Indexers with Multiple Dimensions
Indexer Definitions on Interface Types
Understanding Operator Overloading
Overloading Binary Operators
And What of the += and –+ Operators?
Overloading Unary Operators
Overloading Equality Operators
Overloading Comparison Operators
Final Thoughts Regarding Operator Overloading
Understanding Custom Type Conversions
Recall: Numerical Conversions
Recall: Conversions Among Related Class Types
Creating Custom Conversion Routines
Additional Explicit Conversions for the Square Type
Defining Implicit Conversion Routines
Understanding Extension Methods
Defining Extension Methods
Invoking Extension Methods
Importing Extension Methods
The IntelliSense of Extension Methods
Extending Types Implementing Specific Interfaces
Understanding Anonymous Types
Defining an Anonymous Type
The Internal Representation of Anonymous Types
The Implementation of ToString() and GetHashCode()
The Semantics of Equality for Anonymous Types
Anonymous Types Containing Anonymous Types
Working with Pointer Types
The unsafe Keyword
Working with the * and & Operators
An Unsafe (and Safe) Swap Function
Field Access via Pointers (the -> Operator)
The stackalloc Keyword
Pinning a Type via the fixed Keyword
The sizeof Keyword
Summary
LINQ to Objects
LINQ-Specific Programming Constructs
Implicit Typing of Local Variables
Object and Collection Initialization Syntax
Lambda Expressions
Extension Methods
Anonymous Types
Understanding the Role of LINQ
LINQ Expressions Are Strongly Typed
The Core LINQ Assemblies
Applying LINQ Queries to Primitive Arrays
Once Again, Without LINQ
Reflecting over a LINQ Result Set
LINQ and Implicitly Typed Local Variables
LINQ and Extension Methods
The Role of Deferred Execution
The Role of Immediate Execution
Returning the Result of a LINQ Query
Returning LINQ Results via Immediate Execution
Applying LINQ Queries to Collection Objects
Accessing Contained Subobjects
Applying LINQ Queries to Nongeneric Collections
Filtering Data Using OfType()
Investigating the C# LINQ Query Operators
Basic Selection Syntax
Obtaining Subsets of Data
Projecting New Data Types
Obtaining Counts Using Enumerable
Reversing Result Sets
Sorting Expressions
LINQ As a Better Venn Diagramming Tool
Removing Duplicates
LINQ Aggregation Operations
The Internal Representation of LINQ Query Statements
Building Query Expressions with Query Operators (Revisited)
Building Query Expressions Using the Enumerable Type and Lambda Expressions
Building Query Expressions Using the Enumerable Type and Anonymous Methods
Building Query Expressions Using the Enumerable Type and Raw Delegates
Summary
Understanding Object Lifetime
Classes, Objects, and References
The Basics of Object Lifetime
The CIL of new
Setting Object References to null
The Role of Application Roots
Understanding Object Generations
Concurrent Garbage Collection Under .NET 1.0–3.5
Background Garbage Collection Under .NET 4.0 and Greater
The System.GC Type
Forcing a Garbage Collection
Building Finalizable Objects
Overriding System.Object.Finalize()
Detailing the Finalization Process
Building Disposable Objects
Reusing the C# using Keyword
Building Finalizable and Disposable Types
A Formalized Disposal Pattern
Understanding Lazy Object Instantiation
Customizing the Creation of the Lazy Data
Summary
Building and Configuring Class Libraries
Defining Custom Namespaces
Resolving Name Clashes with Fully Qualified Names
Resolving Name Clashes with Aliases
Creating Nested Namespaces
The Default Namespace of Visual Studio
The Role of .NET Assemblies
Assemblies Promote Code Reuse
Assemblies Establish a Type Boundary
Assemblies Are Versionable Units
Assemblies Are Self-Describing
Assemblies Are Configurable
Understanding the Format of a .NET Assembly
The Windows File Header
The CLR File Header
CIL Code, Type Metadata, and the Assembly Manifest
Optional Assembly Resources
Building and Consuming Custom Class Library
Exploring the Manifest
Exploring the CIL
Exploring the Type Metadata
Building a C# Client Application
Building a Visual Basic Client Application
Cross-Language Inheritance in Action
Understanding Private Assemblies
The Identity of a Private Assembly
Understanding the Probing Process
Configuring Private Assemblies
The Role of the App.Config File
Understanding Shared Assemblies
The Global Assembly Cache
Understanding Strong Names
Generating Strong Names at the Command Line
Generating Strong Names Using Visual Studio
Installing Strongly Named Assemblies to the GAC
Consuming a Shared Assembly
Exploring the Manifest of SharedCarLibClient
Configuring Shared Assemblies
Freezing the Current Shared Assembly
Building a Shared Assembly Version 2.0.0.0
Dynamically Redirecting to Specific Versions of a Shared Assembly
Understanding Publisher Policy Assemblies
Disabling Publisher Policy
Understanding the Element
The System.Configuration Namespace
The Configuration File Schema Documentation
Summary
Type Reflection, Late Binding, and Attribute-Based Programming
The Necessity of Type Metadata
Viewing (Partial) Metadata for the EngineState Enumeration
Viewing (Partial) Metadata for the Car Type
Examining a TypeRef
Documenting the Defining Assembly
Documenting Referenced Assemblies
Documenting String Literals
Understanding Reflection
The System.Type Class
Obtaining a Type Reference Using System.Object.GetType()
Obtaining a Type Reference Using typeof()
Obtaining a Type Reference Using System.Type.GetType()
Building a Custom Metadata Viewer
Reflecting on Methods
Reflecting on Fields and Properties
Reflecting on Implemented Interfaces
Displaying Various Odds and Ends
Implementing Main()
Reflecting on Generic Types
Reflecting on Method Parameters and Return Values
Dynamically Loading Assemblies
Reflecting on Shared Assemblies
Understanding Late Binding
The System.Activator Class
Invoking Methods with No Parameters
Invoking Methods with Parameters
Understanding the Role of .NET Attributes
Attribute Consumers
Applying Attributes in C#
C# Attribute Shorthand Notation
Specifying Constructor Parameters for Attributes
The Obsolete Attribute in Action
Building Custom Attributes
Applying Custom Attributes
Named Property Syntax
Restricting Attribute Usage
Assembly-Level Attributes
The Visual Studio AssemblyInfo.cs File
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
Building CommonSnappableTypes.dll
Building the C# Snap-In
Building the Visual Basic Snap-In
Building an Extendable Windows Forms Application
Summary
Dynamic Types and the Dynamic Language Runtime
The Role of the C# dynamic Keyword
Calling Members on Dynamically Declared Data
The Role of the Microsoft.CSharp.dll Assembly
The Scope of the dynamic Keyword
Limitations of the dynamic Keyword
Practical Uses of the dynamic Keyword
The Role of the Dynamic Language Runtime (DLR)
The Role of Expression Trees
The Role of the System.Dynamic Namespace
Dynamic Runtime Lookup of Expression Trees
Simplifying Late-Bound Calls Using Dynamic Types
Leveraging the dynamic Keyword to Pass Arguments
Simplifying COM Interoperability Using Dynamic Data
The Role of Primary Interop Assemblies (PIAs)
Embedding Interop Metadata
Common COM Interop Pain Points
COM Interop Using C# Dynamic Data
COM interop Without C# Dynamic Data
Summary
Processes, AppDomains, and Object Contexts
The Role of a Windows Process
The Role of Threads
Interacting with Processes Under the .NET Platform
Enumerating Running Processes
Investigating a Specific Process
Investigating a Process’s Thread Set
Investigating a Process’s Module Set
Starting and Stopping Processes Programmatically
Controlling Process Startup Using the ProcessStartInfo Class
Understanding .NET Application Domains
The System.AppDomain Class
Interacting with the Default Application Domain
Enumerating Loaded Assemblies
Receiving Assembly Load Notifications
Creating New Application Domains
Loading Assemblies into Custom Application Domains
Programmatically Unloading AppDomains
Understanding Object Context Boundaries
Context-Agile and Context-Bound Types
Defining a Context-Bound Object
Inspecting an Object’s Context
Summarizing Processes, AppDomains, and Context
Summary
Understanding CIL and the Role of Dynamic Assemblies
Reasons for Learning the Grammar of CIL
Examining CIL Directives, Attributes, and Opcodes
The Role of CIL Directives
The Role of CIL Attributes
The Role of CIL Opcodes
The CIL Opcode/CIL Mnemonic Distinction
Pushing and Popping: The Stack-Based Nature of CIL
Understanding Round-Trip Engineering
The Role of CIL Code Labels
Interacting with CIL: Modifying an *.il File
Compiling CIL Code Using ilasm.exe
The Role of peverify.exe
Understanding CIL Directives and Attributes
Specifying Externally Referenced Assemblies in CIL
Defining the Current Assembly in CIL
Defining Namespaces in CIL
Defining Class Types in CIL
Defining and Implementing Interfaces in CIL
Defining Structures in CIL
Defining Enums in CIL
Defining Generics in CIL
Compiling the CILTypes.il file
.NET Base Class Library, C#, and CIL Data Type Mappings
Defining Type Members in CIL
Defining Field Data in CIL
Defining Type Constructors in CIL
Defining Properties in CIL
Defining Member Parameters
Examining CIL Opcodes
The .maxstack Directive
Declaring Local Variables in CIL
Mapping Parameters to Local Variables in CIL
The Hidden this Reference
Representing Iteration Constructs in CIL
Building a .NET Assembly with CIL
Building CILCars.dll
Building CILCarClient.exe
Understanding Dynamic Assemblies
Exploring the System.Reflection.Emit Namespace
The Role of the System.Reflection.Emit.ILGenerator
Emitting a Dynamic Assembly
Emitting the Assembly and Module Set
The Role of the ModuleBuilder Type
Emitting the HelloClass Type and the String Member Variable
Emitting the Constructors
Emitting the SayHello() Method
Using the Dynamically Generated Assembly
Summary
Multithreaded, Parallel, and Async Programming
The Process/AppDomain/Context/Thread Relationship
The Problem of Concurrency
The Role of Thread Synchronization
A Brief Review of the .NET Delegate
The Asynchronous Nature of Delegates
The BeginInvoke() and EndInvoke() Methods
The System.IAsyncResult Interface
Invoking a Method Asynchronously
Synchronizing the Calling Thread
The Role of the AsyncCallback Delegate
The Role of the AsyncResult Class
Passing and Receiving Custom State Data
The System.Threading Namespace
The System.Threading.Thread Class
Obtaining Statistics About the Current Thread of Execution
The Name Property
The Priority Property
Manually Creating Secondary Threads
Working with the ThreadStart Delegate
Working with the ParameterizedThreadStart Delegate
The AutoResetEvent Class
Foreground Threads and Background Threads
The Issue of Concurrency
Synchronization Using the C# lock Keyword
Synchronization Using the System.Threading.Monitor Type
Synchronization Using the System.Threading.Interlocked Type
Synchronization Using the [Synchronization] Attribute
Programming with Timer Callbacks
Understanding the CLR ThreadPool
Parallel Programming Using the Task Parallel Library
The System.Threading.Tasks Namespace
The Role of the Parallel Class
Data Parallelism with the Parallel Class
Accessing UI Elements on Secondary Threads
The Task Class
Handling Cancellation Request
Task Parallelism Using the Parallel Class
Parallel LINQ Queries (PLINQ)
Opting in to a PLINQ Query
Cancelling a PLINQ Query
Asynchronous Calls Under .NET 4.5
A First Look at the C# async and await Keywords
Naming Conventions for Async Methods
Async Methods Returning Void
Async Methods with Multiple Awaits
Retrofitting the AddWithThreads Example Using Asycn/Await
Summary
File I/O and Object Serialization
Exploring the System.IO Namespace
The Directory(Info) and File(Info) Types
The Abstract FileSystemInfo Base Class
Working with the DirectoryInfo Type
Enumerating Files with the DirectoryInfo Type
Creating Subdirectories with the DirectoryInfo Type
Working with the Directory Type
Working with the DriveInfo Class Type
Working with the FileInfo Class
The FileInfo.Create() Method
The FileInfo.Open() Method
The FileInfo.OpenRead() and FileInfo.OpenWrite() Methods
The FileInfo.OpenText() Method
The FileInfo.CreateText() and FileInfo.AppendText() Methods
Working with the File Type
Additional File-Centric Members
The Abstract Stream Class
Working with FileStreams
Working with StreamWriters and StreamReaders
Writing to a Text File
Reading from a Text File
Directly Creating StreamWriter/StreamReader Types
Working with StringWriters and StringReaders
Working with BinaryWriters and BinaryReaders
Watching Files Programmatically
Understanding Object Serialization
The Role of Object Graphs
Configuring Objects for Serialization
Defining Serializable Types
Public Fields, Private Fields, and Public Properties
Choosing a Serialization Formatter
The IFormatter and IRemotingFormatter Interfaces
Type Fidelity Among the Formatters
Serializing Objects Using the BinaryFormatter
Deserializing Objects Using the BinaryFormatter
Serializing Objects Using the SoapFormatter
Serializing Objects Using the XmlSerializer
Controlling the Generated XML Data
Serializing Collections of Objects
Customizing the Soap/Binary Serialization Process
A Deeper Look at Object Serialization
Customizing Serialization Using ISerializable
Customizing Serialization Using Attributes
Summary
ADO.NET Part I: The Connected Layer
A High-Level Definition of ADO.NET
The Three Faces of ADO.NET
Understanding ADO.NET Data Providers
The Microsoft-Supplied ADO.NET Data Providers
A Word Regarding System.Data.OracleClient.dll
Obtaining Third-Party ADO.NET Data Providers
Additional ADO.NET Namespaces
The Types of the System.Data Namespace
The Role of the IDbConnection Interface
The Role of the IDbTransaction Interface
The Role of the IDbCommand Interface
The Role of the IDbDataParameter and IDataParameter Interfaces
The Role of the IDbDataAdapter and IDataAdapter Interfaces
The Role of the IDataReader and IDataRecord Interfaces
Abstracting Data Providers Using Interfaces
Increasing Flexibility Using Application Configuration Files
Creating the AutoLot Database
Creating the Inventory Table
Adding Test Records to the Inventory Table
Authoring the GetPetName() Stored Procedure
Creating the Customers and Orders Tables
Visually Creating Table Relationships
The ADO.NET Data Provider Factory Model
A Complete Data Provider Factory Example
A Potential Drawback with the Data Provider Factory Model
The Element
Understanding the Connected Layer of ADO.NET
Working with Connection Objects
Working with ConnectionStringBuilder Objects
Working with Command Objects
Working with Data Readers
Obtaining Multiple Result Sets Using a Data Reader
Building a Reusable Data Access Library
Adding the Connection Logic
Adding the Insertion Logic
Adding the Deletion Logic
Adding the Update Logic
Adding the Selection Logic
Working with Parameterized Command Objects
Executing a Stored Procedure
Creating a Console UI–Based Front End
Implementing the Main() Method
Implementing the ShowInstructions() Method
Implementing the ListInventory() Method
Implementing the DeleteCar() Method
Implementing the InsertNewCar() Method
Implementing the UpdateCarPetName() Method
Implementing LookUpPetName()
Understanding Database Transactions
Key Members of an ADO.NET Transaction Object
Adding a CreditRisks Table to the AutoLot Database
Adding a Transaction Method to InventoryDAL
Testing Your Database Transaction
Summary
ADO.NET Part II: The Disconnected Layer
Understanding the Disconnected Layer of ADO.NET
Understanding the Role of the DataSet
Key Properties of the DataSet
Key Methods of the DataSet
Building a DataSet
Working with DataColumns
Building a DataColumn
Enabling Autoincrementing Fields
Adding DataColumn Objects to a DataTable
Working with DataRows
Understanding the RowState Property
Understanding the DataRowVersion Property
Working with DataTables
Inserting DataTables into DataSets
Obtaining Data in a DataSet
Processing DataTable Data Using DataTableReader Objects
Serializing DataTable/DataSet Objects As XML
Serializing DataTable/DataSet Objects in a Binary Format
Binding DataTable Objects to Windows Forms GUIs
Hydrating a DataTable from a Generic List
Deleting Rows from a DataTable
Selecting Rows Based on Filter Criteria
Updating Rows Within a DataTable
Working with the DataView Type
Working with Data Adapters
A Simple Data Adapter Example
Mapping Database Names to Friendly Names
Adding Disconnection Functionality to AutoLotDAL.dll
Defining the Initial Class Type
Configuring the Data Adapter Using the SqlCommandBuilder
Implementing GetAllInventory()
Implementing UpdateInventory()
Setting Your Version Number
Testing the Disconnected Functionality
Multitabled DataSet Objects and Data Relationships
Prepping the Data Adapters
Building the Table Relationships
Updating the Database Tables
Navigating Between Related Tables
The Windows Forms Database Designer Tools
Visually Designing the DataGridView
The Generated App.config File
Examining the Strongly Typed DataSet
Examining the Strongly Typed DataTable
Examining the Strongly Typed DataRow
Examining the Strongly Typed Data Adapter
Completing the Windows Forms Application
Isolating Strongly Typed Database Code into a Class Library
Viewing the Generated Code
Selecting Data with the Generated Code
Inserting Data with the Generated Code
Deleting Data with the Generated Code
Invoking a Stored Procedure Using the Generated Code
Programming with LINQ to DataSet
The Role of the DataSet Extensions Library
Obtaining a LINQ-Compatible DataTable
The Role of the DataRowExtensions.Field() Extension Method
Hydrating New DataTables from LINQ Queries
Summary
ADO.NET Part III: The Entity Framework
Understanding the Role of Entity Framework
The Role of Entities
The Building Blocks of the Entity Framework
Building and Analyzing Your First EDM
Programming Against the Conceptual Model
AutoLotDAL Version Four, Now with Entities
The Role of Navigation Properties
Using Navigation Properties within LINQ to Entity Queries
Invoking a Stored Procedure
Data Binding Entities to Windows Forms GUIs
Adding the Data-Binding Code
Going Forward with .NET Data-Access APIs
Summary
Introducing LINQ to XML
A Tale of Two XML APIs
LINQ to XML As a Better DOM
VB Literal Syntax As a Better LINQ to XML
Members of the System.Xml.Linq Namespace
The LINQ to XML Axis Methods
The Oddness of XName (and XNamespace)
Working with XElement and XDocument
Generating Documents from Arrays and Containers
Loading and Parsing XML Content
Manipulating an In-Memory XML Document
Building the UI of the LINQ to XML App
Import the Inventory.xml File
Defining a LINQ to XML Helper Class
Attaching the UI to Your Helper Class
Summary
Introducing Windows Communication Foundation
A Potpourri of Distributed Computing APIs
The Role of DCOM
The Role of COM+/Enterprise Services
The Role of MSMQ
The Role of .NET Remoting
The Role of XML Web Services
The Role of WCF
An Overview of WCF Features
An Overview of Service-Oriented Architecture
WCF: The Bottom Line
Investigating the Core WCF Assemblies
The Visual Studio WCF Project Templates
The WCF Service Web Site Project Template
The Basic Composition of a WCF Application
The ABCs of WCF
Understanding WCF Contracts
Understanding WCF Bindings
Understanding WCF Addresses
Building a WCF Service
The [ServiceContract] Attribute
The [OperationContract] Attribute
Service Types As Operational Contracts
Hosting the WCF Service
Establishing the ABCs Within an App.config File
Coding Against the ServiceHost Type
Specifying Base Addresses
Details of the ServiceHost Type
Details of the Element
Enabling Metadata Exchange
Building the WCF Client Application
Generating Proxy Code Using svcutil.exe
Generating Proxy Code Using Visual Studio
Configuring a TCP-Based Binding
Simplifying Configuration Settings
Leveraging Default Endpoints
Exposing a Single WCF Service Using Multiple Bindings
Changing Settings for a WCF Binding
Leveraging the Default MEX Behavior Configuration
Refreshing the Client Proxy and Selecting the Binding
Using the WCF Service Library Project Template
Building a Simple Math Service
Testing the WCF Service with WcfTestClient.exe
Altering Configuration Files Using SvcConfigEditor.exe
Hosting the WCF Service Within a Windows Service
Specifying the ABCs in Code
Enabling MEX
Creating a Windows Service Installer
Installing the Windows Service
Invoking a Service Asynchronously from the Client
Designing WCF Data Contracts
Using the Web-Centric WCF Service Project Template
Implementing the Service Contract
The Role of the *.svc File
Examining the Web.config File
Testing the Service
Summary
Introducing Windows Workflow Foundation
Defining a Business Process
The Role of WF
Building a Simple Workflow
The Workflow Runtime
Hosting a Workflow Using WorkflowInvoker
Hosting a Workflow Using WorkflowApplication
Recap of Your First Workflow
Examining the Workflow Activities
Control Flow Activities
Flowchart Activities
Messaging Activities
The State Machine Activities
The Runtime and Primitives Activities
The Transaction Activities
The Collection and Error Handling Activities
Building a Flowchart Workflow
Connecting Activities in a Flowchart
Working with the InvokeMethod Activity
Defining Workflow-Wide Variables
Working with the FlowDecision Activity
Working with the TerminateWorkflow Activity
Building the “True” Condition
Working with the ForEach Activity
Completing the Application
Reflecting on What We Have Done
Building a Sequence Workflow (in a Dedicated DLL)
Defining the Initial Project
Importing Assemblies and Namespaces
Defining the Workflow Arguments
Defining Workflow Variables
Working with the Assign Activity
Working with the If and Switch Activities
Building a Custom Code Activity
Consuming the Workflow Library
Retrieving the Workflow Output Argument
Summary
Introducing Windows Presentation Foundation and XAML
The Motivation Behind WPF
Unifying Diverse APIs
Providing a Separation of Concerns via XAML
Providing an Optimized Rendering Model
Simplifying Complex UI Programming
The Various Flavors of WPF
Traditional Desktop Applications
Navigation-Based WPF Applications
XBAP Applications
The WPF/Silverlight Relationship
Investigating the WPF Assemblies
The Role of the Application Class
The Role of the Window Class
Building a WPF Application Without XAML
Creating a Strongly Typed Window
Creating a Simple User Interface
Interacting with Application-Level Data
Handling the Closing of a Window Object
Intercepting Mouse Events
Intercepting Keyboard Events
Building a WPF Application Using Only XAML
Defining a Window Object in XAML
Defining the Application Object in XAML
Processing the XAML Files Using msbuild.exe
Transforming Markup into a .NET Assembly
Mapping the Window XAML Markup to C# Code
The Role of BAML
Mapping the Application XAML Markup to C# Code
XAML-to-Assembly Process Summary
Understanding the Syntax of WPF XAML
Introducing Kaxaml
XAML XML Namespaces and XAML “Keywords”
Controlling Class and Member Variable Visibility
XAML Elements, XAML Attributes, and Type Converters
Understanding XAML Property-Element Syntax
Understanding XAML Attached Properties
Understanding XAML Markup Extensions
Building a WPF Application Using Code-Behind Files
Adding a Code File for the MainWindow Class
Adding a Code File for the MyApp Class
Processing the Code Files with msbuild.exe
Building WPF Applications Using Visual Studio
The WPF Project Templates
The Toolbox and XAML Designer/Editor
Setting Properties Using the Properties Window
Handling Events Using the Properties Window
Handling Events in the XAML Editor
The Document Outline Window
Viewing the AutoGenerated Code Files
Building a Custom XAML Editor with Visual Studio
Designing the GUI of Our Window
Implementing the Loaded Event
Implementing the Button’s Click Event
Implementing the Closed Event
Testing Your Application
Exploring the WPF Documentation
Summary
Programming with WPF Controls
A Survey of the Core WPF Controls
The WPF Ink Controls
The WPF Document Controls
WPF Common Dialog Boxes
The Details Are in the Documentation
A Brief Review of the Visual Studio WPF Designer
Working with WPF Controls Using Visual Studio
Working with the Document Outline Editor
Controlling Content Layout Using Panels
Positioning Content Within Canvas Panels
Positioning Content Within WrapPanel Panels
Positioning Content Within StackPanel Panels
Positioning Content Within Grid Panels
Positioning Content Within DockPanel Panels
Enabling Scrolling for Panel Types
Configuring Panels Using the Visual Studio Designers
Building a Window’s Frame Using Nested Panels
Building the Menu System
Building the ToolBar
Building the StatusBar
Finalizing the UI Design
Implementing the MouseEnter/MouseLeave Event Handlers
Implementing the Spell Checking Logic
Understanding WPF Commands
The Intrinsic Command Objects
Connecting Commands to the Command Property
Connecting Commands to Arbitrary Actions
Working with the Open and Save Commands
A Deeper Look at WPF APIs and Controls
Working with the TabControl
Building the Ink API Tab
Designing the ToolBar
The RadioButton Control
Handling Events for the Ink API Tab
The InkCanvas Control
The ComboBox Control
Saving, Loading, and Clearing InkCanvas Data
Introducing the Documents API
Block Elements and Inline Elements
Document Layout Managers
Building the Documents Tab
Populating a FlowDocument Using Code
Enabling Annotations and Sticky Notes
Saving and Loading a Flow Document
Introducing the WPF Data-Binding Model
Building the Data Binding Tab
Establishing Data Bindings Using Visual Studio
The DataContext Property
Data Conversion Using IValueConverter
Establishing Data Bindings in Code
Building the DataGrid Tab
Summary
WPF Graphics Rendering Services
Understanding WPF’s Graphical Rendering Services
WPF Graphical Rendering Options
Rendering Graphical Data Using Shapes
Adding Rectangles, Ellipses, and Lines to a Canvas
Removing Rectangles, Ellipses, and Lines from a Canvas
Working with Polylines and Polygons
Working with Paths
WPF Brushes and Pens
Configuring Brushes Using Visual Studio
Configuring Brushes in Code
Configuring Pens
Applying Graphical Transformations
A First Look at Transformations
Transforming Our Canvas Data
Working with the Visual Studio Transform Editor
Building the Initial Layout
Applying Transformations at Design Time
Transforming the Canvas in Code
Rendering Graphical Data Using Drawings and Geometries
Building a DrawingBrush Using Geometries
Painting with the DrawingBrush
Containing Drawing Types in a DrawingImage
The Role of Expression Design
Exporting a Sample Design File As XAML
Importing the Graphical Data into a WPF Project
Interacting with the Bear
Rendering Graphical Data Using the Visual Layer
Summary
WPF Resources, Animations, and Styles
Understanding the WPF Resource System
Working with Binary Resources
Working with Object (Logical) Resources
The Role of the Resources Property
Defining Window-Wide Resources
The Markup Extension
The {DynamicResource} Markup Extension
Application-Level Resources
Defining Merged Resource Dictionaries
Defining a Resource-Only Assembly
Understanding WPF’s Animation Services
The Role of the Animation Class Types
The To, From, and By Properties
The Role of the Timeline Base Class
Authoring an Animation in C# Code
Controlling the Pace of an Animation
Reversing and Looping an Animation
Authoring Animations in XAML
The Role of Storyboards
The Role of Event Triggers
Animation Using Discrete Key Frames
Understanding the Role of WPF Styles
Defining and Applying a Style
Overriding Style Settings
Automatically Applying a Style with TargetType
Subclassing Existing Styles
The Role of Unnamed Styles
Defining Styles with Triggers
Defining Styles with Multiple Triggers
Animated Styles
Assigning Styles Programmatically
Summary
Dependency Properties, Routed Events, and Templates
Understanding the Role of Dependency Properties
Examining an Existing Dependency Property
Important Notes Regarding CLR Property Wrappers
Building a Custom Dependency Property
Adding a Data Validation Routine
Responding to the Property Change
Understanding Routed Events
The Role of Routed Bubbling Events
Continuing or Halting Bubbling
The Role of Routed Tunneling Events
Logical Trees, Visual Trees, and Default Templates
Programmatically Inspecting a Logical Tree
Programmatically Inspecting a Visual Tree
Programmatically Inspecting a Control’s Default Template
Building a Control Template with the Trigger Framework
Templates As Resources
Incorporating Visual Cues Using Triggers
The Role of the {TemplateBinding} Markup Extension
The Role of ContentPresenter
Incorporating Templates into Styles
Summary
Introducing ASP.NET Web Forms
The Role of HTTP
The HTTP Request/Response Cycle
HTTP Is a Stateless Protocol
Understanding Web Applications and Web Servers
The Role of IIS Virtual Directories
The ASP.NET Development Web Server
The Role of HTML
HTML Document Structure
The Role of an HTML Form
The Visual Studio HTML Designer Tools
Building an HTML Form
The Role of Client-Side Scripting
A Client-Side Scripting Example
Posting Back to the Web Server
Postbacks Under ASP.NET
An Overview of the ASP.NET API
Major Features of ASP.NET 2.0 and Higher
Major Features of ASP.NET 3.5 (and .NET 3.5 SP1) and Higher
Major Features of ASP.NET 4.0 and 4.5
Building a Single-File ASP.NET Web Page
Referencing AutoLotDAL.dll
Designing the UI
Adding the Data Access Logic
The Role of ASP.NET Directives
Analyzing the “Script” Block
Analyzing the ASP.NET Control Declarations
Building an ASP.NET Web Page Using Code Files
Referencing the AutoLotDAL.dll Assembly
Updating the Code File
Debugging and Tracing ASP.NET Pages
ASP.NET Web Sites vs. ASP.NET Web Applications
The ASP.NET Web Site Directory Structure
Referencing Assemblies
The Role of the App_Code Folder
The Inheritance Chain of the Page Type
Interacting with the Incoming HTTP Request
Obtaining Browser Statistics
Access to Incoming Form Data
The IsPostBack Property
Interacting with the Outgoing HTTP Response
Emitting HTML Content
Redirecting Users
The Life Cycle of an ASP.NET Web Page
The Role of the AutoEventWireup Attribute
The Error Event
The Role of the web.config File
The ASP.NET Web Site Administration Utility
Summary
ASP.NET Web Controls, Master Pages, and Themes
Understanding the Nature of Web Controls
Understanding Server-Side Event Handling
The AutoPostBack Property
The Control and WebControl Base Classes
Enumerating Contained Controls
Dynamically Adding and Removing Controls
Interacting with Dynamically Created Controls
Functionality of the WebControl Base Class
Major Categories of ASP.NET Web Controls
A Brief Word Regarding System.Web.UI.HtmlControls
Web Control Documentation
Building the ASP.NET Cars Web Site
Working with ASP.NET Master Pages
Defining the Default Content Page
Designing the Inventory Content Page
Designing the Build-a-Car Content Page
The Role of the Validation Controls
Enabling Client-Side JavaScript Validation Support
The RequiredFieldValidator
The RegularExpressionValidator
The RangeValidator
The CompareValidator
Creating Validation Summaries
Defining Validation Groups
Working with Themes
Understanding *.skin Files
Applying Site-Wide Themes
Applying Themes at the Page Level
The SkinID Property
Assigning Themes Programmatically
Summary
ASP.NET State Management Techniques
The Issue of State
ASP.NET State Management Techniques
Understanding the Role of ASP.NET View State
Demonstrating View State
Adding Custom View State Data
The Role of the Global.asax File
The Global Last-Chance Exception Event Handler
The HttpApplication Base Class
Understanding the Application/Session Distinction
Maintaining Application-Level State Data
Modifying Application Data
Handling Web Application Shutdown
Working with the Application Cache
Fun with Data Caching
Modifying the *.aspx File
Maintaining Session Data
Additional Members of HttpSessionState
Understanding Cookies
Creating Cookies
Reading Incoming Cookie Data
The Role of the Element
Storing Session Data in the ASP.NET Session State Server
Storing Session Data in a Dedicated Database
Introducing the ASP.NET Profile API
The ASPNETDB.mdf Database
Defining a User Profile Within web.config
Accessing Profile Data Programmatically
Grouping Profile Data and Persisting Custom Objects
Summary
Index
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T, U
V
W
X, Y, Z