Pro C# 2005 and the.net 2.0 Platform. Andrew Troelsen

Transcription

1 Pro C# 2005 and the.net 2.0 Platform Andrew Troelsen

2 Pro C# 2005 and the.net 2.0 Platform Copyright 2005 by Andrew Troelsen All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. ISBN: Printed and bound in the United States of America Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. Lead Editor: Ewan Buckingham Technical Reviewer: Gavin Smyth Editorial Board: Steve Anglin, Dan Appleman, Ewan Buckingham, Gary Cornell, Tony Davis, Jason Gilmore, Jonathan Hassell, Chris Mills, Dominic Shakeshaft, Jim Sumser Associate Publisher and Project Manager: Grace Wong Copy Edit Manager: Nicole LeClerc Copy Editors: Nicole LeClerc, Ami Knox Assistant Production Director: Kari Brooks-Copony Production Editor: Laura Cheu Compositor and Artist: Kinetic Publishing Services, LLC Proofreader: Nancy Sixsmith Indexers: Kevin Broccoli and Dan Mabbutt Interior Designer: Van Winkle Design Group Cover Designer: Kurt Krames Manufacturing Director: Tom Debolski Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor, New York, NY Phone SPRINGER, fax , orders-ny@springer-sbm.com, or visit For information on translations, please contact Apress directly at 2560 Ninth Street, Suite 219, Berkeley, CA Phone , fax , info@apress.com, or visit The information in this book is distributed on an as is basis, without warranty. Although every precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work. The source code for this book is available to readers at in the Source Code section.

3 I would like to dedicate this book to my mother, Mary Troelsen. Mom, thanks for all of your support over the years and the years to come. Oh yeah, and thanks for not busting my chops when I came home with the red Mohawk. Luv ya, Pooch

4 Contents at a Glance About the Author xxxiii About the Technical Reviewer xxxv Acknowledgments xxxvii Introduction xxxix PART 1 Introducing C# and the.net Platform CHAPTER 1 The Philosophy of.net CHAPTER 2 Building C# Applications PART 2 The C# Programming Language CHAPTER 3 C# Language Fundamentals CHAPTER 4 Object-Oriented Programming with C# CHAPTER 5 Understanding Object Lifetime CHAPTER 6 Understanding Structured Exception Handling CHAPTER 7 Interfaces and Collections CHAPTER 8 Callback Interfaces, Delegates, and Events CHAPTER 9 Advanced C# Type Construction Techniques CHAPTER 10 Understanding Generics PART 3 Programming with.net Assemblies CHAPTER 11 Introducing.NET Assemblies CHAPTER 12 Type Reflection, Late Binding, and Attribute-Based Programming CHAPTER 13 Processes, AppDomains, Contexts, and CLR Hosts CHAPTER 14 Building Multithreaded Applications CHAPTER 15 Understanding CIL and the Role of Dynamic Assemblies v

5 PART 4 Programming with the.net Libraries CHAPTER 16 The System.IO Namespace CHAPTER 17 Understanding Object Serialization CHAPTER 18 The.NET Remoting Layer CHAPTER 19 Building a Better Window with System.Windows.Forms CHAPTER 20 Rendering Graphical Data with GDI CHAPTER 21 Programming with Windows Forms Controls CHAPTER 22 Database Access with ADO.NET PART 5 Web Applications and XML Web Services CHAPTER 23 ASP.NET 2.0 Web Pages and Web Controls CHAPTER 24 ASP.NET 2.0 Web Applications CHAPTER 25 Understanding XML Web Services INDEX

6 Contents About the Author xxxiii About the Technical Reviewer xxxv Acknowledgments xxxvii Introduction xxxix PART 1 Introducing C# and the.net Platform CHAPTER 1 The Philosophy of.net Understanding the Previous State of Affairs Life As a C/Win32 API Programmer Life As a C++/MFC Programmer Life As a Visual Basic 6.0 Programmer Life As a Java/J2EE Programmer Life As a COM Programmer Life As a Windows DNA Programmer The.NET Solution 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 Additional.NET-Aware Programming Languages Life in a Multilanguage World An Overview of.net Assemblies Single-File and Multifile Assemblies The Role of the Common Intermediate Language Benefits of CIL Compiling CIL to Platform-Specific Instructions The Role of.net Type Metadata The Role of the Assembly Manifest Understanding the Common Type System CTS Class Types CTS Structure Types CTS Interface Types CTS Enumeration Types CTS Delegate Types vii

7 viii CONTENTS 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 Accessing a Namespace Programmatically Referencing External Assemblies Using ildasm.exe Viewing CIL Code Viewing Type Metadata Viewing Assembly Metadata Deploying the.net Runtime The Platform-Independent Nature of.net Summary CHAPTER 2 Building C# Applications Installing the.net Framework 2.0 SDK The C# Command-Line Compiler (csc.exe) Configuring the C# Command-Line Compiler Configuring Additional.NET Command-Line Tools Building C# Applications Using csc.exe Referencing External Assemblies Compiling Multiple Source Files with csc.exe Referencing Multiple External Assemblies Working with csc.exe Response Files The Default Response File (csc.rsp) The Command-Line Debugger (cordbg.exe) Debugging at the Command Line Building.NET Applications Using TextPad Enabling C# Keyword Coloring Configuring the *.cs File Filter Hooking Into csc.exe Associating Run Commands with Menu Items Enabling C# Code Snippets Building.NET Applications Using SharpDevelop Learning the Lay of the Land: SharpDevelop The Project and Classes Scouts The Assembly Scout Windows Forms Designers Building.NET Applications Using Visual C# 2005 Express

8 CONTENTS ix The Big Kahuna: Building.NET Applications Using Visual Studio Learning the Lay of the Land: Visual Studio The Solution Explorer Utility The Class View Utility The Code Definition Window The Object Browser Utility Integrated Support for Code Refactoring Code Expansions and Surround with Technology The Visual Class Designer Object Test Bench The Integrated Help System A Partial Catalogue of Additional.NET Development Tools Summary PART 2 The C# Programming Language CHAPTER 3 C# Language Fundamentals The Anatomy of a Simple C# Program Variations on the Main() Method Processing Command-Line Arguments Specifying Command-Line Arguments with Visual Studio An Interesting Aside: The System.Environment Class Defining Classes and Creating Objects The Role of Constructors Is That a Memory Leak? Defining an Application Object The System.Console Class Basic Input and Output with the Console Class Formatting Console Output NET String Formatting Flags Establishing Member Visibility Establishing Type Visibility Default Values of Class Member Variables Default Values and Local Variables Member Variable Initialization Syntax Defining Constant Data Referencing Constant Data Defining Read-Only Fields Static Read-Only Fields Understanding the static Keyword Static Methods Static Data

9 x CONTENTS Static Constructors Static Classes Method Parameter Modifiers The Default Parameter-Passing Behavior The out Modifier The ref Modifier The params Modifier 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 The switch Statement 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 Value and Reference Types: Final Details Understanding Boxing and Unboxing Operations Some Practical (Un)Boxing Examples Unboxing Custom Value Types Working with.net Enumerations The System.Enum Base Class The Master Class: System.Object The Default Behavior of System.Object Overriding Some Default Behaviors of System.Object Overriding System.Object.ToString() Overriding System.Object.Equals() Overriding System.Object.GetHashCode() Testing the Overridden Members Static Members of System.Object The System Data Types (and C# Shorthand Notation) Experimenting with Numerical Data Types Members of System.Boolean Members of System.Char Parsing Values from String Data System.DateTime and System.TimeSpan The System.String Data Type Basic String Operations Escape Characters Working with C# Verbatim Strings

10 CONTENTS xi The Role of System.Text.StringBuilder NET Array Types Arrays As Parameters (and Return Values) Working with Multidimensional Arrays The System.Array Base Class Understanding C# Nullable Types Working with Nullable Types The?? Operator Defining Custom Namespaces A Type s Fully Qualified Name Defining using Aliases Creating Nested Namespaces The Default Namespace of Visual Studio Summary CHAPTER 4 Object-Oriented Programming with C# Understanding the C# Class Type Understanding Method Overloading Self-Reference in C# Using this Defining the Public Interface of a Class Reviewing the Pillars of OOP Encapsulation Inheritance Polymorphism The First Pillar: C# s Encapsulation Services Enforcing Encapsulation Using Traditional Accessors and Mutators Another Form of Encapsulation: Class Properties Internal Representation of C# Properties Controlling Visibility Levels of Property get/set Statements Read-Only and Write-Only Properties Static Properties The Second Pillar: C# s Inheritance Support Controlling Base Class Creation with base Regarding Multiple Base Classes Keeping Family Secrets: The protected Keyword Preventing Inheritance: Sealed Classes Programming for Containment/Delegation Nested Type Definitions The Third Pillar: C# s Polymorphic Support The virtual and override Keywords Revisiting the sealed Keyword

11 xii CONTENTS Understanding Abstract Classes Enforcing Polymorphic Activity: Abstract Methods Member Hiding C# Casting Rules Determining the Type of Employee Numerical Casts Understanding C# Partial Types Documenting C# Source Code via XML XML Code Comment Format Characters Transforming XML Code Comments Summary CHAPTER 5 Understanding Object Lifetime Classes, Objects, and References The Basics of Object Lifetime The CIL of new The Role of Application Roots Understanding Object Generations 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 Summary CHAPTER 6 Understanding Structured Exception Handling Ode to Errors, Bugs, and Exceptions The Role of.net Exception Handling The Atoms of.net Exception Handling The System.Exception Base Class The Simplest Possible Example Throwing a Generic Exception Catching Exceptions Configuring the State of an Exception The TargetSite Property The StackTrace Property The HelpLink Property The Data Property

12 CONTENTS xiii 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 Generic catch Statements Rethrowing Exceptions Inner Exceptions The Finally Block Who Is Throwing What? The Result of Unhandled Exception Debugging Unhandled Exceptions Using Visual Studio Summary CHAPTER 7 Interfaces and Collections Defining Interfaces in C# Implementing an Interface in C# Contrasting Interfaces to Abstract Base Classes 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 Understanding Explicit Interface Implementation Resolving Name Clashes Building Interface Hierarchies Interfaces with Multiple Base Interfaces Implementing Interfaces Using Visual Studio Building Enumerable Types (IEnumerable and IEnumerator) Understanding C# Iterator Methods Building Cloneable Objects (ICloneable) A More Elaborate Cloning Example Building Comparable Objects (IComparable) Specifying Multiple Sort Orders (IComparer) Custom Properties, Custom Sort Types The Interfaces of the System.Collections Namespace The Role of ICollection The Role of IDictionary The Role of IDictionaryEnumerator The Role of IList

13 xiv CONTENTS The Class Types of System.Collections Working with the ArrayList Type Working with the Queue Type Working with the Stack Type System.Collections.Specialized Namespace Summary CHAPTER 8 Callback Interfaces, Delegates, and Events Understanding Callback Interfaces Understanding the.net Delegate Type Defining a Delegate in C# The System.MulticastDelegate and System.Delegate Base Classes The Simplest Possible Delegate Example Investigating a Delegate Object Retrofitting the Car Type with Delegates Enabling Multicasting A More Elaborate Delegate Example Delegates As Parameters Analyzing the Delegation Code Understanding Delegate Covariance Understanding C# Events Events Under the Hood Listening to Incoming Events Simplifying Event Registration Using Visual Studio A Prim-and-Proper Event Understanding C# Anonymous Methods Accessing Outer Variables C# Method Group Conversions Summary CHAPTER 9 Advanced C# Type Construction Techniques Building a Custom Indexer A Variation of the Garage Indexer Internal Representation of Type Indexers Indexers: Final Details Understanding Operator Overloading Overloading Binary Operators And What of the += and + Operators? Overloading Unary Operators Overloading Equality Operators Overloading Comparison Operators

14 CONTENTS xv The Internal Representation of Overloaded Operators Interacting with Overloaded Operators from Overloaded Operator Challenged Languages 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 The Internal Representation of Custom Conversion Routines The Advanced Keywords of C# The checked Keyword The unchecked Keyword Working with Pointer Types The sizeof Keyword C# Preprocessor Directives Specifying Code Regions Conditional Code Compilation Summary CHAPTER 10 Understanding Generics Revisiting the Boxing, Unboxing, and System.Object Relationship The Problem with (Un)Boxing Operations Type Safety and Strongly Typed Collections Boxing Issues and Strongly Typed Collections The System.Collections.Generic Namespace Examining the List<T> Type Creating Generic Methods Omission of Type Parameters Creating Generic Structures (or Classes) The default Keyword in Generic Code Creating a Custom Generic Collection Constraining Type Parameters Using where The Lack of Operator Constraints Creating Generic Base Classes Creating Generic Interfaces Creating Generic Delegates Simulating Generic Delegates Under.NET A Brief Word Regarding Nested Delegates Summary

15 xvi CONTENTS PART 3 Programming with.net Assemblies CHAPTER 11 Introducing.NET Assemblies 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 Win32 File Header The CLR File Header CIL Code, Type Metadata, and the Assembly Manifest Optional Assembly Resources Single-File and Multifile Assemblies Building and Consuming a Single-File Assembly Exploring the Manifest Exploring the CIL Exploring the Type Metadata Building a C# Client Application Building a Visual Basic.NET Client Application Cross-Language Inheritance in Action Building and Consuming a Multifile Assembly Exploring the ufo.netmodule File Exploring the airvehicles.dll File Consuming a Multifile Assembly Understanding Private Assemblies The Identity of a Private Assembly Understanding the Probing Process Configuring Private Assemblies Configuration Files and Visual Studio Introducing the.net Framework 2.0 Configuration Utility Understanding Shared Assemblies Understanding Strong Names Strongly Naming CarLibrary.dll Assigning Strong Names Using Visual Studio Installing/Removing Shared Assemblies to/from the GAC The Role of Delayed Signing Consuming a Shared Assembly Exploring the Manifest of SharedCarLibClient

16 CONTENTS xvii Configuring Shared Assemblies Freezing the Current Shared Assembly Building Shared Assembly Version Dynamically Redirecting to Specific Versions of a Shared Assembly Revisiting the.net Framework 2.0 Configuration Utility Investigating the Internal Composition of the GAC Understanding Publisher Policy Assemblies Disabling Publisher Policy Understanding the <codebase> Element The System.Configuration Namespace The Machine Configuration File The Assembly Binding Big Picture Summary CHAPTER 12 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 System.Type.GetType() Obtaining a Type Reference Using typeof() 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 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

17 xviii CONTENTS Understanding Attributed Programming Attribute Consumers Applying Predefined Attributes in C# Specifying Constructor Parameters for Attributes The Obsolete Attribute in Action C# Attribute Shorthand Notation Building Custom Attributes Applying Custom Attributes Restricting Attribute Usage Assembly-Level (and Module-Level) Attributes The Visual Studio 2005 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.NET Snap-In Building an Extendable Windows Forms Application Summary CHAPTER 13 Processes, AppDomains, Contexts, and CLR Hosts Reviewing Traditional Win32 Processes An Overview 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 Understanding.NET Application Domains Enumerating a Process s AppDomains Programmatically Creating New AppDomains 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

18 CONTENTS xix Hosting the Common Language Runtime Side-by-Side Execution of the CLR Loading a Specific Version of the CLR Additional CLR Hosts Summary CHAPTER 14 Building Multithreaded Applications The Process/AppDomain/Context/Thread Relationship The Problem of Concurrency and 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 The Name Property The Priority Property Programmatically Creating Secondary Threads Working with the ThreadStart Delegate Working with the ParameterizedThreadStart Delegate 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 Summary CHAPTER 15 Understanding CIL and the Role of Dynamic Assemblies Reflecting on the Nature of CIL Programming Examining CIL Directives, Attributes, and Opcodes The Role of CIL Directives The Role of CIL Attributes

19 xx CONTENTS 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 Compiling CIL Code Using SharpDevelop Compiling CIL Code Using ILIDE# 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 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 Considering 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 HelloWorld() Method Using the Dynamically Generated Assembly

20 CONTENTS xxi A Brief Word Regarding System.CodeDOM Summary PART 4 Programming with the.net Libraries CHAPTER 16 The System.IO Namespace Exploring the System.IO Namespace The Directory(Info) and File(Info) Types The Abstract FileSystemInfo Base Class Working with the DirectoryInfo Type The FileAttributes Enumeration 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 New.NET 2.0 File 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 Programmatically Watching Files Performing Asynchronous File I/O Summary CHAPTER 17 Understanding Object Serialization Understanding Object Serialization The Role of Object Graphs Configuring Objects for Serialization Public Fields, Private Fields, and Public Properties

21 xxii CONTENTS Choosing a Serialization Formatter The IFormatter and IRemotingFormatting 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 Persisting Collections of Objects Customizing the Serialization Process A Deeper Look at Object Serialization Customizing Serialization Using ISerializable Customizing Serialization Using Attributes Versioning Serializable Objects Summary CHAPTER 18 The.NET Remoting Layer Defining.NET Remoting The.NET Remoting Namespaces Understanding the.net Remoting Framework Understanding Proxies and Messages Understanding Channels Revisiting the Role of.net Formatters All Together Now! A Brief Word Regarding Extending the Default Plumbing Terms of the.net Remoting Trade Object Marshaling Choices: MBR or MBV? Activation Choices for MBR Types: WKO or CAO? Stateful Configuration of WKO Types: Singleton or Single Call? Summarizing the Traits of MBR Object Types Basic Deployment of a.net Remoting Project Building Your First Distributed Application Building the General Assembly Building the Server Assembly Building the SimpleRemoteObjectClient.exe Assembly Testing the Remoting Application Understanding the ChannelServices Type Understanding the RemotingConfiguration Type Revisiting the Activation Mode of WKO Types Deploying the Server to a Remote Machine Leveraging the TCP Channel A Brief Word Regarding the IpcChannel

22 CONTENTS xxiii Remoting Configuration Files Building Server-Side *.config Files Building Client-Side *.config Files Working with MBV Objects Building the General Assembly Building the Server Assembly Building the Client Assembly Understanding Client-Activated Objects The Lease-Based Lifetime of CAO/WKO-Singleton Objects The Default Leasing Behavior Altering the Default Lease Characteristics Server-Side Lease Adjustment Client-Side Lease Adjustment Server-Side (and Client-Side) Lease Sponsorship Alternative Hosts for Remote Objects Hosting Remote Objects Using a Windows Service Hosting Remote Objects Using IIS Asynchronous Remoting The Role of the [OneWay] Attribute Summary CHAPTER 19 Building a Better Window with System.Windows.Forms Overview of the System.Windows.Forms Namespace Working with the Windows Forms Types Building a Main Window by Hand Honoring the Separation of Concerns The Role of the Application Class Fun with the Application Class The System.EventHandler Delegate The Anatomy of a Form The Functionality of the Control Class Fun with the Control Class Responding to the MouseMove Event Determining Which Mouse Button Was Clicked Responding to Keyboard Events The Functionality of the Form Class The Life Cycle of a Form Type Building Windows Applications with Visual Studio Enabling the Deprecated Controls Dissecting a Visual Studio 2005 Windows Forms Project Handling Events at Design Time The Program Class Autoreferenced Assemblies

23 xxiv CONTENTS Working with MenuStrips and ContextMenuStrips Adding a TextBox to the MenuStrip Creating a Context Menu Checking Menu Items Working with StatusStrips Designing the Menu System Designing the StatusStrip Working with the Timer Type Toggling the Display Displaying the Menu Selection Prompts Establishing a Ready State Working with ToolStrips Working with ToolStripContainers Building an MDI Application Building the Parent Form Building the Child Form Spawning Child Windows Summary CHAPTER 20 Rendering Graphical Data with GDI A Survey of the GDI+ Namespaces An Overview of the System.Drawing Namespace The System.Drawing Utility Types The Point(F) Type The Rectangle(F) Type The Region Class Understanding the Graphics Class Understanding Paint Sessions Invalidating the Form s Client Area Obtaining a Graphics Object Outside of a Paint Event Handler Regarding the Disposal of a Graphics Object The GDI+ Coordinate Systems The Default Unit of Measure Specifying an Alternative Unit of Measure Specifying an Alternative Point of Origin Defining a Color Value The ColorDialog Class Manipulating Fonts Working with Font Families Working with Font Faces and Font Sizes Enumerating Installed Fonts The FontDialog Class Survey of the System.Drawing.Drawing2D Namespace

24 CONTENTS xxv Working with Pens Working with Pen Caps Working with Brushes Working with HatchBrushes Working with TextureBrushes Working with LinearGradientBrushes Rendering Images Dragging and Hit Testing the PictureBox Control Hit Testing Rendered Images Hit Testing Nonrectangular Images Understanding the.net Resource Format The System.Resources Namespace Programmatically Creating an *.resx File Building the *.resources File Binding the *.resources File into a.net Assembly Working with ResourceWriters Generating Resources using Visual Studio Programmatically Reading Resources Summary CHAPTER 21 Programming with Windows Forms Controls The World of Windows Forms Controls Adding Controls to Forms by Hand The Control.ControlCollection Type Adding Controls to Forms Using Visual Studio Working with the Basic Controls Fun with Labels Fun with TextBoxes Fun with MaskedTextBoxes Fun with Buttons Fun with CheckBoxes, RadioButtons, and GroupBoxes Fun with CheckedListBoxes Fun with ListBoxes Fun with ComboBoxes Configuring the Tab Order The Tab Order Wizard Setting the Form s Default Input Button Working with More Exotic Controls Fun with MonthCalendars Fun with ToolTips Fun with TabControls Fun with TrackBars Fun with Panels

25 xxvi CONTENTS Fun with the UpDown Controls Fun with ErrorProviders Fun with TreeViews Fun with WebBrowsers Building Custom Windows Forms Controls Creating the Images Building the Design-Time UI Implementing the Core CarControl Defining the Custom Events Defining the Custom Properties Controlling the Animation Rendering the Pet Name Testing the CarControl Type Building a Custom CarControl Form Host The Role of the System.ComponentModel Namespace Enhancing the Design-Time Appearance of CarControl Defining a Default Property and Default Event Specifying a Custom Toolbox Bitmap Building Custom Dialog Boxes The DialogResult Property Understanding Form Inheritance Dynamically Positioning Windows Forms Controls The Anchor Property The Dock Property Table and Flow Layout Summary CHAPTER 22 Database Access with ADO.NET A High-Level Definition of ADO.NET The Two Faces of ADO.NET Understanding ADO.NET Data Providers Microsoft-Supplied Data Providers Select Third-Party Data Providers Additional ADO.NET Namespaces The System.Data Types 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

26 CONTENTS xxvii The.NET 2.0 Provider Factory Model Registered Data Provider Factories A Complete Data Provider Factory Example The <connectionstrings> Element Installing the Cars Database Connecting to the Cars Database from Visual Studio Understanding the Connected Layer of ADO.NET Working with Connection Objects Working with.net 2.0 ConnectionStringBuilders Working with Command Objects Working with Data Readers Obtaining Multiple Result Sets Using a Data Reader Modifying Tables Using Command Objects Inserting New Records Deleting Existing Records Updating Existing Records Working with Parameterized Command Objects Specifying Parameters Using the DbParameter Type Executing a Stored Procedure Using DbCommand Asynchronous Data Access Under.NET Understanding the Disconnected Layer of ADO.NET Understanding the Role of the DataSet Members of the DataSet Working with DataColumns Building a DataColumn Enabling Autoincrementing Fields Adding a DataColumn to a DataTable Working with DataRows Understanding the DataRow.RowState Property Working with DataTables Working with.net 2.0 DataTableReaders Persisting DataSets (and DataTables) As XML Binding DataTables to User Interfaces Programmatically Deleting Rows Applying Filters and Sort Orders Updating Rows Working with the DataView Type Working with Data Adapters Filling a DataSet Using a Data Adapter Mapping Database Names to Friendly Names Updating a Database Using Data Adapter Objects Setting the InsertCommand Property Setting the UpdateCommand Property Setting the DeleteCommand Property

27 xxviii CONTENTS Autogenerating SQL Commands Using CommandBuilder Types Multitabled DataSets and DataRelation Objects Navigating Between Related Tables We re Off to See the (Data) Wizard Strongly Typed DataSets The Autogenerated Data Component Summary PART 5 Web Applications and XML Web Services CHAPTER 23 ASP.NET 2.0 Web Pages and Web Controls The Role of HTTP Understanding Web Applications and Web Servers Working with IIS Virtual Directories The ASP.NET 2.0 Development Server The Role of HTML HTML Document Structure HTML Form Development Building an HTML-Based User Interface The Role of Client-Side Scripting A Client-Side Scripting Example Validating the default.htm Form Data Submitting the Form Data (GET and POST) Building a Classic ASP Page Responding to POST Submissions Problems with Classic ASP Major Benefits of ASP.NET 1.x Major Enhancements of ASP.NET The ASP.NET 2.0 Namespaces The ASP.NET Web Page Code Model Working with the Single-File Page Model Working with the Code-behind Page Model Details of an ASP.NET Website Directory Structure The Role of the Bin folder The Role of the App_Code Folder The ASP.NET 2.0 Page Compilation Cycle Compilation Cycle for Single-File Pages Compilation Cycle for Multifile Pages The Inheritance Chain of the Page Type The System.Web.UI.Page Type

28 CONTENTS xxix Interacting with the Incoming HTTP Request Obtaining Brower 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 Understanding the Nature of Web Controls Qualifying Server-Side Event Handling The AutoPostBack Property The System.Web.UI.Control Type Enumerating Contained Controls Dynamically Adding (and Removing) Controls Key Members of the System.Web.UI.WebControls.WebControl Type Categories of ASP.NET Web Controls A Brief Word Regarding System.Web.UI.HtmlControls Building a Simple ASP.NET 2.0 Website Working with Master Pages Defining the Default.aspx Content Page Designing the Inventory Content Page Designing the Build a Car Content Page The Role of the Validation Controls The RequiredFieldValidator The RegularExpressionValidator The RangeValidator The CompareValidator Creating Validation Summaries Summary CHAPTER 24 ASP.NET 2.0 Web Applications 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 A Brief Word Regarding Control State The Role of the Global.asax File The Global Last Chance Exception Event Handler The HttpApplication Base Class

29 xxx CONTENTS 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 Configuring Your ASP.NET Web Application Using Web.config Enabling Tracing via <trace> Customizing Error Output via <customerrors> Options for Storing State via <sessionstate> The ASP.NET 2.0 Site Administration Utility Configuration Inheritance Summary CHAPTER 25 Understanding XML Web Services The Role of XML Web Services Benefits of XML Web Services Defining an XML Web Service Client The Building Blocks of an XML Web Service Previewing XML Web Service Discovery Previewing XML Web Service Description Previewing the Transport Protocol The.NET XML Web Service Namespaces Examining the System.Web.Services Namespace Building an XML Web Service by Hand Testing Your XML Web Service Using WebDev.WebServer.exe Testing Your Web Service Using IIS Viewing the WSDL Contract The Autogenerated Test Page Providing a Custom Test Page Building an XML Web Service Using Visual Studio Implementing the TellFortune() Web Method The Role of the WebService Base Class Understanding the [WebService] Attribute The Effect of the Namespace and Description Properties The Name Property

30 CONTENTS xxxi Understanding the [WebServiceBinding] Attribute Ignoring BP 1.1 Conformance Verification Disabling BP 1.1 Conformance Verification Understanding the [WebMethod] Attribute Documenting a Web Method via the Description Property Avoiding WSDL Name Clashes via the MessageName Property Building Stateful Web Services via the EnableSession Property Exploring the Web Service Description Language (WSDL) Defining a WSDL Document The <types> Element The <message> Element The <porttype> Element The <binding> Element The <service> Element Revisiting the XML Web Service Wire Protocols HTTP GET and HTTP POST Bindings SOAP Bindings The wsdl.exe Command-Line Utility Transforming WSDL into a Server-Side XML Web Service Skeleton Transforming WSDL into a Client-Side Proxy Examining the Proxy Code The Default Constructor Synchronous Invocation Support Asynchronous Invocation Support Building the Client Application Generating Proxy Code Using Visual Studio Exposing Custom Types from Web Methods Exposing Arrays Exposing Structures Exposing ADO.NET DataSets A Windows Forms Client Client-Side Type Representation Understanding the Discovery Service Protocol (UDDI) Interacting with UDDI via VS.NET Summary INDEX

31 About the Author ANDREW TROELSEN is a Microsoft MVP (Visual C#) and a partner, trainer, and consultant with Intertech Training ( a.net and J2EE developer education center. He is the author of numerous books, including Developer s Workshop to COM and ATL 3.0 (Wordware Publishing, 2000), COM and.net Interoperability (Apress, 2002), Visual Basic.NET and the.net Platform: An Advanced Guide (Apress, 2001), and the award-winning C# and the.net Platform (Apress, 2003). Andrew has also authored numerous articles on.net for MSDN online and MacTech (where he explored the platform-independent aspects of the.net platform), and he is a frequent speaker at various.net conferences and user groups. Andrew currently lives in Minneapolis, Minnesota, with his wife, Amanda. He spends his free time waiting for the Wild to win the Stanley Cup, the Vikings to win the Super Bowl (before he retires would be nice), and the Timberwolves to grab numerous NBA championship titles. xxxiii