CODING TECHNIQUES FOR MICROSOFT VISUAL BASIC .NET（影印版）

1 Visual Basic .NET from the Ground Up 1

What a Long, Strange Trip It’s Been 2

From COM to .NET 4

The .NET World 6

Why You Need to Learn Visual Basic .NET 8

What Are the Pieces and How Do They Fit Together? A .NET Framework Overview 9

Web Services 11

User Interface 11

Data and XML 12

Base Class Library 12

Common Language Runtime 13

Where Do We Start to Access Functionality from Visual Basic .NET Source Code? 15

Visual Basic .NET Is Object Oriented 16

A Brief Look at How the Visual Basic .NET Language Works 18

How Is a Visual Basic .NET Program Put Together? 20

Metadata—Data About Data 20

The Just-In-Time Compiler 21

Execution of Visual Basic .NET Code 22

Assemble the Troops 23

Configuring the Interactive Development Environment 23

A First Look at the Visual Basic .NET IDE 25

Some Visual Basic .NET Code 27

Files Created by the IDE for Our First .NET Program 33

Another Word on Assemblies 38

A Closer Look at the Code 41

You Mean I Get an Inheritance? 41

Starting Up Our Form1 Class 42

Warning! Don’t Fiddle with the Designer’s Code 46

The Big Event 47

Nothing but .NET 48

2 Object-Oriented Programming in Visual Basic .NET 49

An Object Lesson 49

Starting Out with Objects 50

A Class Is Really Only a Blueprint 50

Let’s Talk Objects 51

Our Form as an Object 52

Reading, Writing, Invoking 54

Inheritance 56

Understanding Namespaces 58

Inheriting from System.Windows.Forms.Form: Forms and Controls 62

A Word About Visual Basic .NET Controls 63

Check Out the Code 65

The Code Added for the Button 67

Enough Talk: Press F5 and Run Your Program 69

The Doppelganger Program: Creating Clones of the Form1 Class 70

Important Object Concepts from the Doppelganger Program 71

Using the Class View to Spy on Structure and Access Modifiers 76

More About Access Types 78

Overloading Methods 79

Some of the Overloaded Show Methods 81

Polymorphism 83

What’s Controlling Our Form When We Run It? 84

Try This Out 84

Your First Real Visual Basic .NET Program 86

Telling the Application Object Which Form to Run 88

Let’s Add Some Controls 90

Examining the Handiwork of the IDE-Generated Code 94

How Do We Hardwire the Controls? 98

Can You Name That Namespace? 98

Date and Time Arithmetic 99

Formatting the Date and Time 101

Let’s Run This Baby! 103

Conclusion 105

3 Writing Your First Class 109

Creating the Employee Class 110

Examining the Class Code 113

Our Class’s Namespace 118

Declaring Our Class 118

Using Shared Variables 120

Class Constructors 120

Overloading Constructors 121

MyBase.New 122

Assigning Values to Our Private Data Fields 123

Overriding 124

#Region 126

The Employee Class Properties 127

More About Inheritance 130

Virtual Methods 134

Synchronizing the Class View 134

Creating Instances of the Employee Class 136

Conclusion 140

4 Visual Basic .NET Data Types and Features 143

Getting to Know Data Types 143

Visual Basic .NET Data Types 144

Value Types 145

Reference Types 147

Data Type Features 148

The System.Object Class 149

Strong Typing 152

Type Safety 152

Data Widening 157

Garbage Collection: Getting Rid of Our Objects 160

The Stack and the Managed Heap 160

Conclusion 161

5 Examining the .NET Class Framework Using Files and Strings 163

What Exactly Is the .NET Framework? 164

Tapping into the .NET Framework 165

It All Starts with the System Namespace 165

Learning to Find and Use What You Need 169

Searching in Windows Class Viewer 170

Using the Namespaces 171

Examining the File Class 171

Streams 173

What’s the Difference Between a File and a Stream? 174

Reading and Writing Binary, Numeric, or Text Data 174

Using the File and StreamWriter Classes in the .NET Framework 175

Reading Our File 176

The FileInfo Class 177

Creating a New File 179

Enumerating Directory Entries Using the Framework 180

Let’s Talk Strings 183

What’s New in Strings? 184

Uninitialized Strings 184

Working with Strings 185

Copying and Cloning a String 187

Conclusion 190

6 Arrays and Collections in Visual Basic .NET 191

Building Your First Visual Basic .NET Array 192

Array Boundaries 194

Why Arrays Are Based on the System.Array Class 198

What If I Don’t Know How Many Elements I Need Ahead of Time? 202

Arrays Start at Zero in Visual Basic .NET 204

Initializing the Array During Declaration 204

Arrays Are Reference Types 205

Arrays in Action: A Roman Numeral Calculator 207

Writing the Code 208

Examining the Code 209

Caching Our Variables 210

Visual Basic .NET Collections 212

The ArrayList Collection 213

Queues 216

Stacks 218

Eliza and the Beginning of Artificial Intelligence 219

Eliza in Action 220

Coding Eliza 222

Topology of Our Dialog.vb Code Module 224

Writing the Dialog.vb Code Module 226

Examining Our Code 234

Arrays vs. Collections 235

The Entry Point for Eliza 236

Is the Patient Discussing the Good Doctor? 240

Can Eliza Return a Quick Response? 241

Can Eliza Translate the Patient’s Response to Make It a Question? 243

Return a Previous Patient Phrase 247

When All Else Fails 250

Calling the Module from the Form 251

Conclusion 253

7 Handling Errors and Debugging Programs 255

What Can Possibly Go Wrong? 255

Types of Visual Basic .NET Errors 258

The Classic Visual Basic Err Object Is Gone in Visual Basic .NET 259

Try, Catch, and Finally 259

Adding Structured Error Handling 261

The Try…Catch Block 262

Making Our Simple Program Even More Bullet Proof 264

The Finally Block 266

Setting a Breakpoint in Your Code 267

Running the Program Using the Debugger 268

Stepping Through Our Code 270

Helpful Debugging Windows 271

The Call Stack 276

The Debug and Trace Classes 278

Debug.WriteLine 278

Debug.Assert 279

Tracing 281

Adding a Tracing Class to Our Code 282

Examining the ErrorTrace.vb Code 284

Setting the Trace Level 288

Adding the Errors.vb Class to a Program 289

Adding Event Logging to Your Programs 293

The Philosophy of Logging Events to the Event Viewer 295

Adding Event Logging to the ErrorTrace.vb Class 296

Using Our New Event Logging Capability 300

Conclusion 301

8 Assemblies in Detail 303

The Right to Assemble 303

Private Assemblies 304

Shared Assemblies 305

The Other Parts of an Assembly 308

Reflection: How to Go About Examining Assemblies 309

The Assembly Spy Program 310

Building the Assembly Spy Program 313

Let’s Write Some Code 315

Examining the Code 320

Self-Examination: Contemplating Our Own Assembly 329

Code Signing 330

Creating a Strongly Named Assembly 330

The Global Assembly Cache Revisited 333

Assembly Versioning 335

New Variable Scoping in Visual Basic .NET 338

Namespace Scope 340

Determining the Scope of a Variable 340

Conclusion 341

9 File System Monitoring 343

The File Sentinel Program 344

How the File Sentinel Program Works 345

Starting to Write the File Sentinel Program 346

Adding the Sentinel Class to Our Program 349

Delegates 356

Handling the Changed, Created, and Deleted Events 358

Handling the Renamed and Error Events 360

Writing to Our Log File 361

Wiring Up the User Interface 362

Possible Enhancements to the File Sentinel 370

Introduction to Windows Services 372

The Life and Death of a Service 372

Building Our File Sentinel into a Windows Service 373

Adding Our Sentinel Class to Our Service 374

Updating the Service1.vb File 375

How Our Service Works 377

Looking at vbMonitorService in the Services Window 387

Debugging a Windows Service 389

Conclusion 392

10 Data Access with ADO.NET 393

From ADO to ADO.NET 393

ADO.NET from 50,000 Feet 394

Individual Tables, Not the Join, Are in a DataSet 395

Comparing Classic ADO and ADO.NET 397

A Closer Look at the Foundation of ADO.NET: The DataSet Object 399

The DataTable Object 400

The DataSet Object and XML 401

DataView Objects 402

Managed Providers in ADO.NET 402

A Common Provider Model 404

Enough Talk, Let’s Look at Some Code 405

Connecting to Our Data Source 406

Commands to Manipulate Data from the Data Source 406

Creating the DataReader Object 407

Putting the Pieces of Our DataReader Together 408

Writing a Simple SQLClient Class DataSet Program 410

Getting Started 410

Adding a DataAdapter Object to Our Program 414

Finishing the User Interface 418

A Sneak Preview of Our Data from the DataAdapter 419

XML Schema for the Customers Table 421

Just Add Code 422

Running Our Program 423

Editing Our Data 424

How the Code Works 424

Updating the Data Source 426

Conclusion 429

11 Data Sets in Detail 431

Looking Again at the ADO.NET Object Model 431

Data Sets and XML 434

Building the Data Set and XML Viewer Project 436

Adding the Connection, Data Adapter, and DataSet Objects 438

Adding Code to Our Program 439

How It Works 440

Generating XML from Our Data Set 441

Updating the Data Source 441

ADO.NET and XML 443

Examining Our Program’s XML Output 443

The XML Schema Output 444

Persisting Our XML Information 446

Testing Our Persistence Code 447

Examining the DiffGram 449

Leveraging Our XML File for New Classes 452

The Xsd.exe Program 452

Adding a Relationship to Our Program 455

The Data Sets and XML Program 456

Creating the Parent/Child Relationship 457

Adding a Relationship to Our Tables 458

Examining DataSet Properties 461

Populating a Data Grid from a Persisted XML File 462

Run the Program 463

How the Program Works 464

Hand Coding a Simple Program 465

Data Binding 467

Creating the Program 467

Adding the Code That Wires the Controls to the Data Set 469

Run the Program 470

How It Works 471

Updating Our Data Grid 476

Conclusion 476

12 ADO.NET Data Binding 477

The BindingContext Object 477

The CurrencyManager Object 479

Record Navigation 479

A Simple Example 479

Add the Code 481

How the Code Works 484

The DataTable, DataRow, and DataColumn Objects 488

Examining the DataTable Schema 488

Building a Table Programmatically 490

How the Code Works 491

Finding Specific Records 493

Conclusion 495

13 ASP.NET and Web Services 497

A Look Back at ASP 497

Why ASP.NET? 498

Our First Web Form 500

New Server Controls 503

The HTML Presentation Template 505

Viewing the Code-Behind File 508

Setting the Properties on Our Web Page 509

Adding the Calendar Control Code 510

Running the Web Form 511

Examining the HTML Sent to the Browser 512

Building a Loan Payment Calculator 514

Building Our Loan Application Project 517

Adding Code to the Code-Behind Form 519

The Life of a Web Form 520

How Our Program Works 521

Taking a Closer Look at Our Drop-Down List 523

Adding the Payment Schedule Page 524

Adding Our Class Code 526

How the Calculator Works 529

Tracing Our Program 532

Web Services: The New Marketplace 533

What Are Web Services? 533

OK, Now How Do We Communicate? 534

Finding Out Who Is Offering What in the Global Marketplace 535

Where Are Web Services Going? 537

Building a Web Service 538

Run the Program 540

Consuming the MagicEightBall Web Service 543

Building Our Web Services Client Program 545

Adding a Proxy Class to Our Program 546

Adding Code to get Our Magic Eight Ball Answers 547

Conclusion 548

14 Visual Inheritance and Custom Controls 549

Visual Inheritance 549

Building a Base Form 550

Adding the Inherited Form 552

Creating a Custom Control 555

Changing the Background Color of a Text Box 555

Building Our Control 556

Adding Code to Our Control 556

Adding Our Custom Control to the Host Form 558

How it Works 559

Putting it Together: What We’ve Learned So Far 561

How Do We Save the Notes? XML, Of Course 562

Building the Sticky Notes Progam 564

Constructing a Sticky Note 570

Adding Code to the Sticky Note 571

How Does it Work? 574

Adding Even Handler Delegates 575

The serialize Class in More Detail 577

When the User Quits the Sticky Notes Program 582

How the BaseNote Sticky Yellow Form Works 585

Deploying Our Sticky Notes Program 588

Installing Our Program on a Client Machine 592

Install the Sticky Notes Program 593

Conclusion 594

APPENDIX: Some Helpful ADO.NET Wizards 595

Using the Data Form Wizard 595

Run the Program 600

Under the Hood 601

Generating a Crystal Report from a Data Source 603

Building a Crystal Report 603

Getting Ready to View Our Report 609

INDEX