Expert one-on-one Visual Basic 2005 Design and Development by Rod Stephens

Acknowledgments     ix
Introduction     xxi
Why Visual Basic?     xxi
Who Should Read This Book     xxii
How This Book Is Organized     xxiii
How to Use This Book     xxvi
What You Need to Use This Book     xxvi
p2p.wrox.com     xxvii
The Book's Web Site     xxviii
Design     1
Language Selection     3
Language Addiction     3
Disadvantages     4
Interpreted, Not Compiled     4
Language Features     6
Multiple Inheritance     7
Platform Dependencies     8
Upgrading from Visual Basic 6     8
GUI Building     8
Verbosity     9
Power and Flexibility     9
Advantages     9
Self-Documenting     10
Prototyping and Simple Applications     10
IDE     11
Language Relatives     11
Garbage Collection     11
Large Talent Pool     12
Summary     12
Lifecycle Methodologies     15
Lifecycle Stages     15
Idea Formulation and Refinement     16
Team Building     17
Requirements Gathering     19
Feasibility Analysis     21
High-level Design     23
Lower-Level Design     24
Implementation     25
Testing     26
Deployment     30
Support     31
Lifecycle Models     33
Throwaway     34
Waterfall     34
Prototyping     40
Mix and Match     46
Summary     47
Agile Methodologies     49
Agile Programming     49
Crystal Clear     51
Extreme Programming (XP)     52
Agile Versus Traditional Lifecycles     60
Agile Strengths and Weaknesses     61
Design by Contract     62
Microsoft Tools for Agile Development     67
Summary     68
Object-Oriented Design     69
The Bug Hunter Example     69
Building an Object Model     70
Picking Candidate Classes     70
Converting Candidates into Classes     71
Adding Internal Classes     74
Adding Database Classes     75
Studying Different Design Views     75
Improving the Classes     76
UML     79
Use Case Diagrams     80
Class Diagrams     83
Sequence Diagrams     85
Activity Diagrams     86
State Chart Diagrams     87
Component Diagrams     89
Deployment Diagrams     90
UML Summary     91
UML Tools     92
Summary     95
User-Interface Design     91
UI Design Philosophy     98
Give the User Control     98
Focus on Tasks     98
Advise, Don't Act     99
Help Users Do the Right Thing     100
Users     101
Understand the User's Job     101
Respect the User     101
Understand the User's Environment     102
Understand User Types     102
Forms     104
MDI versus SDI     104
Resizing Forms     105
Editors     107
Property Sheets     108
Design Principles     109
Prototype in Stages     110
Promote Form Flow     110
Group Related Items      113
Support Resizing     114
Support Different Font Sizes     115
Optimize Menus     119
Use Space Wisely     121
Design Good Headers     122
Preserve State     122
Undo and Redo     123
Accommodate Different Skills Levels     127
Provide Appropriate Feedback     129
Consistency     131
Summary     131
Data Storage Design     133
Relational Databases     133
Relational Database Products     139
Compiled-In Data     140
Resource Files     145
Satellite Assemblies     148
System Registry     149
INI Files     154
XML     157
Other Text File Formats     159
Object Databases     160
Summary     162
Design Patterns     163
Creation Patterns     164
Clone     164
Factory     168
Relation Patterns     170
Adapter     171
Facade     171
Interface     172
Behavior Patterns     172
Abstract Base Class      173
Chain of Responsibility     176
Chain of Events     178
Command     181
Delegation     183
Model, View, Controller     185
Property Procedure     193
Snapshot     195
Strategy     199
For More Information     201
Summary     201
Meta-Development     203
Snippets, Macros, and Add-ins     205
Snippets     205
Using Snippets     206
Making Snippets     208
Installing Snippets     211
Sharing Snippets     211
Macros     212
Recording Macros     213
Editing Macros     214
Modifying Macros     214
Using Sample Macros     218
Customizing Visual Studio     218
Sharing Macros     221
Add-ins     222
Making an Add-in     222
Adding Add-in Code     227
Making a Better Add-in     230
Learning About Other Objects     231
Summary     236
Scripting     237
Scripting Safely     237
Executing SQL Statements      241
Running Queries     241
Generating Queries     244
Running Commands     247
Executing Visual Basic Code     251
Running Code     251
Exposing an Object Model     254
Simplifying Scripting     257
Evaluating Expressions     259
Summary     261
Custom Controls and Components     263
Building Derived Controls     264
Setting Toolbox Bitmaps     270
Testing Controls     271
Building UserControls     272
Building Controls from Scratch     275
Building Components     282
Building Extender Providers     287
A Simple Example     289
A More Useful Example     291
Summary     294
Property Support     297
Customizations Overview     298
Displaying and Editing LineWidth     304
LineWidthEditor     304
LineWidthListBox     306
Displaying and Editing LineColor     307
Displaying and Editing PolyPolyline     308
PolyPolylineConverter     309
PolyPolylineEditor     310
Displaying Smart Tags     313
Displaying Property Sheets     319
Displaying Object Properties     322
Summary     328
Attributes and XML Comments     329
Attributes     330
Helping the Properties Window     332
Helping the Form Designer     339
Helping the Code Editor     340
Helping Serialization     344
XML Comments     347
Automatic Documentation     348
Design-Time Support     350
Recommended Tags     351
Recommendations     355
Summary     357
Development     359
Documentation     361
Documentation Timing     361
Documentation Types     364
User Documentation     364
Developer Documentation     369
XML Documentation     373
Custom XML Tags     374
Using XML Documentation     375
Program XmlDocToText     376
Program XmlDocToHtml     381
Summary     388
Development Philosophy     391
Program for People     392
Keep the User In Charge     393
Make the Program Find Errors     394
Make it Work First     395
Look Before You Leap     397
Do a Good Job; Then Move On     398
Use Object-Oriented Principles     399
Take Advantage of Visual Studio     400
Beware of the Weakest Link     401
Save Everything     403
Avoid the Bleeding Edge     404
Use the Agile Smorgasbord     405
Summary     406
Coding Standards     409
Names     410
Hungarian Notation     410
Component Names     411
Constant Names     413
Routine Variable Names     413
Other Names     414
Boolean Names     415
Abbreviations     415
Escaped Names     416
Class Names     416
Property Names     417
Method Names     417
Event Names     418
Declaring Variables     419
Overloading and Optional Parameters     422
ParamArrays     426
If Then and Select Case     427
Block Endings     429
Exit Points     430
Exit For, Exit Do, and Continue      431
End     432
Summary     432
Bug Proofing     435
Catching Bugs     435
Waiting for Bugs     436
Global Error Handling     438
Hunting for Bugs     441
Try Catch Blocks     445
Responding to Bugs     447
Summary     451
Testing     453
Testing Philosophy     453
Test Early and Often     454
Test Everything     455
Save Tests Forever     455
Don't Shoot the Messenger     456
Kinds of Tests     456
Sub-Unit Tests     456
Unit Tests     457
Integration Tests     458
System Tests     458
Regression Tests     459
Test Techniques     459
Exhaustive Testing     460
Black Box Testing     460
White Box Testing     461
Random Testing     461
Testing Mechanics     461
Testing Inside the Application     461
Testing Outside the Application     464
A Testing Example     465
Testing Tools     467
Visual Studio Testing Tools     470
GUI Testing     471
Summary     475
Deployment     477
Deployment Models     477
User Types     478
Major and Minor Releases     479
Agile Releases     480
Deployment Methods     480
ClickOnce     480
Windows Installer     486
Other Solutions     490
Xcopy     491
Summary     492
Specific Techniques     493
Splash Screens     495
Determining Splash Screen Contents     496
Displaying Splash Screens     498
Displaying About Dialogs     500
Providing Feedback     500
Controlling Item Placement     501
Shaping Forms     502
Filling Text     504
Rotating Text     505
Displaying Hidden Screens     506
Summary     508
Printing     511
Event-Driven Printing     512
Printing Forms     514
Wrapping Text     518
Flowing Text     522
Printing Procedurally     528
Summary      532
Threading     535
Threading Pros and Cons     536
Advantages     536
Disadvantages     537
Using Background Workers     542
UI Threading     542
Providing Feedback     547
Providing Graphical Feedback     550
Dividing Tasks     551
Understanding SyncLock     554
Summary     557
Reflection     559
Exploring Assemblies     559
Exploring Enumerations     567
Loading Classes Dynamically     571
Invoking Methods Dynamically     575
Discovering Resources     577
Retrieving Known Resources     580
Summary     583
Memory Management     585
Garbage Collection     585
Finalization     587
Disposing Resources     589
Disposing Custom Classes     590
Pre-allocating Objects     591
Weak References     595
Improving Garbage Collection     597
Summary     599
Index     601