INTRODUCTION

IT HAS BEEN SAID THAT SIR ISAAC NEWTON was the last person to know everything. He was an accomplished physicist (his three laws of motion were the basis of classical mechanics, which defined astrophysics for three centuries), mathematician (he was one of the inventors of calculus and developed Newton’s Method for finding roots of equations), astronomer, natural philosopher, and alchemist (okay, maybe the last one was a mistake). He invented the reflecting telescope, a theory of color, and a law of cooling, and he studied the speed of sound.

Just as important, he was born before relativity, quantum mechanics, gene sequencing, thermodynamics, parallel computation, and a swarm of other extremely difficult branches of science.

If you ever used Visual Basic 3, you too could have known everything. Visual Basic 3 was a reasonably small but powerful language. Visual Basic 4 added classes to the language and made Visual Basic much more complicated. Versions 4, 5, and 6 added more support for database programming and other topics such as custom controls, but Visual Basic was still a fairly understandable language, and if you took the time you could become an expert in just about all of it.

Visual Basic .NET changed the language in much more fundamental ways and made it much harder to understand every last detail of Visual Basic. The .NET Framework added powerful new tools to Visual Basic, but those tools came at the cost of increased complexity. Associated technologies have been added to the language at an ever-increasing rate, so today it is impossible for anyone to be an expert on every topic that deals with Visual Basic.

To cover every nook and cranny in Visual Basic you would need an in-depth understanding of database technologies, custom controls, custom property editors, XML, cryptography, serialization, two- and three-dimensional graphics, multi-threading, reflection, the code document object model (DOM), diagnostics, globalization, web services, inter-process communication, work flow, Office, ASP, Windows Forms, WPF, and much more.

This book doesn’t even attempt to cover all of these topics. Instead, it provides a broad, solid understanding of essential Visual Basic topics. It explains the powerful development environment that makes Visual Basic such a productive language. It describes the Visual Basic language itself and explains how to use it to perform a host of important development tasks.

It also explains the forms, windows, controls, and other objects that Visual Basic provides for building applications in a modern windowing environment.

This book may not cover every possible topic related to Visual Basic, but it does cover the majority of the technologies that developers need to build sophisticated applications.

SHOULD YOU USE VISUAL BASIC 2012?

Software engineers talk about five generations of languages (so far). A first-generation language (1GL) is machine language: 0s and 1s. For example, the binary command 00110010 00001110 00010010 00000000 might mean to combine the register CL with the value at address 12H by using the exclusive-or (XOR) operation. Pretty incomprehensible, right? You actually had to program some early computers by painstakingly toggling switches to enter 0s and 1s!

A second-generation language (2GL) is an assembly language that provides terse mnemonics for machine instructions. It provides few additional tools beyond an easier way to write machine code. In assembly language, the previous XOR command might look like “XOR CL, [12H].” It’s a lot better than assembly language but it’s still pretty hard to read. Third-generation languages (3GLs) are higher-level languages such as Pascal and FORTRAN. They provide much more sophisticated language elements such as subroutines, loops, and data structures. In Visual Basic, the previous example might look something like total = total Xor value.

Fourth-generation languages (4GLs) are natural languages, such as SQL. They let developers use a language that is sort of similar to a human language to execute programming tasks. For example, the SQL statement “SELECT * FROM Customers WHERE Balance > 50” tells the database to return information about customers who owe more than $50.

Fifth-generation languages (5GLs) provide powerful, highly graphical development environments to allow developers to use the underlying language in more sophisticated ways. The emphasis is more on the development environment than on the language itself.

The Visual Studio development environment is an extremely powerful fifth-generation tool. It provides graphical editors to make building forms and editing properties easy and intuitive; IntelliSense to help developers remember what to type next; auto-completion so developers can use meaningful variable names without needing to waste time typing them completely by hand; tools that show call hierarchies indicating which routines call which others; and breakpoints, watches, and other advanced debugging tools that make building applications easier.

Visual Studio is so powerful that the answer to the question of whether you should use it is practically obvious: If you want to write powerful applications that run in a Windows operating system, you should use Visual Studio.

Visual Basic is not the only language that uses Visual Studio. The C# language does, too, so now the question is, should you use Visual Basic or C#?

A Visual Basic programmer’s joke asks, “What’s the difference between Visual Basic .NET and C#? About three months!” The implication is that Visual Basic .NET syntax is easier to understand and building applications with it is faster. Similarly, C# programmers have their jokes about Visual Basic .NET, implying that C# is more powerful.

In fact, Visual Basic .NET is not a whole lot easier to use than C#, and C# is not significantly more powerful. The basic form of the two languages is very similar. Aside from a few stylistic differences (Visual Basic is line-oriented; C# uses lots of braces and semicolons), the languages are comparable. Both use the Visual Studio development environment, both provide access to the .NET Framework of support classes and tools, and both provide similar syntax for performing basic programming tasks.

The main difference between these languages is one of style. If you have experience with previous versions of Visual Basic, you will probably find Visual Basic 2012 easier to get used to. If you have experience with C++ or Java, you will probably find C# (or Visual C++ or Visual J#) easy to learn.

Visual Basic does have some ties with other Microsoft products that increase its value. For example, Active Server Pages (ASP) and ASP.NET use Visual Basic to create interactive web pages. Microsoft Office applications (Word, Excel, PowerPoint, and so forth) and many third-party tools use Visual Basic for Applications (VBA) as a macro programming language. If you know Visual Basic, you have a big head start in using these other languages. ASP and VBA are based on pre-.NET versions of Visual Basic, so you won’t instantly know how to use them, but you’ll have an advantage if you need to learn ASP or VBA.

If you are new to programming, either Visual Basic 2012 or C# is a good choice. I think Visual Basic 2012 is a little easier to learn, but I may be slightly biased because I’ve been using Visual Basic since long before C# was invented. You won’t be making a big mistake either way, and you can easily switch later, if necessary.

WHO SHOULD READ THIS BOOK

This book is intended for programmers of all levels. It describes the Visual Basic 2012 language from scratch, so you don’t need experience with previous versions of the language. The book also covers many intermediate and advanced topics. It covers topics in enough depth that even experienced developers will discover new tips, tricks, and language details. After you have mastered the language, you may still find useful tidbits throughout the book, and the reference appendices will help you look up easily forgotten details.

The chapters move quickly through the more introductory material. If you have never programmed before and are intimidated by computers, you might want to read a more introductory book first. If you are a beginner who’s not afraid of the computer, you should have few problems learning Visual Basic 2012 from this book.

If you have programmed in any other language, fundamentals such as variable declarations, data types, and arrays should be familiar to you, so you should have no problem with this book. The index and reference appendices should be particularly useful in helping you translate from the languages you already know into the corresponding Visual Basic syntax.

HOW THIS BOOK IS ORGANIZED

The chapters in this book are divided into four parts plus appendices. The chapters in each part are described here. If you are an experienced programmer, you can use these descriptions to decide which chapters to skim and which to read in detail.

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 there are a few differences such as which keyboard shortcuts perform which tasks.

Chapter 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.

Chapter 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.

Chapter 3, “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.

Chapter 4, “WPF Designer,” explains how to use the Windows Presentation Foundation (WPF) form designer. This chapter is similar to Chapter 3 except that it covers WPF forms instead of Windows Forms.

Chapter 5, “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.

Chapter 6, “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, windows, 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.

Chapter 7, “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.

Chapter 8, “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 run time, 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.

Chapter 9, “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.

Chapter 10, “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 7 except it covers WPF controls instead of Windows Forms controls.

Chapter 11, “Using WPF Controls,” gives more detail about how you can use WPF controls. This chapter is similar to Chapter 8 except it deals with WPF controls instead of Windows Forms controls.

Chapter 12, “WPF Windows,” describes the windows that WPF applications use in place of Windows forms. This chapter is similar to Chapter 9 except it deals with WPF windows instead of Windows forms.

Chapter 13, “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.

Chapter 14, “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.

Chapter 15, “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).

Chapter 16, “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.

Chapter 17, “Program Control Statements,” describes the statements that a Visual Basic program uses to control code execution. These include decision statements, such as If, Then, and Else, and looping statements, such as For and Next.

Chapter 18, “Error Handling,” explains error handling and debugging techniques. It describes the Try Catch structured error handler and 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.

Chapter 19, “Database Controls and Objects,” explains how to use the standard Visual Basic database controls. These include database 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.

Chapter 20, “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.

Chapter 21, “Metro-Style Applications,” explains how to build Metro-style applications that run on Windows 8. It explains special considerations that you should take into account when writing Metro applications such as loading files asynchronously.

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.

Chapter 22, “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.

Chapter 23, “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.

Chapter 24, “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.

Chapter 25, “Collection Classes,” explains classes included in the .NET Framework 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.

Chapter 26, “Generics,” explains how you can build classes that can work with arbitrary 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: 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 printer, screen, keyboard, and mouse; and interact with the user through standard dialog box controls.

Chapter 27, “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.

Chapter 28, “Configuration and Resources,” describes some of the ways that a Visual Basic program can store configuration and resource values for use at run time. Some of the most useful of these include environment variables, the registry, configuration files, and resource files.

Chapter 29, “Streams,” explains the classes that a Visual Basic application can use to work with stream data. Streams allow you to manipulate different kinds of data, such as files or chunks of memory, in a uniform way.

Chapter 30, “Filesystem Objects,” describes classes that let a Visual Basic application interact with the filesystem. These include classes such as Directory, DirectoryInfo, File, and FileInfo that make it easy to create, examine, move, search, rename, and delete directories and files.

Part V: Appendices

The book’s appendices provide a categorized reference of the Visual Basic 2012 language. You can use them to quickly review the syntax of a particular command or to 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.

Appendix A, “Useful Control Properties, Methods, and Events,” describes properties, methods, and events that are useful with many different kinds of controls.

Appendix 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.

Appendix C, “Operators,” summarizes the standard operators such as +, <<, OrElse, and Like. It also gives the syntax for operator overloading.

Appendix 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 lambda statements (subroutines).

Appendix E, “Control Statements,” summarizes statements that control program flow, such as If Then, Select Case, and looping statements.

Appendix F, “Error Handling,” summarizes Try Catch error handling blocks.

Appendix G, “Windows Forms Controls and Components,” summarizes standard Windows Forms controls and components provided by Visual Basic 2012.

Appendix H, “WPF Controls,” summarizes the most useful WPF controls.

Appendix I, “Visual Basic Power Packs,” lists some additional tools that you can download to make Visual Basic development easier.

Appendix J, “Form Objects,” describes forms. 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.

Appendix K, “Classes and Structures,” summarizes the syntax for declaring classes and structures, and defining their constructors and events.

Appendix L, “LINQ,” summarizes LINQ and PLINQ syntax.

Appendix M, “Generics,” summarizes the syntax for declaring generic classes.

Appendix N, “Graphics,” summarizes the objects used to generate graphics in Visual Basic 2012. The earlier chapters in the book cover graphics only in passing while explaining how to print. This appendix provides more detail and a summary of the most useful graphics classes.

Appendix 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.

Appendix P, “Date and Time Format Specifiers,” summarizes standard and custom specifiers 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.

Appendix Q, “Other Format Specifiers,” summarizes formatting for numbers and enumerated types.

Appendix R, “The Application Class,” summarizes the Application class that provides properties and methods for controlling the current application.

Appendix 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.

Appendix T, “Streams,” summarizes the Visual Basic stream classes such as Stream, FileStream, MemoryStream, TextReader, and CryptoStream.

Appendix U, “Filesystem Classes,” summarizes methods that an application can use to learn about and manipulate the filesystem. 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.

Appendix V, “Visual Studio Versions,” describes the Visual Studio version that I used when writing this book and explains which versions you can use to reproduce the examples described here.

HOW TO USE THIS BOOK

If you are an experienced Visual Basic .NET programmer, you may want to skim the language basics covered in the first parts of the book. You may find a few new features that have appeared in Visual Basic 2012, so you probably shouldn’t skip these chapters entirely, but most of the basic language features are the same as in previous versions.

Intermediate programmers and those with less experience with Visual Basic .NET should take these chapters a bit more slowly. The chapters in Part III, “Object-Oriented Programming,” cover particularly tricky topics. Learning all the variations on inheritance and interfaces can be rather confusing so don’t skip those chapters unless you have previous experience with object-oriented programming.

Beginners should spend more time on these first chapters because they set the stage for the material that follows. It will be a lot easier for you to follow a discussion of file management or regular expressions if you are not confused by the error-handling code that the examples take for granted.

Programming is a skill best learned by doing. You can pick up the book and read through it quickly if you like (well, as quickly as you can given how long it is), but the information is more likely to stick if you open the development environment and experiment with some programs of your own.

Learning by doing may encourage you to skip sections of the book. For example, Chapter 1 covers the IDE in detail. After you’ve read for a while, you may want to skip some sections and start experimenting with the environment on your own. I encourage you to do so. Lessons learned by doing last longer than those learned by reading. Later, when you have some experience with the development environment, you can go back and examine Chapter 1 in more detail to see if you missed anything during your experimentation.

The final part of the book is a Visual Basic 2012 reference. These appendices present more concise, categorized information about the language. You can use these appendices to recall the details of specific operations. For example, you can read Chapter 27 to learn what generic classes are for and how to create them. Later you can use Appendix M to refresh your memory of the syntax for declaring a generic class.

NECESSARY EQUIPMENT

To read this book and understand the examples, you will need no special equipment. To use Visual Basic 2012 and to run the examples found on the book’s web page, you need any computer that can reasonably run Visual Basic 2012. That means a reasonably modern, fast computer with a lot of memory. See the Visual Basic 2012 documentation for Microsoft’s exact requirements and recommendations. (I use a dual-core 1.83 GHz Intel Core 2CPU system with 2 GB of memory and 164 GB of hard disk space running Windows 7 Ultimate. It’s a nice system and works well but I wouldn’t say it’s overkill.)

To build Visual Basic 2012 programs, you will also need a copy of Visual Basic 2012. You can download the free Express Edition of Visual Basic (and purchase other editions) at www.microsoft.com/visualstudio/products.

Don’t bother trying to run the examples shown here if you have a pre-.NET version of Visual Basic such as Visual Basic 6. The changes between Visual Basic 6 and Visual Basic .NET are huge, and many Visual Basic .NET concepts don’t translate well into Visual Basic 6. With some experience in C#, it would be much easier to translate the example programs into that language.

Much of the Visual Basic 2012 release is compatible with Visual Basic 2010 and earlier versions of Visual Basic .NET, however, so you can make many of the examples work with earlier versions of Visual Basic .NET. You will not be able to load the example programs downloaded from the book’s website, however, because Visual Basic programs are not generally backward compatible with earlier versions. You will need to open the source code files in an editor such as WordPad and copy and paste the significant portions of the code into your version of Visual Basic.

CONVENTIONS

To help you get the most from the text and keep track of what’s happening, a number of conventions have been used throughout the book.

For styles in the text:

• Important words are highlighted when they are introduced.
• Keyboard strokes are shown like this: Ctrl+A.
• Filenames, URLs, and code within the text are shown like this: persistence.properties. Code is presented in the following way:

We use a monofont type for most code examples.

SOURCE CODE

As you work through the examples in this book, you may choose either to type in all the code manually or to use the source code files that accompany the book. All the source code used in this book is available for download at www.wrox.com. Specifically for this book, the code download is on the Download Code tab at:

www.wrox.com/remtitle.cgi?isbn=1118314077

You can also search for the book at www.wrox.com by ISBN (the ISBN for this book is 978-1-118-31407-4) to find the code. And a complete list of code downloads for all current Wrox books is available at www.wrox.com/dynamic/books/download.aspx.

At the beginning of each chapter, we’ve provided a list of the major code files for the chapter. Throughout each chapter, you’ll also find references to the names of code files as needed in the text.

Most of the code on www.wrox.com is compressed in a .ZIP, .RAR archive, or similar archive format appropriate to the platform. Once you download the code, just decompress it with an appropriate compression tool.

Once you download the code, just decompress it with your favorite compression tool. Note that the programs won’t run or even load in Visual Studio properly if you don’t decompress them. If Visual Studio can’t open an example program, make sure you have decompressed it.

Alternatively, you can go to the main Wrox code download page at www.wrox.com/dynamic/books/download.aspx to see the code available for this book and all other Wrox books.

You can also download the book’s source code from its web page on my VB Helper website www.vb-helper.com/vb_prog_ref.htm. That page allows you to download all of the book’s code in one big chunk or by individual chapter.

ERRATA

We make every effort to ensure that there are no errors in the text or in the code. However, no one is perfect, and mistakes do occur. If you find an error in one of my books, like a spelling mistake or faulty piece of code, I would be very grateful for your feedback. By sending in errata you may save another reader hours of frustration and at the same time you will be helping me provide higher quality information.

To find the errata page for this book, go to www.wrox.com and locate the title using the Search box or one of the title lists. Then, on the book details page, click the Book Errata link. On this page you can view all errata that have been submitted for this book and posted by Wrox editors. A complete book list including links to each book’s errata is also available at www.wrox.com/misc-pages/booklist.shtml.

If you don’t spot “your” error on the Book Errata page, go to www.wrox.com/contact/techsupport.shtml and complete the form there to send us the error you have found. We’ll check the information and, if appropriate, post a message to the book’s errata page and fix the problem in subsequent editions of the book.

P2P.WROX.COM

For author and peer discussion, join the P2P forums at p2p.wrox.com. The forums are a web-based system for you to post messages relating to Wrox books and related technologies and interact with other readers and technology users. The forums offer a subscription feature to e-mail you topics of interest of your choosing when new posts are made to the forums. Wrox authors, editors, other industry experts, and your fellow readers are present on these forums.

At p2p.wrox.com you will find a number of different forums that will help you not only as you read this book but also as you develop your own applications. To join the forums, just follow these steps:

Once you join, you can post new messages and respond to messages other users post. You can read messages at any time on the web. If you would like to have new messages from a particular forum e-mailed to you, click the Subscribe to this Forum icon by the forum name in the forum listing.

For more information about how to use the Wrox P2P, be sure to read the P2P FAQs for answers to questions about how the forum software works as well as many common questions specific to P2P and Wrox books. To read the FAQs, click the FAQ link on any P2P page.

Using the P2P forums allows other readers to benefit from your questions and any answers they generate. I monitor my book’s forums and respond whenever I can help.

If you have other comments, suggestions, or questions that you don’t want to post to the forums, feel free to e-mail me at [email protected]. I can’t promise to solve every problem but I’ll try to help you out if I can.

IMPORTANT URLS

Here’s a summary of important URLs:

• www.vb-helper.com — My VB Helper website. Contains thousands of tips, tricks, and examples for Visual Basic developers.
• www.vb-helper.com/vb_prog_reg.htm — This book’s web page on my VB Helper website. Includes basic information, code downloads, errata, and more.
• p2p.wrox.com — Wrox P2P forums.
• www.wrox.com — The Wrox website. Contains code downloads, errata, and other information. Search for the book by title or ISBN.
• [email protected] — My e-mail address. I hope to hear from you!