Sams c sharp 3 0 unleashed with the dot NET framework 3 5 aug 2008 ISBN 0672329816 pdf

.461 22 Creating Data Abstractions with the ADO.NET Entity Framework.. .475 23 Working with Data in the Cloud with ADO.NET Data Services.. .473 22 Creating Data Abstractions with the ADO

All rights reserved No part of this book shall be reproduced, stored in a retrieval

system, or transmitted by any means, electronic, mechanical, photocopying, recording,

or otherwise, without written permission from the publisher No patent liability is

assumed with respect to the use of the information contained herein Although every

precaution has been taken in the preparation of this book, the publisher and author

assume no responsibility for errors or omissions Nor is any liability assumed for

damages resulting from the use of the information contained herein.

First Printing June 2008

Trademarks

All terms mentioned in this book that are known to be trademarks or service marks

have been appropriately capitalized Sams Publishing cannot attest to the accuracy of

this information Use of a term in this book should not be regarded as affecting the

validity of any trademark or service mark.

Warning and Disclaimer

Every effort has been made to make this book as complete and as accurate as

possi-ble, but no warranty or fitness is implied The information provided is on an “as is”

basis The authors and the publisher shall have neither liability nor responsibility to any

person or entity with respect to any loss or damages arising from the information

contained in this book.

Bulk Sales

Sams Publishing offers excellent discounts on this book when ordered in quantity for

bulk purchases or special sales For more information, please contact

U.S Corporate and Government Sales

Acquisitions EditorBrook Farling

Development EditorMark Renfrow

Managing EditorKristy Hart

Project EditorAndrew Beaster

Copy EditorKeith Cline

IndexerBrad Herriman

ProofreaderSan Dee Phillips

Technical EditorsTony GravagnoTodd Meister

J Boyd Nolan

PublishingCoordinatorCindy Teeters

Cover DesignerGary Adair

CompositionJake McFarland

Introduction .1

Part 1 Learning C# Basics 1 Introducing the NET Platform .9

2 Getting Started with C# and Visual Studio 2008 .19

3 Writing C# Expressions and Statements .49

4 Understanding Reference Types and Value Types .79

5 Manipulating Strings .105

6 Arrays and Enums .131

7 Debugging Applications with Visual Studio 2008 .147

Part 2 Object-Oriented Programming with C# 8 Designing Objects .163

9 Designing Object-Oriented Programs .177

10 Coding Methods and Custom Operators .201

11 Error and Exception Handling .231

12 Event-Based Programming with Delegates and Events .249

13 Naming and Organizing Types with Namespaces .273

14 Implementing Abstract Classes and Interfaces .287

Part 3 Applying Advanced C# Language Features 15 Managing Object Lifetime .319

16 Declaring Attributes and Examining Code with Reflection .339

17 Parameterizing Type with Generics and Writing Iterators .365

18 Using Lambda Expressions and Expression Trees .397

Part 4 Learning LINQ and NET Data Access 19 Accessing Data with LINQ .409

20 Managing Data with ADO.NET .441

21 Manipulating XML Data .461

22 Creating Data Abstractions with the ADO.NET Entity Framework .475

23 Working with Data in the Cloud with ADO.NET Data Services .491

Part 5 Building Desktop User Interfaces 24 Taking Console Applications to the Limit .507

25 Writing Windows Forms Applications .515

Part 6 Designing Web User Interfaces

27 Building Web Applications with ASP.NET .583

28 Adding Interactivity to Your Web Apps with ASP.NET AJAX .619

29 Crafting Rich Web Applications with Silverlight .641

Part 7 Communicating with NET Technologies 30 Using NET Network Communications Technologies .661

31 Building Windows Service Applications .679

32 Remoting .695

33 Writing Traditional ASMX Web Services .713

34 Creating Web and Services with WCF .725

Part 8 Examining NET Application Architecture and Design 35 Using the Visual Studio 2008 Class Designer .743

36 Sampling Design Patterns in C# .755

37 Building N-Tier/Layer Systems .779

38 Automating Logic with Windows Workflow .797

Part 9 Surveying More of the NET Framework Class Library 39 Managing Processes and Threads .817

40 Localizing and Globalization .831

41 Performing Interop (P/Invoke and COM) and Writing Unsafe Code .853

42 Instrumenting Applications with System.Diagnostics Types .879

Part 10 Deploying Code 43 Assemblies and Versioning .921

44 Securing Code .933

45 Creating Visual Studio 2008 Setup Projects .947

46 Deploying Desktop Applications .955

47 Publishing Web Applications .961

Part 11 Appendixes A Compiling Programs .969

B Getting Help with the NET Framework .973

Index .977

Introduction 1

Why This Book Is for You .2

Organization and Goals .3

Part 1 Learning C# Basics 1 Introducing the NET Platform 9 What Is NET? .9

The Common Language Runtime (CLR) .11

Why Is the CLR Important? .11

CLR Features .12

The CLR Execution Process .12

The NET Framework Class Library (FCL) .14

C# and Other NET Languages .16

The Common Type System (CTS) .17

The Common Language Specification (CLS) .17

Summary .17

2 Getting Started with C# and Visual Studio 2008 19 Writing a Simple C# Program .19

Creating a Visual Studio 2008 (VS2008) Project .23

Running the New Project Wizard .23

Understanding Solutions and Projects .26

Coding in VS2008 .27

Building and Running Applications .28

Setting Compiler Options .31

Commenting Code .32

Multiline Comments .32

Single-Line Comments .32

XML Documentation Comments .33

Identifiers and Keywords .35

Identifiers .35

Keywords .36

Convention and Style .37

Variables and Types .38

Variables .38

The Simple Types .39

The string Type .43

Definite Assignment .44

Interacting with Programs .45

Console Screen Communications .45

Command-Line Communications .45

Command-Line Options with VS2008 .46

Returning Values from Your Program .47

Summary .48

3 Writing C# Expressions and Statements 49 C# Operators .49

Unary Operators .49

Binary Operators .52

Relational Operators .54

Logical Operators .56

Assignment Operators .59

The Ternary Operator .60

Other Operators .60

Statements .62

Blocks and Scope .63

Labels .63

Operator Precedence and Associativity .64

Selection and Looping Statements .65

ifStatements .65

switchStatements .67

C# Loops .69

gotoStatements .74

breakStatements .75

continueStatements .76

returnStatements .76

Summary .77

4 Understanding Reference Types and Value Types 79 A Quick Introduction to Reference Types and Value Types .79

The Unified Type System .80

How the Unified Type System Works .80

Usingobjectfor Generic Programming .82

Performance Implications of Boxing and Unboxing .83

Reference Type and Value Type Memory Allocation .85

Reference Type Memory Allocation .86

Value Type Memory Allocation .86

Reference Type and Value Type Assignment .88

Reference Type Assignment .88

Value Type Assignment .91

More Differences Between Reference Types and Value Types .92 Inheritance Differences Between Reference Types

Types and Value Types .93

Object Size Considerations for Reference Types and Value Types .94

C# and NET Framework Types .94

C# Aliases and the CTS .95

UsingSystem.Guid .95

Working with System.DateTime .97

Nullable Types .102

Summary .103

5 Manipulating Strings 105 The C# String Type .105

Formatting Strings .106

Comparing Strings .109

Checking for String Equality .110

Concatenating Strings .111

Copying Strings .112

Inspecting String Content .113

Extracting String Information .114

Padding and Trimming String Output .115

Modifying String Content .117

Splitting and Joining Strings .118

Working with String Characters .119

Affecting CLR String Handling via the Intern Pool .121

TheStringBuilderClass .122

TheAppendMethod .123

TheAppendFormatMethod .123

TheEnsureCapacityMethod .123

TheToString()Method .124

Regular Expressions .124

Basic Regular Expression Operations .125

More Regular Expressions .126

Application for Practicing Regular Expressions .127

Summary .129

6 Arrays and Enums 131 Arrays .131

Single-Dimension Arrays .132

Multidimension Arrays .134

Jagged Arrays .135

TheSystem.ArrayClass .137

Array Bounds .137

Searching and Sorting .138

Using Enum Types .139

The System.Enum struct .142

Converting Between Enum Types, Ints, and Strings .142

Iterating Through Enum Type Members .144

OtherSystem.EnumMembers .144

Summary .145

7 Debugging Applications with Visual Studio 2008 147 Stepping Through Code .147

The Debugger Demo Program .147

Setting Breakpoints .148

Examining Program State .149

Stepping Through Code .150

Extra Must-Have Debugging Commands .152

Using the Debugger to Find a Program Error .152

Attaching to Processes .156

Summary .159

Part 2 Object-Oriented Programming with C# 8 Designing Objects 163 Object Members .163

Instance and Static Members .164

Fields .165

Constant Fields .165

readonlyFields .166

Methods .166

Properties .167

Declaring Properties .167

Using Properties .167

Auto-Implemented Properties .168

The VS2008 Property Snippet .169

Indexers .169

Reviewing Where Partial Types Fit In .170

Static Classes .171

TheSystem.ObjectClass .172

Checking an Object’s Type .172

Comparing References .172

Checking Equality .173

Getting Hash Values .173

Cloning Objects .173

Using Objects as Strings .174

Summary .175

Inheritance .178

Base Classes .178

Calling Base Class Members .179

Hiding Base Class Members .180

Versioning .180

Sealed Classes .183

Encapsulating Object Internals .184

Data Hiding .185

Modifiers Supporting Encapsulation .185

Access Modifiers for Objects .188

Containment and Inheritance .190

Polymorphism .190

Examining Problems That Polymorphism Solves .190

Solving Problems with Polymorphism .193

Polymorphic Properties .196

Polymorphic Indexers .196

OverridingSystem.ObjectClass Members .197

Summary .200

10 Coding Methods and Custom Operators 201 Methods .202

Defining Methods .202

Local Variables .203

Method Parameters .204

Overloading Methods .210

Overloading Operators .213

Mathematical Operator Overloads for Custom Types .213

Logical Operator Overloads on Custom Types .215

Additional Operator Overload Tips .217

Conversions and Conversion Operator Overloads .218

Implicit Versus Explicit Conversions .219

Custom Value Type Conversion Operators .222

Custom Reference Type Conversion Operators .225

Partial Methods .227

Extension Methods .228

Summary .230

11 Error and Exception Handling 231 Why Exception Handling? .232

Exception Handler Syntax: The Basic try/catchBlock .232

Ensuring Resource Cleanup with finallyBlocks .234

Handling Exceptions .235

Handling Different Exception Types .236

Handling and Passing Exceptions .237

Recovering from Exceptions .240

Designing Your Own Exceptions .243

checkedanduncheckedStatements .245

Summary .248

12 Event-Based Programming with Delegates and Events 249 Exposing Delegates .250

Defining Delegates .250

Creating Delegate Method Handlers .251

Hooking Up Delegates and Handlers .251

Invoking Methods Through Delegates .252

Multicasting with Delegates .252

Checking Delegate Equality .255

Implementing Delegate Inference .256

Assigning Anonymous Methods .256

Coding Events .258

Defining Event Handlers .258

Registering for Events .259

Implementing Events .261

Firing Events .263

Modifying Event Add/Remove Methods .266

Summary .271

13 Naming and Organizing Types with Namespaces 273 Why Namespaces? .274

Organizing Code .274

Avoiding Conflict .275

Namespace Directives .275

TheusingDirective .275

ThealiasDirective .276

Creating Namespaces .278

Namespace Members .281

Scope and Visibility .282

Namespace Alias Qualifiers .283

Extern Namespaces Alias .284

Summary .286

14 Implementing Abstract Classes and Interfaces 287 Abstract Classes .288

Abstract Class and Interface Differences .290

Implementing Interfaces .291

Defining Interface Types .291

Methods .292

Properties .292

Events .293

Implicit Implementation .293

Single Class Interface Implementation .293

Simulating Polymorphic Behavior .298

Explicit Implementation .304

Interface Mapping .310

Interface Inheritance .312

Summary .315

Part 3 Applying Advanced C# Language Features 15 Managing Object Lifetime 319 Object Initialization .320

Instance Constructors .320

Overloading Constructors .322

Default Constructors .323

Private Constructors .323

Inheritance and Order of Instantiation .324

Static Constructors .325

Object Initializers .326

Object Finalization .327

Automatic Memory Management .328

Memory Allocation .328

Inside the Garbage Collector .329

GC Optimization .330

Proper Resource Cleanup .331

The Problems with Finalizers .332

The Dispose Pattern .332

TheusingStatement .334

Interacting with the Garbage Collector .335

Controlling Objects .335

Summary .337

16 Declaring Attributes and Examining Code with Reflection 339 Using Attributes .340

Using an Attribute .340

Using Multiple Attributes .341

Using Attribute Parameters .342

Positional Parameters .342

Named Parameters .343

Attribute Targets .344

Creating Your Own Attributes .345

The AttributeUsage Attribute .345

Using Reflection .349

Discovering Program Information .350

Reflecting on Attributes .356

Dynamically Activating Code .357

Building Runtime Assemblies with Reflection.Emit .359

Summary .363

17 Parameterizing Type with Generics and Writing Iterators 365 Nongeneric Collections .366

Understanding the Benefits of Generics .366

Problems Solved by Generics .367

Generics Are Object-Oriented .370

Choosing Between Arrays, Nongeneric Collections, and Generic Collections .371

Building Generic Types .372

Implementing a Singly Linked List with Generics .373

Applying Generics Beyond Collections .381

Defining Type with Generics .384

Implementing Iterators .388

The GetEnumerator Iterator .388

Method Iterators .390

Property Iterators .391

Indexer Iterators .391

Operator Iterators .393

Iterators as a Sequence of Values .394

Disposing Iterators .395

Summary .396

18 Using Lambda Expressions and Expression Trees 397 Lambda Expressions .398

Lambda Syntax .398

Using Lambdas .398

Delegates and Lambdas .399

Expression Trees .404

Converting Lambdas to Expression Trees .404

Converting Expression Trees to Lambdas .405

Summary .406

Part 4 Learning LINQ and NET Data Access 19 Accessing Data with LINQ 409 LINQ to Objects .410

Basic LINQ Syntax .410

Extracting Projections .411

Filtering Data .412

Grouping Data .413

Joining Data .413

Building Hierarchies with Group Joins .414

Querying Relational Data with LINQ to SQL .414

Defining a DataContext .415

Querying Through the DataContext .418

ModifyingDataContextObjects .419

Calling Stored Procedures .420

Using SQL Functions .421

Modifying a Database with Stored Procedures .421

Extending Data Handling Logic with Partial Methods .425

Standard Query Operators .427

Sorting Operators .427

Set Operators .428

Filtering Operators .430

Quantifier Operators .431

Projection Operators .432

Partitioning Operators .433

Join Operators .433

Grouping Operators .434

Generation Operators .435

Equality Operators .436

Element Operators .437

Conversion Operators .438

Concatenation Operator .438

Aggregate Operators .439

Summary .439

20 Managing Data with ADO.NET 441 ADO.NET Architecture .441

ADO.NET Components .441

Connected and Disconnected Modes .443

Data Providers .444

Making Connections .445

Viewing Data .447

Manipulating Data .450

Inserting Data .450

Updating Data .451

Deleting Data .451

Calling Stored Procedures .452

Working with Disconnected Data .453

Reading Data into a DataSet .453

SavingDataSetModifications to the Database .454

LINQ to DataSet .458

DataTablesas Data Sources .458

Strongly Typed Field Access .458

Summary .459

21 Manipulating XML Data 461 Streaming XML Data .462

Writing XML .462

Reading XML .465

Working with the XML DOM .466

Reading XML with XPathDocument .466

Manipulating XML with XmlDocument .467

Easier Manipulation with LINQ to XML .468

LINQ to XML Objects .468

Creating XML Documents .468

Working with Namespaces with LINQ to XML .470

Reading XML Documents .471

Querying XML Documents .471

Modifying XML Documents .472

Summary .473

22 Creating Data Abstractions with the ADO.NET Entity Framework 475 An Overview of Entities .476

Starting the Entity Data Model in VS2008 .476

Querying Entities with Entity SQL .480

Accessing Entities .480

Selecting Entities .480

Creating Custom Entities .482

Mapping and Schemas .482

Adding a Custom Entity to a Model .483

Coding with LINQ to Entities .486

Querying Entities .486

Modifying Entity Data .487

Summary .489

23 Working with Data in the Cloud with ADO.NET Data Services 491 Adding ADO.NET Data Services to Your Project .492

Accessing ADO.NET Data Services via HTTP URIs .493

Viewing Entity Sets .493

Selecting Entity Items .493

Filtering Entity Results .495

Sorting Entities .497

Traversing Entity Associations .497

Writing Code with the ADO.NET Data Services Client Library .499

Querying Entities with WebDataQuery .499

Adding Entities .501

Updating Entities .501

Deleting Entities .502

Querying Entities with LINQ to Data Services .503

Using the WebDataGen.exe-Generated Classes .503

Summary .504

Part 5 Building Desktop User Interfaces 24 Taking Console Applications to the Limit 507 Introducing the PasswordGenerator Console Application .508

Interacting with the User .508

Handling Command-Line Input .510

Adding Color and Positioning to Consoles .511

Summary .514

25 Writing Windows Forms Applications 515 Windows Forms Fundamentals .516

VS2008 Support for Windows Forms .519

The Visual Design Environment .519

Files in a Windows Forms Application .520

How the Visual Designer Works .521

Using Windows Forms Controls .528

MenuStrip,StatusStrip, and ToolStripControls .531

Data Grids and Data Binding .533

Setting Up a Project for Data Binding .533

Binding Data to a ListBoxControl .534

Binding Data to a DataGridView .534

GDI+ Essentials .536

Brush,Pen, and GraphicsObjects .536

Fonts and Drawing Text .537

Additional Windows and Dialogs .539

Modal Versus Modeless Dialog Boxes .539

Window Communication .540

Common Dialogs .543

Summary .545

26 Creating Windows Presentation Foundation (WPF) Applications 547 Just Enough XAML .548

Introducing the WPF Application .548

Examining XAML .549

Controls in XAML .550

Managing Layout .551

Control Alignment, Sizing, and the Box Model .552

Canvas Layout .553

WrapPanelLayout .553

StackPanelLayout .554

UniformGridLayout .555

GridLayout .555

DockPanelLayout .559

WPF Controls .560

Border .560

Button Control .561

CheckBoxControl .561

ComboBoxControl .561

ContentControlControl .561

DockPanelControl .562

DocumentViewerControl .562

EllipseControl .563

ExpanderControl .563

FrameControl .563

GridControl .564

GridSplitterControl .564

GroupBoxControl .564

ImageControl .565

LabelControl .565

ListBoxControl .565

ListViewControl .565

MediaElementControl .565

MenuControl .565

PasswordBoxControl .566

ProgressBarControl .566

RadioButtonControl .566

RectangleControl .567

RichTextBoxControl .567

ScrollBarControl .567

ScrollViewerControl .568

SeparatorControl .568

SliderControl .569

StackPanelControl .569

StatusBarControl .569

TabControl .569

TextBlockControl .570

TextBoxControl .570

ToolBarControl .570

ToolBarPanelControl .570

TreeViewControl .571

UniformGridControl .571

ViewboxControl .572

WindowsFormsHostControl .572

WrapPanelControl .573

Event Handling .573

Data Binding .574

Overview of Data Binding .574

Displaying Lists of Data .575

Using Styles .578

Summary .580

Part 6 Designing Web User Interfaces 27 Building Web Applications with ASP.NET 583 The Web Application Model .583

A High-Level View of an ASP.NET Page Request .584

Where Does Your C# Code Reside? .584

Where Does Scalability and State Management Come In? .584

How Do I Comprehend Perceived Performance? .585

Why Should I Use ASP.NET .586

Starting an ASP.NET Project with VS2008 .586

A Lap Around an ASP.NET Page .588

What Makes a Web Form? .588

Code-Behind and the Page Life Cycle .590

Controls .593

Server Controls .593

HTML Controls .595

State Management .596

Global State with Application .596

Holding Updatable Information in Cache .596

Holding State for a Single Request .598

Issuing Cookies .598

User-Specific Information with Session State .599

Understanding Page State in ViewState .599

Page Reuse with Master Pages and Custom Controls .599

Navigation .603

Defining Site Layout with Web.sitemap .604

Navigation with the Menu Control .605

Implementing a TreeView .606

Adding Breadcrumbs with SiteMapPath .609

Theming a Site .609

Setting Up a Theme .610

Creating Skins .610

Creating Style Sheets .612

Securing a Website .612

Data Binding .614

Setting Up a Business Object .614

Simple Data Binding .615

Data Binding with an ObjectDataSource .615

Summary .617

28 Adding Interactivity to Your Web Apps with ASP.NET AJAX 619 What Is AJAX? .619

Setting Up an ASP.NET AJAX Site .620

The AJAX Page Life Cycle .621

Loading Custom Script Libraries .623

ASP.NET AJAX Controls .625

The UpdatePanel Control .625

The UpdateProgress Control .627

The Timer Control .628

Accessing Controls via JavaScript .628

Simple Control ID Access in JavaScript .629

Accessing Mangled ASP.NET Control IDs .631

Calling Web Services with ASP.NET AJAX .635

Reasons and Tradeoffs in Using AJAX with Web Services .636

Using AJAX with Web Services .636

Summary .640

29 Crafting Rich Web Applications with Silverlight 641 What Makes Silverlight Tick? .641

Where Do WPF and XAML Come In? .641

How Does Silverlight Relate to ASP.NET, JavaScript, and AJAX? .642

Starting a Silverlight Project in VS2008 .642

Creating a Silverlight Project .643

Understanding the Parts of a Silverlight Project .644

Handling Silverlight Events with C# .648

Adding a C# Handler for a Silverlight Control Event .648

Working with Data in Silverlight .649

Playing Media .652

Adding the MediaPlayer to a WebForm .652

Manipulating the MediaElement with C# .653

Animating UI Elements .655

Summary .657

30 Using NET Network Communications Technologies 661

Implementing Sockets .661

A Socket Server .662

A Socket Client .665

Working with HTTP .669

Performing FTP File Transfers .671

Putting Files on an FTP Server .671

Getting Files from an FTP Server .673

Sending SMTP Mail .675

A Quick Way to Send Email .675

Sending Emails with Attachments .676

Summary .676

31 Building Windows Service Applications 679 Creating Windows Service Projects in VS2008 .680

Running the Windows Service Wizard .680

Examining Windows Service Project Items .680

Coding Windows Services .683

Available Windows Service Method Overrides .683

Implementing Windows Service Method Overrides .684

Configuring a Windows Service .687

Installing a Windows Service .688

Configuring a ServiceProcessInstaller .689

Configuring a ServiceInstaller .690

Deploying the Windows Service .690

Building a Controller to Communicate with a Windows Service .691

Summary .693

32 Remoting 695 Basic Remoting .695

Remoting Server .696

Remoting Client .699

Remoting Setup .701

Channels .706

Lifetime Management .709

Summary .712

33 Writing Traditional ASMX Web Services 713 Web Service Basics .713

Web Service Technologies .713

A Basic Web Service .714

Viewing Web Service Info .716

Using Web Services .719

Summary .723

34 Creating Web and Services with WCF 725 Creating a WCF Application in VS2008 .726

Creating a Web Service Contract .727

Creating a WCF Web Service Interface .727

Declaring the ServiceContract Attribute .730

Declaring OperationContract Attributes .730

Constructing Data Contracts .730

Implementing Web Service Logic .732

Configuring a Web Service .734

Service Element .736

Endpoint Element .736

Behavior Element .736

Consuming a Web Service .737

Creating a Service Reference .737

Writing Client Code to Call a Web Service .738

Summary .739

Part 8 Examining NET Application Architecture and Design 35 Using the Visual Studio 2008 Class Designer 743 Visualizing Code .743

Getting Started Viewing Objects .744

Observing Associations, Inheritance, and Interfaces .747

Building an Object Model with the Class Designer .749

Summary .754

36 Sampling Design Patterns in C# 755 Overview of Design Patterns .755

The Iterator Pattern .756

Implementing IEnumerable .756

Implementing IEnumerator .758

Using the Iterator in Client Code .763

Surprising Behavior in the foreach Loop .764

Simplifying the Iterator Pattern with C# Iterators .767

Implementing the Proxy Pattern .768

Example of the Proxy Pattern .768

Using the Proxy Object .771

Implementing the Template Pattern .772

How the Template Pattern Is Used in the NET Framework .773

An Example of Implementing the Template Pattern .773

Summary .778

Potential Drag-and-Drop Problems .779

A RAD Application in 5 Minutes .780What Harm Is a Little Bit of Productivity? .781Introducing N-Layer/N-Tier .781Early Application Architectures .782N-Layer Architecture .782N-Tier Architecture .783Architecture Shouldn’t Be Academic .784N-Layer Architecture Examples .784N-Layer/Single-Assembly Architectures .785N-Layer/Multiple-Assembly Architectures .792Summary .795

38 Automating Logic with Windows Workflow 797Starting a Workflow Project .797Building a Sequential Workflow .798Creating the Workflow .798Executing the Workflow .802Building a State Workflow .803Overview of the Hospital Appointment State Workflow .803Creating Workflow States .804Communicating from Host to Workflow: Implementing

ExternalDataExchangeService .805Handling Events in the State Workflow .811Summary .813Part 9 Surveying More of the NET Framework Class Library

.NET Process Support .818Launching a New Process .818Working with Existing Processes .821Multithreading Overview .823Creating New Threads .823Running Code in a Thread with Less Code .824Passing Parameters to Threads .824Using the ThreadPool .825Thread Synchronization .826The C# lock Statement .826Inside lock: the Monitor Class .827Balancing Access Between Reader and Writer Threads .828Summary .829

40 Localizing and Globalization 831Resource Files .831Creating a Resource File .831Writing a Resource File .834Reading a Resource File .835Converting a Resource File .836Creating Graphical Resources .838Multiple Locales .843Implementing Multiple Locales .844Finding Resources .849Summary .851

41 Performing Interop (P/Invoke and COM) and Writing Unsafe Code 853Unsafe Code .854What Do You Mean My Code Is Unsafe? .854The Power of Pointers .855The sizeof() Operator .858The stackalloc Operator .860The fixed Statement .861Platform Invoke .864Communicating with COM from NET .866Early-Bound COM Component Calls .866Late-Bound COM Component Calls .868Exposing a NET Component as a COM Component .869Introduction to NET Support for COM+ Services .871Transactions .873JIT Activation .874Object Pooling .875Other Services .876Summary .876

42 Instrumenting Applications with System.Diagnostics Types 879Simple Debugging .880Conditional Debugging .881Runtime Tracing .884Making Assertions .886Accessing Built-In Performance Counters .888Implementing Timers .896Building a Customized Performance Counter .897Analyzing Performance with Sampling .908Summary .917

43 Assemblies and Versioning 921Inside Assemblies .921Manifests .922Attributes .923Assembly Features .925Identity .925Scope .925Versioning .925Security .926Configuration .927Startup Configuration .927Runtime Configuration .928Deployment .930Summary .930

Code-Based Security .933Evidence .934Permissions .934Code Groups .935Security Policy Levels .936Permission Requests .937Implementing Security Policy .940Role-Based Security .942Security Utilities .944Summary .945

45 Creating Visual Studio 2008 Setup Projects 947Running the VS2008 Setup Project Wizard .947Additional Setup Configuration .950File System Setup .950Creating Registry Settings .951File Types .951User Interface .952Launch Conditions .953Custom Actions .953Summary .954

Deploying via ClickOnce .955Configuring ClickOnce .957Summary .959

47 Publishing Web Applications 961The Anatomy of a Web Application .961Web Server Setup .962Virtual Directory Setup .963Web Server Deployment .965Publishing a Web App from VS2008 .965Summary .966Part 11 Appendixes

Advanced .969Assemblies .971

B Getting Help with the NET Framework 973Read This Book .973Index .974.NET Framework Class Library Documentation .974Search Engines .975Favorite Websites .975Summary .975Index .977

Joe Mayo has more than 21 years of software engineering experience and has worked

with C# and NET since July 2000 He regularly contributes to the community throughhis website, C# Station, which has been running since July 2000 He enjoys giving presen-tations on NET, and you can occasionally find him online in a forum or newsgroup,doing what he loves to do—talking about NET For his community service over the years,

he has been a recipient of multiple Microsoft Most Valuable Professional (MVP) awards.These days, Joe makes a living through the company he founded, Mayo Software

Consulting, Inc., delivering value to customers through custom NET software ment services

develop-To my beautiful wife, Maytinee You are the vision, the light guiding my way Your strength and support enable perseverance Mother of our children and best friend

I love and thank you dearly

—Joe Mayo

Acknowledgments

Although my name appears on the cover of this book, work of such magnitude couldnever have occurred without the valuable contributions of many people To the people atSams Publishing, Microsoft, and friends and family, I am eternally grateful

For C# 3.0 Unleashed (this version):

I’ d like to thank Neil Rowe, executive editor, for giving me the opportunity to write

the current version of C# 3.0 Unleashed and getting it started Thanks to Brook

Farling, acquisitions editor, for leading the bulk of the process and all his help.Andrew Beaster did a great job coordinating author reviews, and Mark Renfrowhelped keep my book organized and provided valuable tips along the way Thanksalso to Keith Cline for copyediting that polished the words very nicely

I was pleased to have worked with excellent tech editors for C# 3.0 Unleashed.

Thanks to Tony Gravagno, Todd Meister, and J Boyd Nolan for identifying glitches,valuable suggestions, and technical prowess

Thanks to the people at Microsoft who have worked on C#, the NET Framework,and Visual Studio Rafael Munoz, my MVP lead, was pivotal in helping me tocontact the right people for information

Here’s also a shout-out to the user groups on the Front Range who have allowed me

to give presentations on NET subjects and provided me with live feedback: theBoulder Visual Studio NET User Group, the Colorado Springs NET User Group, the

For the first version of C# Unleashed, I want to thank Shelley Kronzek, executive

editor, for finding me and offering this wonderful opportunity Her leadership isinspiring Susan Hobbs, development editor, was totally awesome, keeping me onfocus and organized Maryann Steinhart, copyeditor, made my writing look great.Other people at Sams Publishing I’d like to recognize include Katie Robinson, LeahKirkpatrick, Elizabeth Finney, Pamalee Nelson, and Laurie McGuire Thanks also toall the editors, indexers, printers, production, and other people at Sams who havecontributed to this book

Special thanks for the first version of C# Unleashed goes to Kevin Burton and Bill

Craun, technical editors Their technical expertise and advice was absolutely notch They provided detailed pointers, and their perspectives made a significantdifference Thanks to Keith Olsen, Charles Tonklinson, Cedric, and Christoph Willefor reviewing my early work

top- Thanks to all the people at Microsoft who set up author seminars and training Theyare transforming the way we do computing and leading the industry in a move ofhistoric proportions—an initiative deserving of much praise Special thanks to EricGunnerson for taking time out of his extremely busy schedule to review chapters ofthe first version

Thanks to family members:

Maytinee Mayo, Joseph A Mayo Jr., Jennifer A Mayo, Kamonchon Ahantric, Laceeand June Mayo, Bob Mayo, Margina Mayo, Richard Mayo, Gary Mayo, Mike Mayo,Tony Gravagno, Tim and Kirby Hoffman, Richard and Barbara Bickerstaff, Bobbie JoBurns, David Burns, Mistie Lea Bickerstaff, Cecil Sr and Margaret Sloan, Cecil Jr andJean Sloan, Lou and Rose Weiner, Mary and Ron Monette, Jack Freeman, Sr., and BillFreeman

Thanks to friends and professional associates:

Evelyn Black, Harry G Hall, Arthur E Richardson, Carl S Markussen, Ruby Mitchell,Judson Meyer, Hoover McCoy, Bill Morris, Gary Meyer, Tim Leuers, Angela Dees-Prebula, Bob Jangraw, Jean-Paul Massart, Jeff and Stephanie Manners, Eddie Alicea,Gary and Gloria Lefebvre, Bob Turbyfill, and Dick Van Bennekom, Barry Patterson,Otis Solomon, and Brian Allen

As the reader of this book, you are our most important critic and commentator We value

your opinion and want to know what we’re doing right, what we could do better, whatareas you’d like to see us publish in, and any other words of wisdom you’re willing topass our way

You can email or write me directly to let me know what you did or didn’t like about thisbook—as well as what we can do to make our books stronger

Please note that I cannot help you with technical problems related to the topic of this book, and that due to the high volume of mail I receive, I might not be able to reply to every message.

When you write, please be sure to include this book’s title and author, as well as yourname and phone or email address I will carefully review your comments and share themwith the author and editors who worked on the book

E-mail: feedback@samspublishing.com

Mail: Neil Rowe

Executive EditorSams Publishing

800 East 96th StreetIndianapolis, IN 46240 USA

Reader Services

Visit our website and register this book at www.informit.com/title/9780672329814 forconvenient access to any updates, downloads, or errata that might be available for thisbook

Welcome to C# 3.0 Unleashed, a programmer’s guide and

reference to the C# (pronounced “C sharp”) programminglanguage C# is primarily an object-oriented programminglanguage, created at Microsoft, which emphasizes a

component-based approach to software development In its third version, C# is still evolving, and this book guidesyou on a journey of learning how that evolution helps youaccomplish more in your software engineering endeavors.C# is one of several languages of the NET (pronounced

“dot net”) platform, which includes a runtime engine calledthe Common Language Runtime (CLR) and a huge classlibrary The runtime is a virtual machine that manages codeand provides several other services The class library

includes literally thousands of reusable objects and supportsseveral user interface technologies for both desktop andWeb Application development

C# is evolving as a programming language It began life as

an object-oriented, component-based language but now isgrowing into areas that were once considered the domain offunctional programming languages Throughout this book,you’ll see examples of objects and components being used

as building blocks for applications You’ll also see manyexamples that include Language Integrated Query (LINQ),which is a declarative way to query data sources, whetherthe data source is in the form of objects, relational, XML, orany other format

Just as C# (and the NET platform) has evolved, so has this

book C# Unleashed began as a language-centric learning

guide and reference for applying the C# programminglanguage The audience was varied because C# was newand developers from all types of backgrounds were

programming with it All the applications compiled on the command line, and all youneeded was the NET Framework SDK and an editor to do everything.

At its essence, the same concepts driving the first version of this book made it into thisversion For example, you don’t need to already know NET before getting started If

you’ve programmed with any programming language, C# 3.0 Unleashed should be an easy

on-ramp for you This book contains a few command-line examples, especially in thebeginning, because I believe that using the command line is a skill that is still necessaryand useful However, I quickly move to the Visual Studio 2008 (VS2008) IntegratedDevelopment Environment (IDE) for the largest share of the rest of the book You aren’trequired to use VS2008, however; I show you right away how to build your applicationswithout it, and Appendix A, “Compiling Programs,” is a guide to command-line options

with examples (just like the first version of C# Unleashed) However, VS2008 is an

incredi-ble tool for increasing productivity, and I provide tips throughout this book for crankingout algorithms with code-focused RAD

In addition to coverage of VS2008, I’ve included several new chapters for the newest nologies, such as Windows Presentation Foundation (WPF), Windows CommunicationFoundation (WCF), and AJAX If you like the cutting edge, there are chapters on theADO.NET Entity Framework and ADO.NET Data Services Speaking of data, I’ve added anentire part of this book with multiple chapters on working with data

tech-Since July 2000, when I cracked open the first public pre-beta release of NET, I’ve beenhooked, with C# as my language of choice I’ve made a good living and found my C#skills in demand, even in a difficult economy Most of all, I’ve gained an enormousamount of experience in both teaching, as a formal course instructor, and as a developer,delivering value to customers with an awesome toolset I hope that all the gotchas, tips,and doses of reality that I’ve encountered and shared in this book will help you learn andthrive as I have

Why This Book Is for You

If you’ve developed software in any other computer programming language, you will beable to understand the contents of this book with no trouble You already know how tomake logical decisions and construct iterative code You also understand variables andbasic number systems such as hexadecimal Novices may want to start with something at

the introductory level, such as Sams Teach Yourself C# in 21 Days Honestly, ambitious

beginners could do well with this book if they’re motivated

This is a book written for any programmer who wants to learn C# and NET It’s basicenough for you to see every aspect of C# that’s possible, yet it’s sufficiently advanced toprovide insight into the modern enterprise-level tasks you deal with every day

Organization and Goals

C# 3.0 Unleashed is divided into eight parts To promote learning from the beginning, it

starts with the simpler material and those items strictly related to the C# language itself.Later, the book moves into other C#-related areas, showing how to use data, user interfacetechnologies, web services, and other useful NET technologies

Part 1 is the beginning, covering basic C# language syntax and other essentials Chapter 1starts you off by discussing the NET platform This is an important chapter because youneed to know the environment that you are building applications for It permeates every-thing else you do as a C# developer and should be a place you return to on occasion toremind yourself of the essential ingredients of being a successful C# developer In

Chapter 2, you learn how to build a simple C# application using both the command lineand VS2008 It is just the beginning of much VS2008 coverage to come Chapter 3 isanother essential milestone for success in developing NET applications with C#, learningthe type system Chapters 4 and 5 show you how to work with strings and arrays, respec-tively By the time you reach Chapter 7, you’ll have enough skills necessary to write asimple application and encounter bugs So, I hope you find my tips on using the VS2008debugger helpful before moving on to more complexity with object-oriented programming

in Part 2

Part 2 covers object and component programming in C# In the first version of C#

Unleashed, I dedicated an entire chapter to basic object-oriented programming concepts What changed in C# 3.0 Unleashed is that I weaved some of those concepts into other

chapters This way, developers who already know object-oriented programming don’t have

to skip over an entire chapter, but those who don’t aren’t completely left out Mostly, Iconcentrate on how C# implements object-oriented programming, explaining thosenuances that are of interest to existing object-oriented programmers and necessary for anyC# developer

Part 3 teaches you some of the more advanced features of C# With an understanding ofobjects from Part 2, you learn about object lifetime—when objects are first instantiated andwhen they are cleaned up from memory An entire body of knowledge builds upon earlierchapters, leading to where you need to be to understand NET memory management, theGarbage Collector, what it means for you as a C# developer, and mostly, what you can do toensure that your objects and the resources they work with are properly managed

Part 4 gives you five chapters of data Feedback from the first version of this book cated that you wanted more So, now you can learn about LINQ to Objects, LINQ to SQL,ADO.NET, LINQ to DataSet, XML, LINQ to XML, ADO.NET Entity Framework, LINQ toEntities, ADO.NET Data Services, and LINQ to Data Services Really, five chapters aren’tthe end of the story, and there is good reason why I moved data earlier in the book: I useLINQ throughout the rest of the book In addition to learning how to use all of these dataaccess technologies, you’ll see many examples in the whole book

indi-Part 5 demonstrates how to use various desktop user interface technologies You havechoices, console applications, which were beefed up in NET 2.0, Windows Forms, andWPF By the way, if you are interested in Silverlight, you’ll want to read the WPF chapter

first because both technologies use XAML, the same layout, and the same control set Notonly does it help me bring more information to you on these new technologies, but it alsoshould be comforting that what you learn with one technology is useful with another,expanding your skill set as a NET developer.

Part 6 teaches you how to build web user interfaces ASP.NET is the primary web UI nology for NET today, and I provide a fair amount of coverage to help you get up-to-speed with it You’ll want to pay attention to the discussion of the difference betweendesktop and web applications because it affects how you develop ASP.NET applications Inrecent years, Asynchronous JavaScript and XML (AJAX) has become a hot topic I showyou how to use ASP.NET AJAX, which ships with VS2008, to make your ASP.NET pagesmore responsive to the user The newest web UI technology is Silverlight, which enablesyou to build interactive websites that were once only possible with desktop UI technolo-gies A couple of the new capabilities of Silverlight are easier ways to play audio and video

tech-on the web and animatitech-on; these new capabilities allow you to build web experiencessimilar to Adobe Flash

Part 7 brings you in touch with various communications technologies In a connectedworld, these chapters teach you how to use essential tools You learn how to use TCP/IP,HTTP, and FTP, and send email using NET Framework libraries The remoting chapter isstill there, as is the web services chapter However, an additional chapter covers the newWCF web services

Part 8 covers topics in architecture and design Many programmers learn C# and all thetopics discussed previously and then find their own way to build applications with whatthey’ve learned If they find an effective way to build applications, then that is positive.However, it’s common for people to want to know what the best way is for puttingtogether all of these objects, components, and services to build a usable application Idon’t have all the answers because architecture and design is a big topic, and there are asmany opinions about it as there are questions However, I’ve taken a quick foray into thesubject, showing you some of the techniques that have worked for me You learn how C#and NET support common design patterns and make it easy for you to use these patterns

I show you how to build an n-layered application and describe a couple more ways thatyou can take what I’ve presented and use it in your own way I also show you how to use

a couple NET tools, including the Class Designer, and introduce you to Windows

Workflow (WF), which has a graphical design surface for building applications graphically.Part 9 is a grab bag of technologies that could be important to your development, depend-ing on what you want to do For example, multithreading is something that most

programmers will do on occasion However, multithreading is a skill that most mers will need as multiprocessing and multicore CPUs become more common, meaningthat I added more multiprocessing/multithreaded information in this version of the book.Depending on where you are in the world, localization and globalization could be veryimportant, so I explain the essentials of resources and satellite assemblies for localization

program-depending on the needs of the project you are working on To help out, the chapter onInterop covers P/Invoke for interoperating with Win32 DLLs and COM Interop for

working with COM There’s also some information on working with COM+ For those ofyou who like a solution out of the box, I explain how to use the NET trace facilities forinstrumenting and logging There’s also a section on how to use existing performancecounters and how to instrument your own code with a custom performance counter fordiagnostics through the Windows Performance Monitor

Part 10 helps you with your ultimate goal: deploying code This is a series of quick ters to help you build setup programs and deploy desktop or web applications Before that,

chap-I give you some more information about assemblies and what they are made of TheSecurity chapter will help you learn how the NET Code Access Security (CAS) systemworks Along the way, I throw in several tips to ensure that your deployment endeavors gomore smoothly than if you would have had to do it alone

That’s what this book is all about I wish you luck in learning C# and hope that you find

C# 3.0 Unleashed a helpful learning tool and useful reference.

Learning C# Basics

Studio 2008

Value Types

Studio 2008

Introducing the NET

As a C# developer, it’s important to understand the

envi-ronment you are building applications on: Microsoft NET

(pronounced “Dot Net”) After all, your design and

development decisions will often be influenced by

code-compilation practicalities, the results of code-compilation, and

the behavior of applications in the runtime environment

The foundation of all NET development begins here, and

throughout this book I occasionally refer back to this

chapter when explaining concepts that affect the practical

implementation of C#

By learning about the NET environment, you can gain an

understanding of what NET is and what it means to you

You learn about the parts of NET, including the Common

Language Runtime (CLR), the NET Framework Class

Library, and how NET supports multiple languages Along

the way, you see how the parts of NET tie together, their

relationships, and what they do for you First, however, you

need to know what NET is, which is explained in the next

section

What Is NET?

Microsoft NET, which I refer to as just NET, is a platform

for developing “managed” software The word managed is

key here—a concept setting the NET platform apart from

many other development environments I’ll explain what

the word managed means and why it is an integral

capabil-ity of the NET platform

When referring to other development environments, as in

the preceding paragraph, I’m focusing on the traditional

Source Code Compiler Binary

Executable

FIGURE 1.1 Traditional compilation

Source Code Compiler Binary

Executable

FIGURE 1.2 Managed compilation

practice of compiling to an executable file that contains machine code and how that file isloaded and executed by the operating system Figure 1.1 shows what I mean about thetraditional compilation-to-execution process

In the traditional compilation process, the executable file is binary and can be executed bythe operating system immediately However, in the managed environment of NET, the fileproduced by the compiler (the C# compiler in our case) is not an executable binary.Instead, it is an assembly, shown in Figure 1.2, which contains metadata and intermediatelanguage code

As mentioned in the preceding paragraph, an assembly contains intermediate languageand metadata rather than binary code This intermediate language is called MicrosoftIntermediate Language (MSIL), which is commonly referred to as IL IL is a high-level,component-based assembly language In later sections of this chapter, you learn how ILsupports a common type system and multiple languages in the same platform

.NET STANDARDIZATION

.NET has been standardized by both the European Computer Manufacturers

Association (ECMA) and the Open Standards Institute (OSI) The standard is referred to

as the Common Language Infrastructure (CLI) Similarly, the standardized term for IL isCommon Intermediate Language (CIL)

In addition to NET, there are other implementations of CIL—the two most well known

by Microsoft and Novell Microsoft’s implementation is an open source offering for thepurposes of research and education called the Shared Source Common Language

Infrastructure (SSCLI) The Novell offering is called Mono, which is also open source

Beyond occasional mention, this book focuses mainly on the Microsoft NET tation of the CLI standard

implemen-The other part of an assembly is metadata, which is extra information about the codebeing used in the assembly Figure 1.3 shows the contents of an assembly

Assembly

Meta Data

IL

FIGURE 1.3 Assembly contents

Figure 1.3 is a simplified version of an assembly, showing only those parts pertaining tothe current discussion Assemblies have other features that illustrate the difference

between an assembly and an executable file Specifically, the role of an assembly is to be aunit of deployment, execution, identity, and security in the managed environment In

Part X, Chapters 43 and 44 explain more about the role of the assembly in deployment,identity, and security The fact that an assembly contains metadata and IL, instead of onlybinary code, has a significant advantage, allowing execution in a managed environment.The next section explains how the CLR uses the features of an assembly to manage codeduring execution

The Common Language Runtime (CLR)

As introduced in the preceding section, C# applications are compiled to IL, which is

executed by the CLR This section highlights several features of the CLR You’ll also see

how the CLR manages your application during execution

Why Is the CLR Important?

In many traditional execution environments of the past, programmers needed to perform

a lot of the low-level work (plumbing) that applications needed to support For example,you had to build custom security systems, implement error handling, and manage

totally manual process In a later section, you learn about how NET supports multiple