Pro C# 2008 and the .NET 3.5 Platform (eBook)

Andrew Troelsen is a partner, trainer, and consultant at Intertech Inc., and is a leading authority on both .NET and COM. His book Pro C# 2005 and the .NET 2.0 Platform won the prestigious 2003 Referenceware Excellence Award and is in its third edition. Also of note are his earlier five-star treatment of traditional COM in the bestselling Developer's Workshop to COM and ATL mirrored in his book, COM and .NET Interoperability, and his top-notch investigation of VB .NET in Visual Basic .NET and the .NET Platform: An Advanced Guide. Troelsen has a degree in mathematical linguistics and South Asian studies from the University of Minnesota, and is a frequent speaker at numerous .NET-related conferences. He currently lives in Minneapolis with his wife, Amanda, and spends his free time investigating .NET and waiting for the Wild to win the Stanley Cup. You can check out his blog at AndrewTroelsen.blogspot.com.

Contents 5
About the Author 17
About the Technical Reviewer 18
Acknowledgments 19
Introduction 20
We’re a Team, You and I 20
An Overview of This Book 21
Diving Even Deeper with Five Free Chapters 28
Obtaining This Book’s Source Code 29
Obtaining Updates for This Book 29
Contacting Me 29
Introducing C# and the . NET Platform 30
The Philosophy of .NET 31
Understanding the Previous State of Affairs 31
The . NET Solution 34
Introducing the Building Blocks of the . NET Platform ( the CLR, CTS, and CLS) 34
Additional . NET- Aware Programming Languages 37
An Overview of . NET Assemblies 39
Understanding the Common Type System 45
Understanding the Common Language Specification 48
Understanding the Common Language Runtime 50
The Assembly/ Namespace/ Type Distinction 51
Exploring an Assembly Using ildasm. exe 56
Exploring an Assembly Using Lutz Roeder’s Reflector 59
Deploying the . NET Runtime 59
The Platform- Independent Nature of . NET 60
Summary 61
Building C# Applications 62
The Role of the . NET Framework 3.5 SDK 62
Building C# Applications Using csc. exe 63
Building . NET Applications Using TextPad 69
Building . NET Applications Using Notepad++ 73
Building . NET Applications Using SharpDevelop 75
Building . NET Applications Using Visual C# 2008 Express 77
Building . NET Applications Using Visual Studio 2008 79
A Partial Catalog of Additional . NET Development Tools 91
Summary 92
Core C# Programming Constructs 93
Core C# Programming Constructs, Part I 94
The Anatomy of a Simple C# Program 94
An Interesting Aside: Some Additional Members of the System. Environment Class 100
The System. Console Class 101
System Data Types and C# Shorthand Notation 105
Understanding the System. String Type 111
Narrowing and Widening Data Type Conversions 120
C# Iteration Constructs 125
Decision Constructs and the Relational/ Equality Operators 127
Summary 129
Core C# Programming Constructs, Part II 131
Methods and Parameter Modifiers 131
Understanding Member Overloading 137
Array Manipulation in C# 138
Understanding the Enum Type 145
Understanding the Structure Type 150
Understanding Value Types and Reference Types 153
Value and Reference Types: Final Details 159
Understanding C# Nullable Types 160
Summary 163
Defining Encapsulated Class Types 164
Introducing the C# Class Type 164
Understanding Class Constructors 167
The Role of the this Keyword 170
Understanding the static Keyword 175
Defining the Pillars of OOP 182
C# Access Modifiers 186
The First Pillar: C#’s Encapsulation Services 187
Understanding Constant Data 196
Understanding Read- Only Fields 197
Understanding Partial Types 198
Documenting C# Source Code via XML 199
Visualizing the Fruits of Our Labor 205
Summary 205
Understanding Inheritance and Polymorphism 207
The Basic Mechanics of Inheritance 207
Revising Visual Studio Class Diagrams 211
The Second Pillar: The Details of Inheritance 212
Programming for Containment/ Delegation 218
The Third Pillar: C#’s Polymorphic Support 221
Understanding Base Class/ Derived Class Casting Rules 232
The Master Parent Class: System. Object 234
Summary 240
Understanding Structured Exception Handling 241
Ode to Errors, Bugs, and Exceptions 241
The Role of . NET Exception Handling 242
The Simplest Possible Example 244
Configuring the State of an Exception 248
System- Level Exceptions ( System. SystemException) 252
Application- Level Exceptions ( System. ApplicationException) 253
Processing Multiple Exceptions 258
The Finally Block 261
Who Is Throwing What? 262
The Result of Unhandled Exceptions 263
Debugging Unhandled Exceptions Using Visual Studio 264
Summary 265
Understanding Object Lifetime 266
Classes, Objects, and References 266
The Basics of Object Lifetime 267
The Role of Application Roots 270
Understanding Object Generations 272
The System. GC Type 273
Building Finalizable Objects 277
Building Disposable Objects 280
Building Finalizable and Disposable Types 283
Summary 286
Advanced C# Programming Constructs 287
Working with Interfaces 288
Understanding Interface Types 288
Defining Custom Interfaces 291
Implementing an Interface 293
Invoking Interface Members at the Object Level 295
Interfaces As Parameters 297
Interfaces As Return Values 299
Arrays of Interface Types 300
Implementing Interfaces Using Visual Studio 2008 301
Resolving Name Clashes via Explicit Interface Implementation 302
Designing Interface Hierarchies 305
Building Enumerable Types ( IEnumerable and IEnumerator) 308
Building Cloneable Objects ( ICloneable) 314
Building Comparable Objects ( IComparable) 318
Understanding Callback Interfaces 323
Summary 327
Collections and Generics 328
The Interfaces of the System. Collections Namespace 328
The Class Types of System. Collections 331
System. Collections. Specialized Namespace 335
The Boxing, Unboxing, and System. Object Relationship 335
The Issue of Type Safety and Strongly Typed Collections 338
The System. Collections. Generic Namespace 343
Creating Custom Generic Methods 346
Creating Generic Structures and Classes 349
Creating a Custom Generic Collection 351
Creating Generic Base Classes 356
Creating Generic Interfaces 357
Summary 358
Delegates, Events, and Lambdas 359
Understanding the . NET Delegate Type 359
Defining a Delegate in C# 360
The System. MulticastDelegate and System. Delegate Base Classes 362
The Simplest Possible Delegate Example 363
Retrofitting the Car Type with Delegates 366
A More Elaborate Delegate Example 371
Understanding Delegate Covariance 376
Creating Generic Delegates 378
Understanding C# Events 380
The Generic EventHandler< T>
Understanding C# Anonymous Methods 388
Understanding Method Group Conversions 390
The C# 2008 Lambda Operator 392
Summary 399
Indexers, Operators, and Pointers 400
Understanding Indexer Methods 400
Understanding Operator Overloading 405
Understanding Custom Type Conversions 414
Working with Pointer Types 421
C# Preprocessor Directives 428
Summary 431
C# 2008 Language Features 432
Understanding Implicitly Typed Local Variables 432
Understanding Automatic Properties 437
Understanding Extension Methods 441
Understanding Partial Methods 450
Understanding Object Initializer Syntax 453
Understanding Anonymous Types 457
Summary 462
An Introduction to LINQ 463
Understanding the Role of LINQ 463
A First Look at LINQ Query Expressions 466
LINQ and Generic Collections 472
LINQ and Nongeneric Collections 473
The Internal Representation of LINQ Query Operators 475
Investigating the C# LINQ Query Operators 479
LINQ Queries: An Island unto Themselves? 485
Summary 488
Programming with .NET Assemblies 489
Introducing .NET Assemblies 490
Defining Custom Namespaces 490
The Role of . NET Assemblies 495
Understanding the Format of a . NET Assembly 497
Building and Consuming a Single- File Assembly 501
Building and Consuming a Multifile Assembly 511
Understanding Private Assemblies 514
Understanding Shared Assemblies 519
Consuming a Shared Assembly 525
Configuring Shared Assemblies 527
Investigating the Internal Composition of the GAC 531
Understanding Publisher Policy Assemblies 533
Understanding the < codeBase>
The System. Configuration Namespace 536
The Machine Configuration File 537
Summary 537
Type Reflection, Late Binding, and Attribute- Based Programming 538
The Necessity of Type Metadata 538
Understanding Reflection 542
Building a Custom Metadata Viewer 545
Dynamically Loading Assemblies 551
Reflecting on Shared Assemblies 553
Understanding Late Binding 554
Understanding Attributed Programming 557
Building Custom Attributes 561
Assembly- Level ( and Module- Level) Attributes 564
Reflecting on Attributes Using Early Binding 565
Reflecting on Attributes Using Late Binding 566
Putting Reflection, Late Binding, and Custom Attributes in Perspective 568
Building an Extendable Application 568
Summary 574
Processes, AppDomains, and Object Contexts 575
Reviewing Traditional Win32 Processes 575
Interacting with Processes Under the . NET Platform 577
Understanding . NET Application Domains 585
Understanding Object Context Boundaries 591
Summarizing Processes, AppDomains, and Context 595
Summary 596
Building Multithreaded Applications 597
The Process/ AppDomain/ Context/ Thread Relationship 597
A Brief Review of the . NET Delegate 599
The Asynchronous Nature of Delegates 601
Invoking a Method Asynchronously 602
The System. Threading Namespace 607
The System. Threading. Thread Class 608
Programmatically Creating Secondary Threads 611
The Issue of Concurrency 616
Programming with Timer Callbacks 623
Understanding the CLR ThreadPool 624
The Role of the BackgroundWorker Component 626
Summary 630
Understanding CIL and the Role of Dynamic Assemblies 631
Reflecting on the Nature of CIL Programming 631
Examining CIL Directives, Attributes, and Opcodes 632
Pushing and Popping: The Stack- Based Nature of CIL 634
Understanding Round- Trip Engineering 635
Understanding CIL Directives and Attributes 643
. NET Base Class Library, C#, and CIL Data Type Mappings 649
Defining Type Members in CIL 650
Examining CIL Opcodes 652
Building a . NET Assembly with CIL 657
Understanding Dynamic Assemblies 662
Summary 671
Introducing the .NET Base Class Libraries 672
File I/O and Isolated Storage 673
Exploring the System. IO Namespace 673
The Directory( Info) and File( Info) Types 674
Working with the DirectoryInfo Type 675
Working with the Directory Type 679
Working with the DriveInfo Class Type 680
Working with the FileInfo Class 681
Working with the File Type 685
The Abstract Stream Class 687
Working with StreamWriters and StreamReaders 689
Working with StringWriters and StringReaders 692
Working with BinaryWriters and BinaryReaders 694
Programmatically “ Watching” Files 695
Performing Asynchronous File I/ O 697
Understanding the Role of Isolated Storage 699
A Primer on Code Access Security 700
An Overview of Isolated Storage 710
Obtaining a Store Using IsolatedStorageFile 714
Isolated Storage in Action: ClickOnce Deployment 719
Summary 722
Introducing Object Serialization 723
Understanding Object Serialization 723
Configuring Objects for Serialization 725
Choosing a Serialization Formatter 727
Serializing Objects Using the BinaryFormatter 729
Serializing Objects Using the SoapFormatter 731
Serializing Objects Using the XmlSerializer 732
Serializing Collections of Objects 735
Customizing the Serialization Process 736
Summary 741
ADO.NET Part I: The Connected Layer 742
A High- Level Definition of ADO. NET 742
Understanding ADO. NET Data Providers 744
Additional ADO. NET Namespaces 747
The Types of the System. Data Namespace 748
Abstracting Data Providers Using Interfaces 752
Creating the AutoLot Database 755
The ADO. NET Data Provider Factory Model 760
Understanding the Connected Layer of ADO. NET 766
Working with Data Readers 771
Building a Reusable Data Access Library 774
Creating a Console UI – Based Front End 781
Asynchronous Data Access Using SqlCommand 786
Understanding Database Transactions 788
Summary 792
ADO.NET Part II: The Disconnected Layer 793
Understanding the Disconnected Layer of ADO. NET 793
Understanding the Role of the DataSet 794
Working with DataColumns 797
Working with DataRows 799
Working with DataTables 803
Binding DataTable Objects to User Interfaces 808
Filling DataSet/ DataTable Objects Using Data Adapters 818
Revisiting AutoLotDAL. dll 821
Navigating Multitabled DataSet Objects 824
The Data Access Tools of Visual Studio 2008 830
Decoupling Autogenerated Code from the UI Layer 841
Summary 845
Programming with the LINQ APIs 846
The Role of LINQ to ADO. NET 846
Programming with LINQ to DataSet 847
Programming with LINQ to SQL 852
Generating Entity Classes Using SqlMetal. exe 857
Building Entity Classes Using Visual Studio 2008 863
Manipulating XML Documents Using LINQ to XML 866
Navigating an In- Memory Document 871
Summary 874
Introducing Windows Communication Foundation 875
A Potpourri of Distributed Computing APIs 875
The Role of WCF 881
Investigating the Core WCF Assemblies 884
The Visual Studio WCF Project Templates 885
The Basic Composition of a WCF Application 887
The ABCs of WCF 888
Building a WCF Service 893
Hosting the WCF Service 896
Building the WCF Client Application 904
Using the WCF Service Library Project Template 908
Hosting the WCF Service As a Windows Service 911
Invoking a Service Asynchronously 916
Designing WCF Data Contracts 918
Summary 923
Introducing Windows Workflow Foundation 924
Defining a Business Process 924
The Building Blocks of WF 925
WF Assemblies, Namespaces, and Projects 931
Building a Simple Workflow- Enabled Application 933
Examining the WF Engine Hosting Code 937
Invoking Web Services Within Workflows 941
Building a Reusable WF Code Library 952
A Brief Word Regarding Custom Activities 958
Summary 959
Desktop User Interfaces 960
Programming with Windows Forms 961
The Windows Forms Namespaces 961
Building a Simple Windows Forms Application ( IDE- Free) 962
The Visual Studio Windows Forms Project Template 967
The Anatomy of a Form 974
Responding to Mouse Activity 981
Responding to Keyboard Activity 983
Designing Dialog Boxes 984
Rendering Graphical Data Using GDI+ 991
Building a Complete Windows Forms Application 996
Summary 1003
Introducing Windows Presentation Foundation and XAML 1005
The Motivation Behind WPF 1005
The Various Flavors of WPF Applications 1008
Investigating the WPF Assemblies 1010
Building a ( XAML- Free) WPF Application 1017
Additional Details of the Application Type 1021
Additional Details of the Window Type 1023
Building a ( XAML- Centric) WPF Application 1027
Transforming Markup into a . NET Assembly 1031
Separation of Concerns Using Code- Behind Files 1035
The Syntax of XAML 1037
Building WPF Applications Using Visual Studio 2008 1050
Processing XAML at Runtime: SimpleXamlPad. exe 1054
The Role of Microsoft Expression Blend 1058
Summary 1059
Programming with WPF Controls 1061
A Survey of the WPF Control Library 1061
Declaring Controls in XAML 1064
Understanding the Role of Dependency Properties 1066
Understanding Routed Events 1070
Working with Button Types 1074
Working with CheckBoxes and RadioButtons 1078
Working with the ListBox and ComboBox Types 1081
Working with Text Areas 1087
Controlling Content Layout Using Panels 1089
Building a Window’s Frame Using Nested Panels 1099
Understanding WPF Control Commands 1105
Understanding the WPF Data- Binding Model 1108
Data Conversion Using IValueConverter 1112
Binding to Custom Objects 1114
Binding UI Elements to XML Documents 1118
Summary 1122
WPF 2D Graphical Rendering, Resources, and Themes 1123
The Philosophy of WPF Graphical Rendering Services 1123
Exploring the Shape- Derived Types 1130
Working with WPF Brushes 1133
Working with WPF Pens 1136
Exploring the Drawing- Derived Types 1136
The Role of UI Transformations 1141
Understanding WPF’s Animation Services 1142
Understanding the WPF Resource System 1151
Defining and Applying Styles for WPF Controls 1153
Altering a Control’s UI Using Templates 1162
Summary 1166
Building Web Applications with ASP. NET 1167
Building ASP.NET Web Pages 1168
The Role of HTTP 1168
Understanding Web Applications and Web Servers 1169
The Role of HTML 1172
The Role of Client- Side Scripting 1177
Submitting the Form Data ( GET and POST) 1179
Building a Classic ASP Page 1180
Problems with Classic ASP 1182
The ASP. NET Namespaces 1183
The ASP. NET Web Page Code Model 1184
Details of an ASP. NET Website Directory Structure 1195
The ASP. NET Page Compilation Cycle 1197
The Inheritance Chain of the Page Type 1199
Interacting with the Incoming HTTP Request 1200
Interacting with the Outgoing HTTP Response 1203
The Life Cycle of an ASP. NET Web Page 1205
The Role of the Web. config File 1208
Summary 1211
ASP.NET Web Controls, Themes, and Master Pages 1212
Understanding the Nature of Web Controls 1212
The System. Web. UI. Control Type 1214
The System. Web. UI. WebControls. WebControl Type 1218
Major Categories of ASP. NET Web Controls 1218
Building a Feature- Rich ASP. NET Website 1220
The Role of the Validation Controls 1236
Working with Themes 1242
Positioning Controls Using HTML Tables 1248
Summary 1249
ASP.NET State Management Techniques 1250
The Issue of State 1250
ASP. NET State Management Techniques 1252
Understanding the Role of ASP. NET View State 1253
The Role of the Global. asax File 1256
Understanding the Application/ Session Distinction 1259
Working with the Application Cache 1264
Maintaining Session Data 1268
Understanding Cookies 1272
The Role of the < sessionState>
Understanding the ASP. NET Profile API 1277
Summary 1284
Appendixes 1285
COM and .NET Interoperability 1286
The Scope of . NET Interoperability 1286
A Simple Example of . NET to COM Interop 1287
Investigating a . NET Interop Assembly 1290
Understanding the Runtime Callable Wrapper 1292
The Role of COM IDL 1295
Using a Type Library to Build an Interop Assembly 1299
Building a More Elaborate COM Server 1302
Examining the Interop Assembly 1304
Understanding COM to . NET Interoperability 1308
The Role of the CCW 1309
The Role of the . NET Class Interface 1310
Building Your . NET Types 1311
Generating the Type Library and Registering the . NET Types 1313
Examining the Exported Type Information 1314
Building a Visual Basic 6.0 Test Client 1315
Summary 1316
Platform-Independent .NET Development with Mono 1317
The Platform- Independent Nature of . NET 1317
Obtaining and Installing Mono 1320
The Mono Development Tools 1323
Building . NET Applications with Mono 1325
Suggestions for Further Study 1332
Summary 1333
Index 1335