Visual Basic.Net for Dummies

Experienced Visual Basic programmers will benefit from this book as it highlights the features and functions of this new and much-changed version of Visual Basic.

All readers will delight in expert For Dummies author Wallace Wang's coverage of topics that include: Variables, constants, loops and other programming fundamentals, Visual Basic.NET syntax, Working with the new Visual Basic.NET IDE, Forms and controls, and Understanding Objects.

Contents

Introduction

About This Book

How to Use This Book

Foolish Assumptions

How This Book Is Organized

Part I: Creating a Visual Basic .NET Program

Part II: Creating User Interfaces

Part III: Making Menus

Part IV: The Basics of Writing Code

Part V: Making Decisions and Getting Loopy

Part VI: Writing Subprograms (So You Don't Go Crazy All at Once)

Part VII: Understanding Object-Oriented Programming

Part VIII: The Part of Tens

Icons Used in This Book

Where to Go from Here

Chapter 1: How Visual Basic .NET Works

Writing a Visual Basic .NET Program

Drawing a user interface

Defining properties to make your user interface unique

Writing BASIC code

Getting to Know Visual Basic .NET

Knowing the Drawbacks of the .NET

Chapter 2: Using the Visual Basic .NET User Interface

Loading Visual Basic .NET

Starting a new project

Loading an existing project

Welcome to the Visual Basic .NET User Interface

Manipulating your windows

Quitting Visual Basic .NET

Chapter 3: Designing Your First User Interface

Common Parts of a User Interface

Drawing objects with the Toolbox

Drawing your first user interface

Defining the Properties of Your User Interface

What properties do

Changing property settings

Changing property settings at design time

Defining the properties of your first user interface

Chapter 4: Writing BASIC Code

What Is BASIC Code?

Writing Visual Basic .NET Event-Handling Procedures

Creating an event-handling procedure the fast way

Creating an event-handling procedure the slower way

What can BASIC code do?

How Visual Basic .NET event-handling procedures work

Writing BASIC Code for Your First Visual Basic .NET Program

Chapter 5: User Interface Design 101

Before You Create Your User Interface

Know your user

Orient the user

Make the choices obvious

Be forgiving

Keep it simple

Designing Your Visual Basic .NET User Interface

Creating a form

Drawing objects on a form

Changing the properties of an object

Naming objects

Displaying text on an object

Changing the size of objects

Moving objects on the screen

Docking your objects within a form

Anchoring your objects

Copying an existing object (to avoid drawing a new one)

Deleting objects off the face of the earth

Selecting more than one object to move, copy, or delete

Defining the TabIndex property of your objects

Dimming objects

Making objects invisible

See How to Change Text on an Object for Yourself

Chapter 6: Designing Forms

Creating a Form

Naming your forms

Viewing different forms

Changing the Look of a Form

Coloring your forms

Putting a background image on a form

Drawing borders around forms

Minimizing and maximizing forms

Positioning a form on the screen

Removing (and adding) forms

Choosing Which Form Visual Basic .NET Displays First

Opening, Hiding, and Closing Forms

Opening a form

Hiding (and showing) a form

Closing a form

Chapter 7: Boxes and Buttons for Making Choices

Pushing Your Buttons

Creating Check Boxes and Radio Buttons

Creating a check box or radio button

Aligning your check boxes and buttons

Grouping check boxes and radio buttons

Displaying Text on a Button, Check Box, Radio Button, or GroupBox

Chapter 8: Text Boxes and Labels for Typing and Showing Words

Creating a Label or Text Box

Changing fonts displayed in a label or text box

Coloring text in a label or text box

Adding pretty borders

Aligning text within a label or text box

Customizing a Text Box

Word-wrapping text boxes

Making a password text box

Limiting the length of text

Chapter 9: Showing Choices with List and Combo Boxes

Making a List Box and a Combo Box

Creating list boxes and combo boxes

Choosing a combo box style

Filling List Boxes and Combo Boxes with Stuff

Sorting items in a list box or combo box

Removing items from a list box or combo box

Making Listed Items Look Pretty

Chapter 10: Fine-Tuning the Appearance of Your User Interface

Resizing Your Objects

Neatly Aligning Objects

Putting Space Between Your Objects

Centering Your Objects

Locking Down Your Objects

Locking (and unlocking) all the objects on a form

Locking (and unlocking) individual objects

Chapter 11: Creating and Editing Pull-Down Menus

The Basic Elements of a Menu Bar

Making Menus for Your User Interface

Adding and deleting menu titles and commands

Moving menu titles and commands around

Naming Menus

Making Menus Pretty

Putting separator bars in menus

Assigning shortcut keys

Putting check marks next to menu commands

Dimming menu commands

Making menu commands invisible

Chapter 12: Submenus, Growing Menus, and Pop-Up Menus

Creating Submenus

Changing Menu Commands While Your Program Is Running

Designing Dynamically Growing Menus

Making a dynamically growing menu at design time

Making a dynamically growing menu at run time

Making Pop-up Menus

Typing commands into a context menu

Making your context menu pop up

Copying commands into a context menu

Chapter 13: Showing Dialog Boxes

Creating a Simple Dialog Box

Adding icons to a dialog box

Defining the number and type of command buttons in a dialog box

Which command button did the user select in a dialog box?

Commonly Used Dialog Boxes

Displaying the OpenFile dialog box

Which file did the user choose from an OpenFile dialog box?

Displaying a SaveFile dialog box

Which file did the user choose from a Save As dialog box?

Displaying a Color dialog box

Which color did the user choose from the Color dialog box?

Displaying a Font dialog box

Which options did the user choose from the Font dialog box?

Displaying a Print dialog box

Displaying a PageSetup dialog box

Chapter 14: Writing Event-Handling Procedures

Working with the Code Editor

Expanding and collapsing BASIC code

Types of Events

Creating event-handling procedures

Getting to know the parts of event-handling procedures

Splitting the code editor in half

Using the Code Editor

Viewing Different Event Procedures

Writing an Event-Handling Procedure

Retrieving data from the user

Calculating a result from the data

Displaying a result to the user

The event-handling procedure that every program needs

Chapter 15: Using Variables

Reading Data

Understanding Values and Variables

Using variables

Assigning numbers to variables

Assigning strings to variables

Assigning variables to other variables

Assigning an object's property to a variable (and vice versa)

Understanding the Scope of Your Variables

Block variables

Procedure variables

Module variables

Namespace variables

Using Variables to Represent Objects

Chapter 16: Getting Data from the User

Retrieving Strings from the Text Property

Checking the Checked Property

Getting a Number from the Value Property

Selecting Multiple Items in a List Box or Combo Box

How many items did the user select?

Retrieving the items the user selected

Chapter 17: Math 101: Arithmetic, Logical, and Comparison Operators

Arithmetic and Concatenation Operators

Adding two numbers with the + operator

Subtracting two numbers with the ­ operator

Negating numbers with the ­ operator

Multiplying two numbers with the * operator

Dividing two numbers with the / operator

Dividing two numbers with the \ operator

Dividing with the modulo ( Mod ) operator

Calculating an exponential with the ^ operator

Adding (concatenating) two strings with the & operator

Converting data types

Logical Operators

Using the Not operator

Using the And operator

Using the Or operator

Using the Xor operator

Comparison Operators

Comparing numbers and strings

Comparing strings with the = and <> operators

Comparing strings with the >, >=, <, and <= operators

Working with Precedence

Chapter 18: Strings and Things

Counting the Length of a String

Converting the Case of Strings

Converting from UPPERCASE to lowercase

Converting from lowercase to UPPERCASE

Converting a string to Proper Case

Trimming a String

Trimming leading spaces from strings

Trimming trailing spaces from strings

Trimming both leading and trailing spaces from strings

Extracting Stuff from a String

Extracting characters from the front of a string

Extracting characters from the end of a string

Extracting characters from the middle of a string

Searching (and Replacing) Your Strings

Finding part of a string with another string

Pattern-matching a string

Replacing part of a string with another string

Converting Strings and Values

Converting a string into a number

Converting a number into a string

Converting a string into an equivalent ASCII value

Converting an ANSI value into a string

Chapter 19: Defining Constants and Using Comments

Naming Constants

Declaring Constants

Calculating constants

Using constants

Defining the Scope of Constants

Private (local) constants

Module constants

Public constants

Using Comments

Creating comments

Comments for readability

Comments for legibility

Comments for disability

Chapter 20: Storing Stuff in Data Structures

Making an Array

Stuffing data into an array

Creating multidimensional arrays

Resizing an array

Creating a Structure

Creating a variable to represent your structure

Storing stuff in a structure

Combining structures with arrays

Tossing Stuff in a Collection

Adding stuff to a collection

Counting the number of items in a collection

Retrieving stuff from a collection

Removing stuff from a collection

Chapter 21: Killing Bugs

Types of Bugs

Syntax errors

Run-time errors

Logic errors

Bug Hunting

Realizing that your program has a bug

Finding the bug

Finding what's causing the bug

Squashing the bug

Setting an Error Trap

How Visual Basic .NET Tracks and Kills Bugs

Stepping through a program line by line

Setting breakpoints

Watching your variables

Chapter 22: Making Decisions with If-Then Statements

Understanding Boolean Values

Assigning a Boolean value to a variable

Assigning a Boolean value to an expression

The If-Then Statement

The If-Then-End If Statement

If-Then-Else Statement

The If-Then-ElseIf Statement

Making multiple choices with If-Then-ElseIf

Making sure that the computer follows at least one set of instructions

Nesting If-Then Statements

Chapter 23: The Select Case Statement

Using the Select Case Statement

Using the Select Case Statement with Comparison Operators

Making Sure the Computer Follows at Least One Set of Instructions

Nesting Case Statements

Chapter 24: Repeating Yourself with Loops

Looping Zero or More Times

Using a Do-While loop

Using a Do-Until loop

Looping at Least Once

Using a Do-Loop Until loop

Using a Do-Loop While loop

Comparing Your Loop Choices

Chapter 25: For-Next Loops That Can Count

How the For-Next Loop Works

Counting Backward and Forward

Use Caution When Using a For-Next Loop with the Step Increment

When to Use a For-Next Loop

Chapter 26: Nested Loops and Quick Exits

Nesting Your Loops

Tips for Using Nested Loops

Making Quick Exits from Loops

Chapter 27: General Procedures (Subprograms That Everyone Can Share)

Understanding Module Files

Creating General Procedures

Creating a general procedure in a form file

Creating and saving a general procedure in a module file

Naming a General Procedure

Calling a General Procedure

Chapter 28: Passing Arguments

Why Use Arguments?

Sending Arguments to a Procedure

Accepting Arguments

Passing arguments by value

Defining multiple arguments

Problems with Sending Arguments

Giving the wrong number of arguments

Giving the wrong type of arguments

Quitting a Procedure Prematurely

Chapter 29: Functions, a Unique Type of Subprogram

How to Create a Function

Creating a function in a form file

Creating and saving a function in a module file

Assigning a Value to a Function

Calling Functions

Defining a Function as a Certain Data Type

Defining argument types

Problems sending arguments

Quitting a Function Prematurely

Chapter 30: What the Heck Is Object-Oriented Programming?

The Divide and Conquer Method of Structured Programming

Dividing a large program into multiple subprograms

Declaring variables and data types

Using sequential, branching, or looping commands

Object-Oriented Programming to the Rescue (Sort of)

Encapsulation: Isolating your data and commands

Inheriting reusable code

Overloading existing code

Chapter 31: Getting Some Class with Object-Oriented Programming

Using Object-Oriented Programming in Visual Basic .NET

Creating a class file

Defining an object

Declaring your variables

Defining an object's properties

Writing an object's methods

Designing a class on paper

Using a Class Module in a Visual Basic .NET Program

Creating an object

Using an object

Try Class Modules Yourself

Chapter 32: Using Inheritance and Overloading

Why Use Inheritance?

Visual Inheritance: Copying a Form

Inheriting Code

Overriding Properties and Methods

Try Inheritance and Overriding Yourself

Chapter 33: Ten Visual Basic .NET Topics That Didn't Fit Anywhere Else

Buy, Read, or Steal Visual Basic Programmer's Journal

Spend a Bundle of Money and Get a Visual Basic .NET Newsletter

Visit a Web Site Dedicated to Visual Basic .NET

Attend a Visual Basic .NET Technical Conference

Shop from Mail-Order Dealers

Combine Visual Basic .NET with C# (and Other Programming Languages)

Participate in a Visual Basic .NET Open Source Project

Buy a Program to Create Help Files

Buy a Program to Create Installation Disks

Write BASIC Programs for the Macintosh, Linux, Palm OS, and the PocketPC

Chapter 34: (Almost) Ten Tips for Using the Visual Basic .NET User Interface

Playing with the Properties Windows (F4)

Using the Solution Explorer (Ctrl+Alt+L)

Customizing the Toolbox (Ctrl+Alt+X)

Customizing a Tab in the Toolbox

Adding Objects to a Custom Tab in the Toolbox

Deleting a Tab in the Toolbox

Looking at the Class View (Ctrl+Alt+C)

Appendix