What's New
Q & A
Tip Jar
C# Helper...
Follow VBHelper on Twitter Follow VBHelper on Twitter
MSDN Visual Basic Community
  Visual Basic 2010 Programmer's Reference: Table of Contents  
Overview Table of Contents Source Code
Updates Wrox Forum Info at Wrox.com
All Editions Sample Chapters

Part I: IDE

The chapters in this part of the book describe the Visual Studio integrated development environment (IDE) from a Visual Basic developer's point of view. The IDE is mostly the same for C# and other developers, but a few differences exist, such as which keyboard shortcuts perform which tasks.
1. Introduction to the IDE
Explains how to get started using the Visual Studio integrated development environment. It tells how to configure the IDE for different kinds of development. It defines and describes Visual Basic projects and solutions, and shows how to create, run, and save a new project.
2. Menus, Toolbars, and Windows
Describes the most useful and important commands available in the IDE's menus and toolbars. The IDE's menus and toolbars include hundreds of commands, so this chapter covers only those that are the most useful.
3. Customization
Explains how to customize the IDE. It tells how you can create, hide, and rearrange menus and toolbars to make it easy to use the tools that you find most useful.
4. Windows Forms Designer
Describes the designer you can use to build Windows Forms. It explains how to create, size, move, and copy controls. It tells how to set control properties and add code to respond to control events. It also explains how to use handy designer tools such as smart tags and command verbs.
5. WPF Designer
Explains how to use the Windows Presentation Foundation (WPF) form designer. This chapter is similar to Chapter 4 except that it covers WPF forms instead of Windows Forms.
6. Visual Basic Code Editor
Describes one of the most important windows used by developers: the code editor. It explains how to write code, set breakpoints, use code snippets, and get the most out of IntelliSense.
7. Debugging
Explains debugging tools provided by Visual Studio. It describes the debugging windows and explains techniques such as setting complex breakpoints to locate bugs.

Part II: Getting Started

The chapters in this part of the book explain the bulk of the Visual Basic language and the objects that support it. They explain the forms, controls, and other objects that a program uses to build a user interface, and they tell how you can put code behind those objects to implement the program's functionality.
8. Selecting Windows Forms Controls
Provides an overview of the Windows Forms controls that you can put on a form. It groups the controls by category to help you find the controls you can use for a particular purpose.
9. Using Windows Forms Controls
Gives more detail about how you can use Windows Forms controls. It explains how you can create controls at design time or runtime, how to set complex property values, and how to use useful properties that are common to many different kinds of controls. It explains how to add event handlers to process control events and how to validate user-entered data.
10. Windows Forms
Describes the forms you use in a Windows Forms application. Technically, forms are just another kind of control, but their unique position in the application's architecture means they have some special properties, and this chapter describes them.
11. Selecting WPF Controls
Provides an overview of WPF controls. It groups the controls by category to help you find the controls you can use for a particular purpose. This chapter is similar to Chapter 8 except it covers WPF controls instead of Windows Forms controls.
12. Using WPF Controls
Gives more detail about how you can use WPF controls. This chapter is similar to Chapter 9 except it deals with WPF controls instead of Windows Forms controls.
13. WPF Windows
Describes the windows that WPF applications use in place of Windows forms. This chapter is similar to Chapter 10 except it deals with WPF windows instead of Windows forms.
14. Program and Module Structure
Describes the most important files that make up a Visual Basic project. It describes some of the hidden files that projects contain and explains some of the structure that you can give to code within a module, such as code regions and conditionally compiled code.
15. Data Types, Variables, and Constants
Explains the standard data types provided by Visual Basic. It shows how to declare and initialize variables and constants, and explains variable scope. It discusses technical topics, such as value and reference types, passing parameters by value or reference, and creating parameter variables on the fly. It also explains how to create and initialize arrays, enumerated types, and structures.
16. Operators
Describes the operators a program uses to perform calculations. These include mathematical operators (+, *, \), string operators (&), and Boolean operators (And, Or). The chapter explains operator precedence and potentially confusing type conversion issues that arise when an expression combines more than one type of operator (for example, arithmetic and Boolean).
17. Subroutines and Functions
Explains how you can use subroutines and functions to break a program into manageable pieces. It describes routine overloading and scope. It also describes lambda functions and relaxed delegates.
18. Program Control Statements
Describes the statements that a Visual Basic program uses to control code execution. These include decision statements, such as If, Then, or Else and looping statements, such as For and Next.
19. Error Handling
Explains error handling and debugging techniques. It describes the Try Catch structured error handler, in addition to the older On Error statement inherited from early versions of Visual Basic. It discusses typical actions a program might take when it catches an error. It also describes important techniques for preventing errors and making errors more obvious when they do occur.
20. Database Controls and Objects
Explains how to use the standard Visual Basic database controls. These include database connection components that manage connections to a database, DataSet components that hold data within an application, and data adapter controls that move data between databases and DataSets.
21. LINQ
Describes language integrated query (LINQ) features. It explains how you can write SQL-like queries to select data from or into objects, XML, or database objects. It also explains PLINQ, a parallel version of LINQ that can provide improved performance on multi-core systems.
22. Custom Controls
Explains how to build your own customized controls that you can then use in other applications. It covers the three main methods for creating a custom control: derivation, composition, and building from scratch. This chapter also provides several examples that you can use as starting points for controls of your own.
23. Drag and Drop, and the Clipboard
Explains how a Visual Basic program can support drag-and-drop operations. It tells how your program can start a drag to another application, respond to drag operations started by another application, and receive a drop from another application. This chapter also explains how you can copy data to and from the clipboard. Using the clipboard is similar to certain types of drag-and-drop operations, so these topics fit naturally in one chapter.
24. UAC Security
Describes the User Account Control (UAC) security model used by the Vista and Windows 7 operating systems. With UAC security, all users run with reduced "normal" user privileges. If a program must perform tasks requiring administrator permissions, a UAC dialog box allows you to elevate the application's privilege level. This chapter describes UAC security and explains how you can mark a program for privilege elevation.

Part III: Object-Oriented Programming

This part explains fundamental concepts in object-oriented programming (OOP) with Visual Basic. It also describes some of the more important classes and objects that you can use when building an application.
25. OOP Concepts
Explains the fundamental ideas behind object-oriented programming (OOP). It describes the three main features of OOP: encapsulation, polymorphism, and inheritance. It explains the benefits of these features, and tells how you can take advantage of them in Visual Basic.
26. Classes and Structures
Explains how to declare and use classes and structures. It explains what classes and structures are, and it describes their differences. It shows the basic declaration syntax and tells how to create instances of classes and structures. It also explains some of the trickier class issues such as private class scope, declaring events, and shared variables and methods.
27. Namespaces
Explains namespaces. It discusses how Visual Studio uses namespaces to categorize code and to prevent name collisions. It describes a project's root namespace, tells how Visual Basic uses namespaces to resolve names (such as function and class names), and demonstrates how you can add namespaces to an application yourself.
28. Collection Classes
Explains classes included in Visual Studio that you can use to hold groups of objects. It describes the various collection, dictionary, queue, and stack classes; tells how to make strongly typed versions of those classes; and gives some guidance on deciding which class to use under different circumstances.
29. Generics
Explains templates you can use to build new classes designed to work with specific data types. For example, you can build a generic binary tree, and then later use it to build classes to represent binary trees of customer orders, employees, or work items.

Part IV: Graphics

The chapters in this part of the book describe graphics in Visual Basic 2010. They explain the Graphics Device Interface+ (GDI+) routines that programs use to draw images in Visual Basic. They explain how to draw lines and text; how to draw and fill circles and other shapes; and how to load, manipulate, and save bitmap images. This part also explains how to generate printed output and how to send reports to the screen or to the printer.
30. Drawing Basics
Explains the fundamentals of drawing graphics in Visual Basic 2010. It describes the graphics namespaces and the classes they contain. It describes the most important of these classes, Graphics, in detail. It also describes the Paint event handler and other events that a program should use to keep its graphics up to date.
31. Brushes, Pens, and Paths
Explains the most important graphics classes after Graphics: Pen and Brush. It tells how you can use Pens to draw solid lines, dashed lines, lines with custom dash patterns, and lines with custom lengthwise stripe patterns. It tells how to use Brushes to fill areas with colors, hatch patterns, linear color gradients, color gradients that follow a path, and tiled images. This chapter also describes the GraphicsPath class, which represents a series of lines, shapes, curves, and text.
32. Text
Explains how to draw strings of text. It shows how to create different kinds of fonts, determine exactly how big text will be when drawn in a particular font, and use GDI+ functions to make positioning text simple. It shows how to use a StringFormat object to determine how text is aligned, wrapped, and trimmed, and how to read and define tab stops.
33. Image Processing
Explains how to load, modify, and save image files. It shows how to read and write the pixels in an image, and how to save the result in different file formats such as BMP, GIF, and JPEG. It tells how to use images to provide auto-redraw features, and how to manipulate an image pixel-by-pixel, both using a Bitmap's GetPixel and SetPixel methods and using "unsafe" access techniques that make pixel manipulation much faster than is possible with normal GDI+ methods.
34. Printing
Explains different ways that a program can send output to the printer. It shows how you can use the PrintDocument object to generate printout data. You can then use the PrintDocument to print the data immediately, use a PrintDialog control to let the user select the printer and set its characteristics, or use a PrintPreviewDialog control to let the user preview the results before printing.

Part V: Interacting with the Environment

The chapters in this part of the book explain how an application can interact with its environment. They show how the program can save and load data in external sources (such as the System Registry, resource files, and text files); work with the computer's screen, keyboard, and mouse; and interact with the user through standard dialog controls.
35. Configuration and Resources
Describes some of the ways that a Visual Basic program can store configuration and resource values for use at runtime. Some of the most useful of these include environment variables, the Registry, configuration files, and resource files.
36. Streams
Explains the classes that a Visual Basic application can use to work with stream data. Some of these classes are FileStream, MemoryStream, BufferedStream, TextReader, and TextWriter.
37. File-System Objects
Describes classes that let a Visual Basic application interact with the file system. These include classes such as Directory, DirectoryInfo, File, and FileInfo that make it easy to create, examine, move, rename, and delete directories and files.
38. WCF
Describes the Windows Communication Foundation (WCF), a library and set of tools that make building service-oriented applications easier. This chapter explains how to use new WCF attributes to easily define a service, how to use configuration files to configure the service, and how to use WCF tools to consume the service.
40. Useful Namespaces
Describes some of the more useful namespaces defined by the .NET Framework. It provides a brief overview of some of the most important System namespaces and gives more detailed examples that demonstrate regular expressions, XML, cryptography, reflection, threading, parallel programming, and Direct3D.


The book's appendixes provide a categorized reference of the Visual Basic 2010 language. You can use them to quickly review the syntax of a particular command or refresh your memory of what a particular class can do. The chapters earlier in the book give more context, explaining how to perform specific tasks and why one approach might be better than another.
A. Useful Control Properties, Methods, and Events
Describes properties, methods, and events that are useful with many different kinds of controls.
B. Variable Declarations and Data Types
Summarizes the syntax for declaring variables. It also gives the sizes and ranges of allowed values for the fundamental data types.
C. Operators
Summarizes the standard operators such as +, <<, OrElse, and Like. It also gives the syntax for operator overloading.
D. Subroutine and Function Declarations
Summarizes the syntax for subroutine, function, and property procedure declarations. It also summarizes the syntax for using lambda functions and statements (subroutines).
E. Control Statements
Summarizes statements that control program flow, such as If Then, Select Case, and looping statements.
F. Error Handling
Summarizes both structured and classic error handling. It describes some useful exception classes and gives an example showing how to build a custom exception class.
G. Windows Forms Controls and Components
Summarizes standard Windows Forms controls and components provided by Visual Basic 2010. It explains the properties, methods, and events that I have found most useful when working with these components.
H. WPF Controls
Summarizes the most useful WPF controls.
I. Visual Basic Power Packs
Describes Visual Basic Power Packs provided by Microsoft and others that you make find useful
J. Form Objects
Describes forms. In a very real sense, forms are just another type of control, but they play such a key role in Visual Basic applications that they deserve special attention in their own appendix.
K. Classes and Structures
Summarizes the syntax for declaring classes and structures, and defining their constructors and events.
Summarizes LINQ and PLINQ syntax.
M. Generics
Summarizes the syntax for declaring generic classes.
N. Graphics
Summarizes the objects used to generate graphics in Visual Basic 2010. It covers the most useful graphics namespaces.
O. Useful Exception Classes
Lists some of the more useful exception classes defined by Visual Basic. You may want to throw these exceptions in your own code.
P. Date and Time Format Specifiers
Summarizes specifier characters that you can use to format dates and times. For example, they let you display a time using a 12-hour or 24-hour clock.
Q. Other Format Specifiers
Summarizes formatting for numbers and enumerated types.
R. The Application Class
Summarizes the Application class that provides properties and methods for controlling the current application.
S. The My Namespace
Describes the My namespace, which provides shortcuts to useful features scattered around other parts of the .NET Framework. It provides shortcuts for working with the application, computer hardware, application forms, resources, and the current user.
T. Streams
Summarizes the Visual Basic stream classes such as Stream, FileStream, MemoryStream, TextReader, CryptoStream, and so forth.
U. File-System Classes
Summarizes methods that an application can use to learn about and manipulate the file system. It explains classic Visual Basic methods such as FreeFile, WriteLine, and ChDir, as well as newer .NET Framework classes such as FileSystem, Directory, and File.
V. Index of Examples
Briefly describes the more than 400 example programs that are available for download on the book's Web site. You can use this list to see which programs demonstrate particular techniques.


  Visual Basic 2010 Programmer's Reference: Table of Contents  
Overview Table of Contents Source Code
Updates Wrox Forum Info at Wrox.com
All Editions Sample Chapters

Copyright © 1997-2010 Rocky Mountain Computer Consulting, Inc.   All rights reserved.