Part I: Design

1. Language Selection

Describes some of the issues that you should consider when picking a development language. The book assumes you will use Visual Basic, but this chapter describes some of the language's strengths and weaknesses.

2. Lifecycle Methodologies

Discusses different lifecycle methodologies such as the waterfall, iterative prototyping, and staged delivery models. It explains why Visual Basic is a particularly good tool for building applications iteratively.

3. Agile Methodologies

Explains different development strategies, such as agile development methods like extreme programming (XP), test-first development, and design by contract (DBC). Includes references to information on Microsoft's Web sites about using Visual Studio for agile development.

4. Object-Oriented Design

Discusses issues in object-oriented design. It introduces the Universal Modeling Language (UML) and gives some tips for designing an object-oriented system. It explains how Visual Studio Team Suite and Visual Studio Team Architect support UML, and mentions a few other UML tools that developers can use.

5. User-Interface Design

Explains important user-interface concepts such as the rule of 7 +/- 2 and tells how to use containers such as tab strips and scrolling controls to display large amounts of data. Discusses the merits and drawbacks of SDI and MDI applications, and examines menus, toolbars, and keyboard shortcuts. Also explains techniques for customizing the user interface for particular users and locales.

6. Data Storage Design

Discusses different data storage and retrieval strategies such as relational databases, XML, flat text files, the System Registry, compiled in data, resource files, and INI files. Explains how a program can serialize and deserialize its data. (Note that this chapter does not cover relational database design in depth. For example, it does not explain normalization and indexing in great detail, instead referring to other books for more information.)

7. Design Patterns

Provides an introduction to design patterns and anti-patterns in Visual Basic. Explains what design patterns and anti-patterns are, describes some of the most useful, and refers the reader to other books such as Visual Basic Design Patterns by Mark Grand and Brad Merrill (Indianapolis: Wiley, 2005) for additional details.

Part II: Meta-Development

8. Snippets, Macros, and Add-Ins

Explains how to write add-ins for the Visual Basic 2005 development environment. It briefly describes code snippets and explains when it is appropriate to use them rather than add-ins.

9. Scripting

Explains how a program can allow the end user to write and execute scripts. Tells how to let the user execute SQL statements, VBA code, and VB .NET scripts. Explains how a program can expose its object model so that the user can control it with VB .NET scripting. Also tells how a developer can use the same scripting techniques to give an application new functionality after it has been compiled.

10. Custom Controls and Components

Explains how to build custom controls. Describes the three main approaches for building custom controls: UserControl, subclassing, and from scratch. Also explains how to build a special particularly useful type of custom control called extender providers, and includes examples of some extremely useful data validation extender providers.

11. Property Support

Explains how to build custom property editors for use by custom controls. Also tells how to use type converters to allow editors such as the Properties window at design time and the PropertyGrid control at run-time to edit complex properties of an object.

12. Attributes and XML Comments

Explains useful attributes that you can use to "decorate" code. These attributes make extra information available to other developers (or yourself) who use the code later so that it is easier to use the code correctly.

Part III: Development

13. Documentation

Explains how a more complex project should be documented. Describes the special XML documentation comments supported by Visual Basic 2005, and provides advanced examples that show how to use them to automatically generate documentation and help files.

14. Development Philosophy

Explains advanced coding concepts that make development and maintenance of complex applications easier. Discusses ideas such as advanced design for testing, defensive and offensive programming, and writing code for people not computers. These ideas are particularly useful in large projects with possibly changing staff because they provide context for new developers moving onto a project.

15. Coding Standards

Explains my particular set of coding standards that make reading code easier. Explains the differences between my standards and those used by Microsoft and others. These standards offer a starting point for developing the rules that you decide to adopt. No set of standards is perfect, but using any standard is better than not following any standard.

16. Bug Proofing

Explains steps that developers can take to make bugs easier to find and repair. These methods are essential in large, complex applications. Explains shortcomings of the Try Catch Finally blocks and shows how to work around them. Explains how to use application-level events to catch all of an application's errors, and discusses advanced methods that allow the program to record and recover from errors.

17. Testing

Explains advanced debugging and testing techniques. Explains black box, white box, and unusual condition testing; regression, routine, module, and integration testing; and tells how to estimate the quality of a project. Describes the free NUnit testing tool and how it fits into a test-driven approach. Also describes the unit-test support built into Visual Studio 2005 Team System.

18. Deployment

Explains the deployment strategies available to Visual Basic 2005 applications. It shows how to provide extensibility by loading new modules and scripts into previously compiled applications. It also explains how to use serialization to allow backward and forward compatibility.

Part IV: Specific Techniques

19. Splash Screens

Explains how to quickly build impressive splash screens and About dialogs. Covers such techniques as shaped forms, rotated text, and links to Web pages.

20. Printing

Explains how to print in Visual Basic .NET. Shows how to use the standard .NET printing techniques to wrap text across pages and flow text around objects. Also describes a more natural procedural approach to printing that is more intuitive for most developers, and lets you display items such as page-by-page counts that are difficult when using the standard .NET printing model.

21. Threading

Explains how to use the new threading tools provided by Visual Basic 2005. Explains some of the issues involved in multi-threaded applications, such as access to the user interface thread and concurrency issues. With computer hardware speeds leveling off, multi-threading is one of the best ways to improve performance of intensive applications, but it comes with its own set of risks and assumptions.

22. Reflection

Explains one of the most powerful features in Visual Basic .NET: reflection. Shows how a program can use reflection to learn about modules, objects, properties, and methods in its own code, and in other assemblies. Also explains how a program can use reflection to load modules that were written after the application was compiled.

23. Memory Management

Explains memory-management issues. Describes the garbage collector, shows how to implement and invoke Dispose methods, and how to use weak memory references to improve memory management.