Visual Basic .NET for Beginners

Owned Forms, InputBox

2011-07-23T03:14:00.000-07:00

Owned Forms
Visual Basic also allows us to create owned forms. An owned form is tied to the form that owns it. If you minimize the owner form, the owned form will also be minimized, if you close the owner form, the owned form will be closed and so on. Owned Forms are added to a form with the AddOwnedForm method and removed with the RemoveOwnedForm method. The following code demonstrates the creation of owned forms. Drag a Button from the toolbox onto the form (form1). When you click the button, Form1 will make an object of the Form class into an owned form and displays it. The code for that looks like this:

Public Class Form1 Inherits System.Windows.Forms.Form
Dim OwnedForm1 As New Form()

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e_
As System.EventArgs) Handles Button2.Click
Me.AddOwnedForm(OwnedForm1)
'adding an owned form to the current form
OwnedForm1.show()
'displaying the owned form
End Sub

The image below displays output from above code.

InputBox Function
InputBox function gets a string of text entered by the user. They are similar to the JavaScript prompt windows that ask us to enter some text and performs some action after the OK button is clicked. In Visual Basic Input boxes let you display a prompt, read the text entered by the user and returns a string result. The following code demonstrates InputBox function. Drag a Button and TextBox control from the toolbox onto the form. When you click the Button, InputBox asks to enter some text and after you click OK it displays the text you entered in the TextBox. The image below displays output.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e_
As System.EventArgs) Handles Button1.Click
Dim s As String = InputBox("Enter some text")
'storing the text entered in a string
TextBox1.Text = s
'displaying string in the textbox
End Sub

Working with Forms (Continued)

2011-07-23T03:11:00.000-07:00

Adding a New Form to the Project
You can add a new form to the project with which you are working. To do that, select File->Add New Item from the main menu which displays a window asking you what to add to the project. Select Windows Form from the window and click Open to add a new form to the project. Alternatively, you can add a new form with the Solution Explorer. To add a new form with the Solution Explorer, right-click on the project name in Solution Explorer and Select Add->Add Windows Form. Once you finish adding a new form, if you want the form which you added to be displayed when you run the application you need to make some changes. You need to set the new form as Startup Object. To do that, right-click on the project name in Solution Explorer window and select Properties which displays the Property Pages window. On this window click the drop-down box which is labeled as Startup Object. Doing that displays all the forms available in the project. It looks like the image below.

Select the form which you want to be displayed when you run the application and click Apply. Now, when you run the application, the form you assigned as Startup object will be displayed.
Working with Multiple Forms
Let's see how we can work with more than one form/open a new form. Say, for example, we want to open a new form (Form2) when a button in the current form (Form1) is clicked. To do that, open a new project by selecting File->New->Project->Visual Basic->WindowsApplication. This adds a form (Form1) to the application. Add a new form (Form2) by selecting File->Add New Item->Windows Form. Also, drag a button (Button1) onto Form1. We want to open Form2 when the button in Form1 is clicked. Unlike earlier versions of Visual Basic, VB .NET requires us to refer to Form2 in Form1 in order to open it i.e creating an object of Form2 in Form1. The code for that looks like this:

Public Class Form1 Inherits System.Windows.Forms.Form
Dim other As New Form2()
'Creating a reference to Form2
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As_
System.EventArgs) Handles Button1.Click
other.Show()
End Sub

Visual Inheritance with Forms
As we know, Inheritance allows us to derive one class from another. VB. NET allows us to inherit one form from another. Let's see how we can inherit a new form from an existing form. Say, we have a form named Form1 with some controls on it and we want to inherit a new form from that form. To derive a new form from the existing one select Project->Add Inherited Form from the main menu. Doing that opens the Add New Item window. Double-click on the Inherited Form Icon in the templates box to open the Inheritance Picker. Inheritance Picker window looks like the image below.

Select Form1 in the picker and click OK. Clicking OK adds a new form, Form2, which is derived from Form1. Everything on Form2 including the title is copied from Form1. The only difference between form1 and form2 is, the controls on Form2 come with a special icon at the upper left corner which indicates that the form is inherited and the controls are locked. The image below displays a Inherited Form.

Inheriting a Form from Other Project
You can also inherit a form from other project. To inherit a form from other project, navigate to the project containing the form you want using the browse button in the Inheritance Picker dialog, click the name of the DLL file containing the form and click Open. This returns to the inheritance Picker dialog box where the selected project is now listed. Choose the appropriate form and click OK. A new inherited form is added to your project.

Working with Forms

2011-07-23T03:09:00.001-07:00

Well, let's now start working with Forms. When you open a new form you can have a look at the default properties of the form by selecting View->Properties Window or by pressing F4 on the keyboard. The properties window opens with default properties set to form by the software.
Briefly on Properties (Categorized):
Appearance
Appearance section of the properties window allow us to make changes to the appearance of the form. With the help of appearance properties we can have a background color, background image for the entire form, set the border style for the form from a predefined list, change the cursor, set the font for the text on the form and so on.
Behavior
Notable Behavior property is the enabled property which lets us enable/disable the form by setting the property to True/False.
Layout
Layout properties are all about the structure of the form. With these properties we can set the location of the form, maximum size of the form, minimum size of the form, exact size of the form with the size property when designing. Note the property start position, this property lets you specify the location of the form where it should appear when you run the application which you can select from a predefined list.
Window Style
The notable property under this is the ControlBox property which by default it is set to True. Setting the property to False makes the minimize, maximize and cancel buttons on the top right side of the form invisible.
Form Event
The default event of a form is the load event which looks like this in code:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)_
Handles MyBase.Load

End Sub

You can write code in the load event of the form just like you write for all other controls.
An Example:
You can run the Form by selecting Debug->Start from the main menu or by pressing F5 on the keyboard. When you run a blank form with no controls on it, nothing is displayed. It looks like the image below.

Now, add a TextBox and a Button to the form from the toolbox. The toolbox can be selected from
View->ToolBox on the main menu or by holding Ctrl+Alt+X on the keyboard. Once adding the TextBox and Button is done, run the form. The output window displays a TextBox and a Button. When you click the Button nothing happens. We need to write an event for the Button stating something should happen when you click it. To do that get back to design view and double-click on the Button. Doing that opens an event handler for the Button where you specify what should happen when you click the button. That looks like this in code.

Public Class Form1
Inherits System.Windows.Forms.Form
#Region " Windows Form Designer generated code "
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)_
Handles MyBase.Load
End Sub
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles Button1.Click
End Sub
End Class

Place the code TextBox1.Text="Welcome to Forms" in the Click event of the Button and run the application. When you click the Button the output "Welcome to Forms" is displayed in the TextBox.
Alternatively, you can also use the MsgBox or MessageBox functions to display text when you click on the Button. To do that place a Button on the form and double-click on that to open it's event. Write this line of code, MsgBox("Welcome to Forms") or MessageBox.Show("Welcome to Forms").

It looks like this in code.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles Button1.Click
MsgBox("Welcome to Forms")
End Sub

or

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles Button1.Click
MessageBox.Show("Welcome to Forms")
End Sub

When you run the form and click the Button, a small message box displays, "Welcome to Forms". The image below displays that.

Windows Form Properties

2011-07-23T03:08:00.000-07:00

Below are the properties of a Windows Form. Properties displayed below are categorized as seen in the properties window.

Appearance Properties	Description
BackColor	Gets/Sets the background color for the form
BackgroundImage	Get/Sets the background image in the form
Cursor	Gets/Sets the cursor to be displayed when the user moves the mouse over the form
Font	Gets/Sets the font for the form
ForeColor	Gets/Sets the foreground color of the form
FormBorderStyle	Gets/Sets the border style of the form
RightToLeft	Gets/Sets the value indicating if the alignment of the control's elements is reversed to support right-to-left fonts
Text	Gets/Sets the text associated with this form
Behavior Properties	Description
AllowDrop	Indicates if the form can accept data that the user drags and drops into it
ContextMenu	Gets/Sets the shortcut menu for the form
Enabled	Gets/Sets a value indicating if the form is enabled
ImeMode	Gets/Sets the state of an Input Method Editor
Data Properties	Description
DataBindings	Gets the data bindings for a control
Tag	Gets/Sets an object that contains data about a control
Design Properties	Description
Name	Gets/Sets name for the form
DrawGrid	Indicates whether or not to draw the positioning grid
GridSize	Determines the size of the positioning grid
Locked	Gets/Sets whether the form is locked
SnapToGrid	Indicates if the controls should snap to the positioning grid
Layout Properties	Description
AutoScale	Indicates if the form adjusts its size to fit the height of the font used on the form and scales its controls
AutoScroll	Indicates if the form implements autoscrolling
AutoScrollMargin	The margin around controls during auto scroll
AutoScrollMinSize	The minimum logical size for the auto scroll region
DockPadding	Determines the size of the border for docked controls
Location	Gets/Sets the co-ordinates of the upper-left corner of the form
MaximumSize	The maximum size the form can be resized to
MinimumSize	The minimum size the form can be resized to
Size	Gets/Sets size of the form in pixels
StartPosition	Gets/Sets the starting position of the form at run time
WindowState	Gets/Sets the form's window state
Misc Properties	Description
AcceptButton	Gets/Sets the button on the form that is pressed when the user uses the enter key
CancelButton	Indicates the button control that is pressed when the user presses the ESC key
KeyPreview	Determines whether keyboard controls on the form are registered with the form
Language	Indicates the current localizable language
Localizable	Determines if localizable code will be generated for this object
Window Style Properties	Description
ControlBox	Gets/Sets a value indicating if a control box is displayed
HelpButton	Determines whether a form has a help button on the caption bar
Icon	Gets/Sets the icon for the form
IsMdiContainer	Gets/Sets a value indicating if the form is a container for MDI child forms
MaximizeBox	Gets/Sets a value indicating if the maximize button is displayed in the caption bar of the form
Menu	Gets/Sets the MainMenu that is displayed in the form
MinimizeBox	Gets/Sets a value indicating if the minimize button is displayed in the caption bar of the form
Opacity	Determines how opaque or transparent the form is
ShowInTaskbar	Gets/Sets a value indicating if the form is displayed in the Windows taskbar
SizeGripStyle	Determines when the size grip will be displayed for the form
TopMost	Gets/Sets a value indicating if the form should be displayed as the topmost form of the application
TransparencyKey	A color which will appear transparent when painted on the form

Windows Forms

2011-07-23T03:05:00.001-07:00

In Visual Basic its these Forms with which we work. They are the base on which we build, develop all our user interface and they come with a rich set of classes. Forms allow us to work visually with controls and other items from the toolbox. In VB .NET forms are based on the System.Windows.Forms namespace and the form class is System.Windows.Forms.Form. The form class is based on the Control class which allows it to share many properties and methods with other controls. When we open a new project in Visual Basic the dialogue box that appears first is the one which looks like the image below. Since we are working with Windows Applications (Forms) you need to select WindowsApplication and click OK.

Once you click OK a new Form opens with the title, Form1, towards the top-left side of the form and maximize, minimize and close buttons towards the top right of the form. The whole form is surrounded with a border. The main area of the form in which we work is called the Client Area. It's in this client area we design the user interface leaving all the code to the code behind file. Forms also support events which let's the form know that something happened with the form, for example, when we double-click on the form, the Form load event occurs. VB .NET also supports forms to be inherited.
Image of a Windows Form.

Typically the Form looks like this in Code which is handled by the Framework.
Public Class Form1
Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "

Public Sub New()
MyBase.New()

'This call is required by the Windows Form Designer.
InitializeComponent()

'Add any initialization after the InitializeComponent() call

End Sub

'Form overrides dispose to clean up the component list.
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
If Not (components Is Nothing) Then
components.Dispose()
End If
End If
MyBase.Dispose(disposing)
End Sub

'Required by the Windows Form Designer
Private components As System.ComponentModel.IContainer

'NOTE: The following procedure is required by the Windows Form Designer
'It can be modified using the Windows Form Designer.
'Do not modify it using the code editor.
<System.Diagnostics.DebuggerStepThrough()> Private Sub InitializeComponent()
'
'Form1
'
Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
Me.ClientSize = New System.Drawing.Size(496, 493)
Me.Name = "Form1"
Me.Text = "Form1"

End Sub

#End Region

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

End Sub
End Class

Shortcut Keys

2011-07-20T10:02:00.000-07:00

Key	What it Does?
Ctrl + N	Opens the New Project Dialogue Box
Ctrl + Shift + O	Opens the Open File Dialog Box
Ctrl + Shift + A	Opens Add New Item window
Ctrl + D	Opens Add Existing Item window
Ctrl + S	Saves Current Form
Ctrl + Shift + S	Saves everything from Application
Alt + Q	Exits Visual Studio. NET
Ctrl + Z	Undo
Ctrl + Shift + Z	Redo
Ctrl + X	Cuts your selection
Ctrl + C	Copies your selection
Ctrl + V	Pastes your selection
Ctrl + A	Selects All
Del	Deletes your selection
Ctrl + F	Opens Find window
Ctrl + H	Opens Find and Replace window
Ctrl + Shift + H	Opens Replace in Files window
Ctrl + Alt + Shift + F12	Opens Find Symbol window
F7	Opens Code Designer window
Shift + F7	Gets you back to Design View
Ctrl + R	Opens the Solution Explorer window
Ctrl + Alt + S	Opens the Server Explorer window
Ctrl + Shift + C	Opens the Class View window
F4	Opens the Properties window
Ctrl + Shift + E	Opens the Resource view window
Ctrl + Alt + X	Opens the Toolbar window
Shift + Alt + Enter	Takes you to Full Screen View
Alt+F8	Opens Macro Explorer window
F2	Opens Object Browser window
Ctrl + Alt + T	Opens Document Outline window
Ctrl + Alt + K	Opens Task List window
Ctrl + Alt + A	Opens Command window
Ctrl + Alt + O	Opens Output window
Ctrl + Alt + Y	Opens Find Symbol Results window
Ctrl + Alt + F	Lists Items under the Favorites Menu in your Internet Explorer
Ctrl + Shift + B	Builds your project
F5	Runs your Application
Ctrl + F5	Runs your Application without Debugging
Ctrl + Alt + E	Opens the Exceptions Dialog Box
F8	Used while Debugging Applications
Shift + F8	Used While Debugging Applications
Ctrl + B	Inserts a New Breakpoint
Ctrl + Shift + F9	Clears All Breakpoints
Ctrl + Alt + P	Opens the Processes Dialog box
Ctrl + T	Opens Customize Toolbox window
Ctrl + Shift + P	Runs Temporary Macro
Ctrl + Shift + R	Records Temporary Macro
Alt + F11	Opens Macros IDE
Ctrl + F1	Opens Dynamic Help window
Ctrl +Alt + F1	Opens Help window sorted by Contents
Ctrl + Alt + F2	Opens Help window sorted by Index
Ctrl + Alt + F3	Opens Help Search window
Shift + Alt + F2	Opens Index Results window
Shift + Alt + F3	Opens Search Results window

Visual Studio .NET IDE

2011-07-20T10:00:00.000-07:00

Visual Studio .NET IDE (Integrated Development Environment) is the Development Environment for all .NET based applications which comes with rich features. VS .NET IDE provides many options and is packed with many features that simplify application development by handling the complexities. Visual Studio .NET IDE is an enhancement to all previous IDE’s by Microsoft.
Important Features
One IDE for all .NET Projects
Visual Studio .NET IDE provides a single environment for developing all types of .NET applications. Application’s range from single windows applications to complex n-tier applications and rich web applications.
Option to choose from Multiple Programming Languages
You can choose the programming language of your choice to develop applications based on your expertise in that language. You can also incorporate multiple programming languages in one .NET solution and edit that with the IDE.
IDE is Customizable
You can customize the IDE based on your preferences. The My Profile settings allow you to do this. With these settings you can set the IDE screen the way you want, the way the keyboard behaves and you can also filter the help files based on the language of your choice.
Built-in Browser
The IDE comes with a built-in browser that helps you browse the Internet without launching another application. You can look for additional resources, online help files, source codes and much more with this built-in browser feature.
When we open VS .NET from Start->Programs->Microsoft Visual Studio .NET->Microsoft Visual Studio .NET the window that is displayed first is the Start Page which is shown below. The start Page allows us to select from the most recent projects (last four projects) with which we worked or it can be customized based on your preferences.

The Integrated Development Environment (IDE) shown in the image below is what we actually work with. This IDE is shared by all programming languages in Visual Studio. You can view the toolbars towards the left side of the image along with the Solution Explorer window towards the right.

New Project Dialogue Box
The New Project dialogue box like the one in the image below is used to create a new project specifying it's type allowing us to name the project and also specify it's location on the disk where it is saved. The default location on the hard disk where all the projects are saved is C:\DocumentsandSettings\Administrator\MyDocuments\VisualStudioProjects.

Following are different templates under Project Types and their use.
Windows Application: This template allows to create standard windows based applications.
Class Library: Class libraries are those that provide functionality similar to Active X and DLL by creating classes that access other applications.
Windows Control Library: This allows to create our own windows controls. Also called as User Controls, where you group some controls, add it to the toolbox and make it available to other projects.
ASP .NET Web Application: This allows to create web-based applications using IIS. We can create web pages, rich web applications and web services.
ASP .NET Web Service: Allows to create XML Web Services.
Web Control Library: Allows to create User-defined controls for the Web. Similar to user defined windows controls but these are used for Web.
Console Application: A new kind of application in Visual Studio .NET. They are command line based applications.
Windows Service: These run continuously regardless of the user interaction. They are designed for special purpose and once written, will keep running and come to an end only when the system is shut down.
Other: This template is to develop other kinds of applications like enterprise applications, database applications etc.
Solution Explorer Window
The Solution Explorer window gives an overview of the solution we are working with and lists all the files in the project. An image of the Solution Explorer window is shown below.

Server Explorer Window
The Server Explorer window is a great tool that provides "drag and drop" feature and helps us work with databases in an easy graphical environment. For example, if we drag and drop a database table onto a form, VB .NET automatically creates connection and command objects that are needed to access that table. The image below displays Server Explorer window.

Intellisense
Intellisense is what that is responsible for the boxes that open as we type the code. IntelliSense provides a list of options that make language references easily accessible and helps us to find the information we need. They also complete the typing for us. The image below displays that.

Code Designer Window
Code Designers like the image below allows us to edit and write code. This is the window that opens when we double-click on a form or any control. This is the place where we write all the code for the application. Notice the two drop-down list boxes at the top of the code window in the image below. The left box allows us to select the object's code we are working with and the right box allows us to select the part of code that we want to work. Also notice the "+" and "-" boxes in the code designer. You can use those boxes to display code Visual Basic .NET already created, like, Windows Forms Designer generated code, etc.

Properties Window
The properties window allows us to set properties for various objects at design time. For example, if you want to change the font, font size, backcolor, name, text that appears on a button, textbox etc, you can do that in this window. Below is the image of properties window. You can view the properties window by selecting
View->Properties Window from the main menu or by pressing F4 on the keyboard.

Dynamic Help Window
The dynamic help window displays help which looks up for things automatically. For example, if you want to get help with a form, select the form and select Help->Dynamic Help from the main menu. Doing that displays all the information relating to forms. The image below displays that. You can get help relating to anything with this feature. Say, if you want to know more about the form, select the form and select Dynamic Help from the Help menu. Doing that displays information about the form as shown in the image below..

Command Window
The command window in the image below is a useful window. Using this window we can add new item to the project, add new project and so on. You can view the command window by selecting
View->Other Windows->Command Window from the main menu. The command window in the image displays all possible commands with File.

Task List Window
The task list window displays all the tasks that VB .NET assumes we still have to finish. You can view the task list window by selecting View->Show tasks->All or View->Other Windows->Task List from the main menu. The image below shows that. As you can see from the image, the task list displayed "TextBox1 not declared", "RichTextBox1 not declared". The reason for that message is, there were no controls on the form and attempts where made to write code for a textbox and a richtextbox. Task list also displays syntax errors and other errors you normally encounter during coding

Class View Window
The class view window like the image below is the window that presents solutions and projects in terms of the classes they contain and the members of these classes. Using the class view window also helps us to find a member of a class that we want to work with. As you can notice from the image, the class view window displayed all the methods and events for the controls which were available on the form.

Output Window
The output window as you can see in the image below displays the results of building and running applications.

Object Explorer Window
The object explorer window allows us to view all the members of an object at once. It lists all the objects in our code and gives us access to them. The image below displays an object explorer window. You can view the object explorer window by selecting View->Other Windows-> Object Browser from the main menu.

Toolbox Window
The toolbox window is the window that gives us access to all controls, components, etc. As you can see from the image below, the toolbox uses tabs to divide it's contents into categories (Data, Components, Windows Forms and General). The Data tab displays tools for creating datasets and making data connections, the Windows Forms tab displays tools for adding controls to forms, the General tab is left empty by default, the Clipboard Ring tab displays recent items stored in the clipboard and allows us to select from them.

Strings, Math Functions

2011-07-20T09:58:00.001-07:00

Strings
Strings in Visual Basic are supported by the .NET String class. The String data type can represent a series of characters and can contain approximately up to 2 billion Unicode characters. There are many built-in functions in the String class. Some .NET Framework functions are also built into the String class. The following code puts some String functions to work.

Imports System.Console
Module Module1

Sub Main()
Dim string1 As String = "Strings in Visual Basic"
Dim string2 As String
Dim string3 As String
Dim string4 As String
Dim string5 As String
Dim string6 As String
string2 = UCase(string1)
'converts string to uppercase
string3 = LCase(string1)
'converts string to lowercase
string4 = string1.Substring(11, 6)
'returns a substring
string5 = string1.Clone
'clones a string
string6 = string1.GetHashCode
'gets the hashcode
WriteLine(string2)
WriteLine(string3)
WriteLine(string4)
WriteLine(string5)
WriteLine(string6)
Read()
End Sub

End Module

The image below displays output from above code.

Math Functions
Visual Basic provides support for handling Mathematical calculations. Math functions are stored in System.Math namespace. We need to import this namespace when we work with Math functions. The functions built into Math class helps us calculate the Trigonometry values, Square roots, logarithm values, etc. The following code puts some Math functions to work.

Imports System.Console
Imports System.Math
Module Module1

Sub Main()
WriteLine("Sine 90 is" & " " & Sin(90))
'display Sine90 value
WriteLine("Square root of 81 is " & " " & Sqrt(81))
'displays square root of 81
WriteLine("Log value of 12 is" & " " & Log(12))
'displays the logarithm value of 12
Read()
End Sub

End Module

The image below displays output from above code.

Arrays

2011-07-20T09:57:00.001-07:00

Arrays are programming constructs that store data and allow us to access them by numeric index or subscript. Arrays helps us create shorter and simpler code in many situations. Arrays in Visual Basic .NET inherit from the Array class in the System namespace. All arrays in VB are zero based, meaning, the index of the first element is zero and they are numbered sequentially. You must specify the number of array elements by indicating the upper bound of the array. The upper bound is the numder that specifies the index of the last element of the array. Arrays are declared using Dim, ReDim, Static, Private, Public and Protected keywords. An array can have one dimension (liinear arrays) or more than one (multidimensional arrays). The dimensionality of an array refers to the number of subscripts used to identify an individual element. In Visual Basic we can specify up to 32 dimensions. Arrays do not have fixed size in Visual Basic.
The following code demonstrates arrays.

Imports System.Console
Module Module1

Sub Main()
Dim sport(5) As String
'declaring an array
sport(0) = "Soccer"
sport(1) = "Cricket"
sport(2) = "Rugby"
sport(3) = "Aussie Rules"
sport(4) = "BasketBall"
sport(5) = "Hockey"
'storing values in the array
WriteLine("Name of the Sport in the third location" & " " & sport(2))
'displaying value from array
End Sub

End Module

Understanding the Code
The above code declared a sport array of type string like this: Dim sport(5) as String. This sport array has 6 elements starting from sport(0) to sport(5). The first element of an array is always referred by zero index. The image below displays output from above code.

You can also declare an array without specifying the number of elements on one line, you must provide values for each element when initializing the array. The following lines demonstrate that:

Dim Test() as Integer
'declaring a Test array
Test=New Integer(){1,3,5,7,9,}

Reinitializing Arrays

We can change the size of an array after creating them. The ReDim statement assigns a completely new array object to the specified array variable. You use ReDim statement to change the number of elements in an array. The following lines of code demonstrate that. This code reinitializes the Test array declared above.

Dim Test(10) as Integer
ReDim Test(25) as Integer
'Reinitializing the array

When using the Redim statement all the data contained in the array is lost. If you want to preserve existing data when reinitializing an array then you should use the Preserve keyword which looks like this:

Dim Test() as Integer={1,3,5}
'declares an array an initializes it with three members
ReDim Preserve Test(25)
'resizes the array and retains the the data in elements 0 to 2

Multidimensional Arrays
All arrays which were mentioned above are one dimensional or linear arrays. There are two kinds of multidimensional arrays supported by the .NET framework: Rectangular arrays and Jagged arrays.
Rectangular arrays
Rectangular arrays are arrays in which each member of each dimension is extended in each other dimension by the same length. We declare a rectangular array by specifying additional dimensions at declaration. The following lines of code demonstrate the declaration of a multidimensional array.

Dim rectArray(4, 2) As Integer
'declares an array of 5 by 3 members which is a 15 member array
Dim rectArray(,) As Integer = {{1, 2, 3}, {12, 13, 14}, {11, 10, 9}}
'setting initial values

Jagged Arrays
Another type of multidimensional array, Jagged Array, is an array of arrays in which the length of each array can differ. Example where this array can be used is to create a table in which the number of columns differ in each row. Say, if row1 has 3 columns, row2 has 3 columns then row3 can have 4 columns, row4 can have 5 columns and so on. The following code demonstrates jagged arrays.
Dim colors(2)() as String
'declaring an array of 3 arrays
colors(0)=New String(){"Red","blue","Green"}
initializing the first array to 3 members and setting values
colors(1)=New String(){"Yellow","Purple","Green","Violet"}
initializing the second array to 4 members and setting values
colors(2)=New String(){"Red","Black","White","Grey","Aqua"}
initializing the third array to 5 members and setting values

Enumeration, Exception Handling

2011-07-20T09:55:00.000-07:00

Enumeration
Enumeration is a related set of constants. They are used when working with many constants of the same type. It's declared with the Enum keyword.
Example

Imports System.Console
Module Module1

Enum Seasons
Summer = 1
Winter = 2
Spring = 3
Autumn = 4
End Enum

Sub Main()
Write("Summer is the" & Seasons.Summer & "season")
End Sub

End Module

Output of above code is the image below. To use a constant from the enumeration it should be referred like this, Seasons.Winter and so on.

Constants
When we have certain values that we frequently use while programming, we should use Constants. A value declared as constant is of fixed value that cannot be changed once set. Constants should be declared as Public if we want it to be accessed by all parts of the application. In Visual Basic .NET we use the Const keyword to declare a constant. The following line of code declares a constant: Public Const Pi as Double=3.14159265
Exception Handling
Exceptions are runtime errors that occur when a program is running and causes the program to abort without execution. Such kind of situations can be handled using Exception Handling. By placing specific lines of code in the application we can handle most of the errors that we may encounter and we can enable the application to continue running. VB .NET supports two ways to handle exceptions, Unstructured exception Handling using the on error goto statement and Structured exception handling using Try....Catch.....Finally
Let's look at the new kind of exception handling introduced in VB .NET which is the Structured Exception Handling. VB .NET uses Try....Catch....Finally block type exception handling. The syntax looks like this:
Module Module1
Sub Main()
Try
-
-
Catch e as Exception
-
-
Finally
End Try
End Sub
End Module
Example

Imports System.Console
Module Module1

Sub Main()
Dim a = 0, b = 1, c As Integer
Try
c = b / a
'the above line throws an exception
WriteLine("C is " & c)
Catch e As Exception
WriteLine(e)
'catching the exception
End Try
End Sub

End Module

The output of the above code displays a message stating the exception. The reason for the exception is because any number divided by zero is infinity. When working with Structured exception handling you can have multiple Catch blocks to handle different types of exceptions differently. The code in the Finally block is optional. If there is a Finally block in the code then that code is executed last.

Operators

2011-07-20T09:54:00.000-07:00

Code Samples
Arithmetic Operators

Imports System.Console
Module Module1

Sub Main()
Dim x, y, z As Integer
x = 30
y = 20
z = x + y
WriteLine("Addition" & " = " & z)
z = x - y
WriteLine("Subtraction" & " = " & z)
z = x * y
WriteLine("Multiplication" & " = " & z)
z = x / y
WriteLine("Division" & " = " & z)
Read()
End Sub

End Module

The image below displays output from above code.

Concatenation Operators

Imports System.Console
Module Module1

Sub Main()
Dim str1, str2, str3, str4 As String
str1 = "Concatenation"
str2 = "Operators"
str3 = str1 + str2
WriteLine(str3)
str4 = str1 & str2
WriteLine(str4)
Read()
End Sub

End Module

The image below displays output from above code.

Comparison Operators

Imports System.Console
Module Module1

Sub Main()
Dim x, y As Integer
WriteLine("enter values for x and y ")
x = Val(ReadLine())
y = Val(ReadLine())
If x = y Then
WriteLine("x is equal to y")
ElseIf x < y Then
WriteLine("x is less than y")
ElseIf x > y Then
WriteLine("x is greater than y")
End If
Read()
End Sub

End Module

The image below displays output from above code.

Logical / Bitwise Operators

Imports System.Console
Module Module1

Sub Main()
Dim x As Boolean
x = Not 45 > 26
WriteLine("x not is false")
' x equals false
x = Not 26 > 87
' x equals True
WriteLine("x not is true")
Read()
End Sub

End Module

The image below displays output from above code.

Operators

2011-07-20T09:53:00.001-07:00

Visual Basic comes with many built-in operators that allow us to manipulate data. An operator performs a function on one or more operands. For example, we add two variables with the "+" addition operator and store the result in a third variable with the "=" assignment operator like this: int x + int y = int z. The two variables (x ,y) are called operands. There are different types of operators in Visual Basic and they are described below in the order of their precedence.
Arithmetic Operators
Arithmetic operators are used to perform arithmetic operations that involve calculation of numeric values. The table below summarizes them:

Operator	Use
^	Exponentiation
-	Negation (used to reverse the sign of the given value, exp -intValue)
*	Multiplication
/	Division
\	Integer Division
Mod	Modulus Arithmetic
+	Addition
-	Subtraction

Concatenation Operators
Concatenation operators join multiple strings into a single string. There are two concatenation operators, + and & as summarized below:

Operator	Use
+	String Concatenation
&	String Concatenation

Comparison Operators
A comparison operator compares operands and returns a logical value based on whether the comparison is true or not. The table below summarizes them:

Operator	Use
=	Equality
<>	Inequality
<	Less than
>	Greater than
>=	Greater than or equal to
<=	Less than or equal to

Logical / Bitwise Operators
The logical operators compare Boolean expressions and return a Boolean result. In short, logical operators are expressions which return a true or false result over a conditional expression. The table below summarizes them:

Operator	Use
Not	Negation
And	Conjunction
AndAlso	Conjunction
Or	Disjunction
OrElse	Disjunction
Xor	Disjunction

Data Type Conversion, File Extensions

2011-07-20T09:51:00.001-07:00

Converting between Data types
In Visual Basic, data can be converted in two ways: implicitly, which means the conversion is performed automatically, and explicitly, which means you must perform the conversion.
Implict Conversions
Let's understand implicit conversions in code. The example below declares two variable, one of type double and the other integer. The double data type is assigned a value and is converted to integer type. When you run the code the result displayed is an integer value, in this case the value displayed is 132 instead of 132.31223.

Imports System.Console
Module Module1

Sub Main()
Dim d=132.31223 as Double
Dim i as Integer
i=d
WriteLine("Integer value is" & i)
End Sub

End Module

Explicit Conversions
When types cannot be implicitly converted you should convert them explicitly. This conversion is also called as cast. Explicit conversions are accomplished using CType function.
CType function for conversion
If we are not sure of the name of a particular conversion function then we can use the CType function. The above example with a CType function looks like this:

Imports System.Console
Module Module1

Sub Main()
Dim d As Double
d = 132.31223
Dim i As Integer
i = CType(d, i)
'two arguments, type we are converting from, to type desired
WriteLine("Integer value is" & i)
End Sub

End Module

Below is the list of conversion functions which we can use in VB .NET.
CBool - use this function to convert to Bool data type
CByte - use this function to convert to Byte data type
CChar - use this function to convert to Char data type
CDate - use this function to convert to Date type
CDbl - use this function to convert to Double data type
CDec - use this function to convert to Decimal data type
CInt - use this function to convert to Integer data type
CLng - use this function to convert to Long data type
CObj - use this function to convert to Object type
CShort - use this function to convert to Short data type
CSng - use this function to convert to Single data type
CString - use this function to convert to String data type
Attributes
Attributes are those that lets us specify information about the items we are using in VB .NET. Attributes are enclosed in angle brackets(< >) and are used when VB .NET needs to know more beyond the standard syntax.
File Extensions in VB .NET
The files and their extensions which are created as part of the Windows Application Project and their meaning are summarized below:
.vbproj->A Visual Basic project
Form1.vb->A form's code
AssemblyInfo.VB->Information about an assembly, includes version information
.vbproj.user->Stores project user options
.sln->Solution file which stores solution's configuration
.suo-> Stores Solution user options
Form1.resx.NET->XML based resource template
bin directory->Directory for binary executables
obj directory->Directory for debugging binaries
Language Terminology
Briefly on some terminology when working with the language:
Module: Used to hold code
Variable: A named memory location of a specific data type used to hold some value
Procedure: A callable series of statements which may or may not return a value
Sub-Procedure: A procedure with no return value
Function: A procedure with return value
Methods: A procedure built into the class
Constructor: Special method used to initialize and customize the object. It has the same name as the class
Class: An OOP class which contains data and code
Object: An instance of a class
Arrays: Programming constructs that lets us access data by numeric index
Attributes: They are the items that specify information about other items being used in VB. NET

Loops

2011-07-20T09:50:00.001-07:00

For Loop
The For loop is the most popular loop. For loops enable us to execute a series of expressions multiple numbers of times. The For loop in VB .NET needs a loop index which counts the number of loop iterations as the loop executes. The syntax for the For loop looks like this:
For index=start to end[Step step]
[statements]
[Exit For]
[statements]
Next[index]
The index variable is set to start automatically when the loop starts. Each time in the loop, index is incremented by step and when index equals end, the loop ends.
Example on For loop

Module Module1

Sub Main()
Dim d As Integer
For d = 0 To 2
System.Console.WriteLine("In the For Loop")
Next d
End Sub

End Module

The image below displays output from above code.

While loop
While loop keeps executing until the condition against which it tests remain true. The syntax of while loop looks like this:
While condition
[statements]
End While
Example on While loop

Module Module1

Sub Main()
Dim d, e As Integer
d = 0
e = 6
While e > 4
e -= 1
d += 1
End While
System.Console.WriteLine("The Loop ran " & e & "times")
End Sub

End Module

The image below displays output from above code.

Do Loop
The Do loop can be used to execute a fixed block of statements indefinite number of times. The Do loop keeps executing it's statements while or until the condition is true. Two keywords, while and until can be used with the do loop. The Do loop also supports an Exit Do statement which makes the loop to exit at any moment. The syntax of Do loop looks like this:
Do[{while | Until} condition]
[statements]
[Exit Do]
[statements]
Loop
Example on Do loop

Module Module1

Sub Main()
Dim str As String
Do Until str = "Cool"
System.Console.WriteLine("What to do?")
str = System.Console.ReadLine()
Loop
End Sub

End Module

The image below displays output from above code.

Conditional Statements

2011-07-20T09:49:00.000-07:00

If....Else statement
If conditional expression is one of the most useful control structures which allows us to execute a expression if a condition is true and execute a different expression if it is False. The syntax looks like this:
If condition Then
[statements]
Else If condition Then
[statements]
-
-
Else
[statements]
End If
Understanding the Syntax

If the condition is true, the statements following the Then keyword will be executed, else, the statements following the ElseIf will be checked and if true, will be executed, else, the statements in the else part will be executed.
Example

Imports System.Console
Module Module1

Sub Main()
Dim i As Integer
WriteLine("Enter an integer, 1 or 2 or 3")
i = Val(ReadLine())
'ReadLine() method is used to read from console

If i = 1 Then
WriteLine("One")
ElseIf i = 2 Then
WriteLine("Two")
ElseIf i = 3 Then
WriteLine("Three")
Else
WriteLine("Number not 1,2,3")
End If

End Sub

End Module

The image below displays output from above code.

Select....Case Statement
The Select Case statement executes one of several groups of statements depending on the value of an expression. If your code has the capability to handle different values of a particular variable then you can use a Select Case statement. You use Select Case to test an expression, determine which of the given cases it matches and execute the code in that matched case.
The syntax of the Select Case statement looks like this:
Select Case testexpression
    [Case expressionlist-n
        [statements-n]] . . .
    [Case Else elsestatements]
End Select
Example

Imports System.Console
Module Module1

Sub Main()
Dim keyIn As Integer
WriteLine("Enter a number between 1 and 4")
keyIn = Val(ReadLine())

Select Case keyIn
Case 1
WriteLine("You entered 1")
Case 2
WriteLine("You entered 2")
Case 3
WriteLine("You entered 3")
Case 4
WriteLine("You entered 4")
End Select

End Sub

End Module

The image below displays output from above code.

Methods

2011-07-20T09:48:00.000-07:00

A Method is a procedure built into the class. They are a series of statements that are executed when called. Methods allow us to handle code in a simple and organized fashion. There are two types of methods in VB .NET: those that return a value (Functions) and those that do not return a value (Sub Procedures). Both of them are discussed below.
Sub Procedures
Sub procedures are methods which do not return a value. Each time when the Sub procedure is called the statements within it are executed until the matching End Sub is encountered. Sub Main(), the starting point of the program itself is a sub procedure. When the application starts execution, control is transferred to Main Sub procedure automatically which is called by default.
Example of a Sub Procedure

Module Module1

Sub Main()
'sub procedure Main() is called by default
Display()
'sub procedure display() which we are creating
End Sub

Sub Display()
System.Console.WriteLine("Using Sub Procedures")
'executing sub procedure Display()
End Sub
End Module

The image below displays output from above code.

Functions
Function is a method which returns a value. Functions are used to evaluate data, make calculations or to transform data. Declaring a Function is similar to declaring a Sub procedure. Functions are declared with the Function keyword. The following code is an example on Functions:

Imports System.Console
Module Module1

Sub Main()
Write("Sum is" & " " & Add())
'calling the function
End Sub

Public Function Add() As Integer
'declaring a function add
Dim i, j As Integer
'declaring two integers and assigning values to them
i = 10
j = 20
Return (i + j)
'performing the sum of two integers and returning it's value
End Function

End Module

The image below displays output from above code.

Calling Methods
A method is not executed until it is called. A method is called by referencing it's name along with any required parameters. For example, the above code called the Add method in Sub main like this:
Write("Sum is" & " " & Add()).
Method Variables
Variables declared within methods are called method variables. They have method scope which means that once the method is executed they are destroyed and their memory is reclaimed. For example, from the above code (Functions) the Add method declared two integer variables i, j. Those two variables are accessible only within the method and not from outside the method.
Parameters
A parameter is an argument that is passed to the method by the method that calls it. Parameters are enclosed in parentheses after the method name in the method declaration. You must specify types for these parameters. The general form of a method with parameters looks like this:
Public Function Add(ByVal x1 as Integer, ByVal y1 as Integer)
------------
Implementation
------------
End Function

Statements and Scope

2011-07-20T09:46:00.001-07:00

Statements
A statement is a complete instruction. It can contain keywords, operators, variables, literals, expressions and constants. Each statement in Visual Basic should be either a declaration statement or a executable statement. A declaration statement is a statement that can create a variable, constant, data type. They are the one's we generally use to declare our variables. On the other hand, executable statements are the statements that perform an action. They execute a series of statements. They can execute a function, method, loop, etc.
Option Statement
The Option statement is used to set a number of options for the code to prevent syntax and logical errors. This statement is normally the first line of the code. The Option values in Visual Basic are as follows.
Option Compare: You can set it's value to Text or Binary. This specifies if the strings are compared using binary or text comparison operators.
Option Explicit: Default is On. You can set it to Off as well. This requires to declare all the variables before they are used.
Option Strict: Default is Off. You can set it to On as well. Used normally when working with conversions in code. If you want to assign a value of one type to another then you should set it to On and use the conversion functions else Visual Basic will consider that as an error.
Example of Option Statement
The following code demonstrates where to place the Option statement.

Option Strict Off
Imports System
Module Module 1

Sub Main ()
Console.WriteLine (“Using Option”)
End Sub

End Module

The following code throws an error because Option Strict is On and the code attempts to convert a value of type double to integer.

Option Strict On
Imports System.Console
Module Module2

Sub Main()
Dim i As Integer
Dim d As Double = 20.12
i = d
WriteLine(i)
End Sub

End Module

We always should program with Option Strict On. Doing so allows us to catch many errors at compile time that would otherwise be difficult to track at run time.
Imports Statement
The Imports statement is used to import namespaces. Using this statement prevents you to list the entire namespace when you refer to them.
Example of Imports Statement
The following code imports the namespace System.Console and uses the methods of that namespace preventing us to refer to it every time we need a method of this namespace.

Imports System.Console
Module Module1

Sub Main()
Write("Imports Statement")
WriteLine("Using Import")
End Sub

End Module

The above two methods without an imports statement would look like this: System.Console.Write("Imports Statement") and System.Console.WriteLine("Using Import")
With Statement
With statemnt is used to execute statements using a particular object. The syntax looks like this:
With object
[statements]
End With
Sample Code
The following code sets text and width for a button using the With Statement.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)_
Handles MyBase.Load
With Button1
.Text = "With Statement"
.Width = 150
End With
End Sub

Boxing
Boxing is implicit conversion of value types to reference types. Recall that all classes and types are derived from the Object class. Because they are derived from Object class they can be implicitly converted to that type. The following sample shows that:

Dim x as Integer=20
'declaring an integer x
Dim o as Object
'declaring an object
o=x
converting integer to object

Unboxing is the conversion of a boxed value back to a value type.
Scope
The scope of an element in code is all the code that can refer to it without qualifying it's name. Stated other way, an element's scope is it's accessibility in code. Scope is normally used when writing large programs as large programs divide code into different classes, modules, etc. Also, scope prevents the chance of code referring to the wrong item. The different kinds of scope available in VB .NET are as follows:
Block Scope: The element declared is available only within the code block in which it is declared.
Procedure Scope: The element declared is available only within the procedure in which it is declared.
Module Scope: The element is available to all code within the module and class in which it is declared.
Namespace Scope: The element declared is available to all code in the namespace.

Data Types, Access Specifiers

2011-07-20T09:45:00.001-07:00

Data Types in VB .NET
The Data types available in VB .NET, their size, type, description are summarized in the table below.

Data Type	Size in Bytes	Description	Type
Byte	1	8-bit unsigned integer	System.Byte
Char	2	16-bit Unicode characters	System.Char
Integer	4	32-bit signed integer	System.Int32
Double	8	64-bit floating point variable	System.Double
Long	8	64-bit signed integer	System.Int64
Short	2	16-bit signed integer	System.Int16
Single	4	32-bit floating point variable	System.Single
String	Varies	Non-Numeric Type	System.String
Date	8		System.Date
Boolean	2	Non-Numeric Type	System.Boolean
Object	4	Non-Numeric Type	System.Object
Decimal	16	128-bit floating point variable	System.Decimal

Access Specifiers
Access specifiers let's us specify how a variable, method or a class can be used. The following are the most commonly used one's:
Public: Gives variable public access which means that there is no restriction on their accessibility
Private: Gives variable private access which means that they are accessible only within their declaration content
Protected: Protected access gives a variable accessibility within their own class or a class derived from that class
Friend: Gives variable friend access which means that they are accessible within the program that contains their declaration
Protected Friend: Gives a variable both protected and friend access
Static: Makes a variable static which means that the variable will hold the value even the procedure in which they are declared ends
Shared: Declares a variable that can be shared across many instances and which is not associated with a specific instance of a class or structure
ReadOnly: Makes a variable only to be read and cannot be written
Variables
Variables are used to store data. A variable has a name to which we refer and the data type, the type of data the variable holds. VB .NET now needs variables to be declared before using them. Variables are declared with the Dim keyword. Dim stands for Dimension.
Example
Imports System.Console
Module Module1

Sub Main()
Dim a,b,c as Integer
'declaring three variables of type integer
a=10
b=20
c=a+b
Write("Sum of a and b is" & c)
End Sub

End Module

Console Applications

2011-07-20T09:44:00.001-07:00

Console Applications are command-line oriented applications that allow us to read characters from the console, write characters to the console and are executed in the DOS version. Console Applications are written in code and are supported by the System.Console namespace.
Example on a Console Application
Create a folder in C: drive with any name (say, examples) and make sure the console applications which you open are saved there. That's for your convenience. The default location where all the .NET applications are saved is C:\Documents and Settings\Administrator\My Documents\Visual Studio Projects. The new project dialogue looks like the image below.

The following code is example of a console application:

Module Module1

Sub Main()
System.Console.Write("Welcome to Console Applications")
End Sub

End Module

You run the code by selecting Debug->Start from the main menu or by pressing F5 on the keyboard. The result "Welcome to Console Applications" displayed on a DOS window. Alternatively, you can run the program using the VB compiler (vbc). To do that, go to the Visual Studio. NET command prompt selecting from
Start->Programs->Visual Studio.NET->Visual Studio.NET Tools->Visual Studio.NET Command Prompt and type:
c:\examples>vbc example1.vb.
The result, "Welcome to Console Applications" is displayed on a DOS window as shown in the image below.

Breaking the Code to understand it
Note the first line, we're creating a Visual Basic Module and Modules are designed to hold code. All the code which we write should be within the Module.
Next line starts with Sub Main(), the entry point of the program.
The third line indicates that we are using the Write method of the System.Console class to write to the console.
Commenting the Code
Comments in VB.NET begin with a single quote (') character and the statements following that are ignored by the compiler. Comments are generally used to specify what is going on in the program and also gives an idea about the flow of the program. The general form looks like this:
Dim I as Integer
'declaring an integer

Code

VB Language

2011-07-20T09:43:00.000-07:00

Visual Basic, the name makes me feel that it is something special. In the History of Computing world no other product sold more copies than Visual Basic did. Such is the importance of that language which clearly states how widely it is used for developing applications. Visual Basic is very popular for it's friendly working (graphical) environment. Visual Basic. NET is an extension of Visual Basic programming language with many new features in it. The changes from VB to VB .NET are huge, ranging from the change in syntax of the language to the types of projects we can create now and the way we design applications. Visual Basic .NET was designed to take advantage of the .NET Framework base classes and runtime environment. It comes with power packed features that simplify application development. Briefly on some changes:
The biggest change from VB to VB .NET is, VB .NET is Object-Oriented now. VB .NET now supports all the key OOP features like Inheritance, Polymorphism, Abstraction and Encapsulation. We can now create classes and objects, derive classes from other classes and so on. The major advantage of OOP is code reusability
The Command Button now is Button and the TextBox is TextBox instead of Text as in VB6
Many new controls have been added to the toolbar to make application development more efficient
VB .NET now adds Console Applications to it apart from Windows and Web Applications. Console applications are console oriented applications that run in the DOS version
All the built-in VB functionality now is encapsulated in a Namespace (collection of different classes) called System
New keywords are added and old one's are either removed or renamed
VB .NET is strongly typed which means that we need to declare all the variables by default before using them
VB .NET now supports structured exception handling using Try...Catch...Finally syntax
The syntax for procedures is changed. Get and Let are replaced by Get and Set
Event handling procedures are now passed only two parameters
The way we handle data with databases is changed as well. VB .NET now uses ADO .NET, a new data handling model to communicate with databases on local machines or on a network and also it makes handling of data on the Internet easy. All the data in ADO .NET is represented in XML format and is exchanged in the same format. Representing data in XML format allows us for sending large amounts of data on the Internet and it also reduces network traffic when communicating with the database
VB .NET now supports Multithreading. A threaded application allows to do number of different things at once, running different execution threads allowing to use system resources
Web Development is now an integral part of VB .NET making Web Forms and Web Services two major types of applications
Namespaces
A namespace is a collection of different classes. All VB applications are developed using classes from the .NET System namespace. The namespace with all the built-in VB functionality is the System namespace. All other namespaces are based on this System namespace.
Some Namespaces and their use:
System: Includes essential classes and base classes for commonly used data types, events, exceptions and so on
System.Collections: Includes classes and interfaces that define various collection of objects such as list, queues,
hash tables, arrays, etc
System.Data: Includes classes which lets us handle data from data sources
System.Data.OleDb: Includes classes that support the OLEDB .NET provider
System.Data.SqlClient: Includes classes that support the SQL Server .NET provider
System.Diagnostics: Includes classes that allow to debug our application and to step through our code
System.Drawing: Provides access to drawing methods
System.Globalization: Includes classes that specify culture-related information
System.IO: Includes classes for data access with Files
System.Net: Provides interface to protocols used on the internet
System.Reflection: Includes classes and interfaces that return information about types, methods and fields
System.Security: Includes classes to support the structure of common language runtime security system
System.Threading: Includes classes and interfaces to support multithreaded applications
System.Web: Includes classes and interfaces that support browser-server communication
System.Web.Services: Includes classes that let us build and use Web Services
System.Windows.Forms: Includes classes for creating Windows based forms
System.XML: Includes classes for XML support
Assemblies
An assembly is the building block of a .NET application. It is a self describing collection of code, resources, and metadata (data about data, example, name, size, version of a file is metadata about that file). An Assembly is a complied and versioned collection of code and metadata that forms an atomic functional unit. Assemblies take the form of a dynamic link library (.dll) file or executable program file (.exe) but they differ as they contain the information found in a type library and the information about everything else needed to use an application or component. All .NET programs are constructed from these Assemblies. Assemblies are made of two parts: manifest, contains information about what is contained within the assembly and modules, internal files of IL code which are ready to run. When programming, we don't directly deal with assemblies as the CLR and the .NET framework takes care of that behind the scenes. The assembly file is visible in the Solution Explorer window of the project.
An assembly includes:

Information for each public class or type used in the assembly – information includes class or type names, the classes from which an individual class is derived, etc
Information on all public methods in each class, like, the method name and return values (if any)
Information on every public parameter for each method like the parameter's name and type
Information on public enumerations including names and values
Information on the assembly version (each assembly has a specific version number)
Intermediate language code to execute
A list of types exposed by the assembly and list of other assemblies required by the assembly

Image of a Assembly file is displayed below.

Structures

2011-07-15T09:12:00.001-07:00

Structures can be defined as a tool for handling a group of logically related data items. They are user-defined and provide a method for packing together data of different types. Structures are very similar to Classes. Like Classes, they too can contain members such as fields and methods. The main difference between classes and structures is, classes are reference types and structures are value types. In practical terms, structures are used for smaller lightweight objects that do not persist for long and classes are used for larger objects that are expected to exist in memory for long periods. We declare a structure in Visual Basic .NET with the Structure keyword.
Value Types and Reference Types
Value Types and Reference Types belong to Application data memory and the difference between them is the way variable data is accessed. We will have a brief overview about them.
Value Types
In VB .NET we use the Dim statement to create a variable that represents a value type. For example, we declare a integer variable with the following statement: Dim x as Integer. The statement tells the run time to allocate the appropriate amount of memory to hold an integer variable. The statement creates a variable but does not assign a value to it. We assign a value to that variable like this: x=55. When a variable of value type goes out of scope, it is destroyed and it's memory is reclaimed.
Reference Types
Creating a variable of reference type is a two-step process, declare and instantiate. The first step is to declare a variable as that type. For example, the following statement Dim Form1 as new System.Windows.Forms.Form tells the run time to set enough memory to hold a Form variable. The second step, instantiation, creates the object. It looks like this in code: Form1=New System.Windows.Forms.Form. A variable of reference type exists in two memory locations and that's why when that variable goes out of scope, the reference to that object is destroyed but the object itself is not destroyed. If any other references to that object exist, the object remains intact. If no references exist to that object then it is subject to garbage collection.
Code for Creating a Structure
The following code creates a Structure named Employee with five fields of different data types.

Module Module1

Structure Employee
'declaring a structure named Employee
Dim EmpName As String
Dim EmpDesignation As String
Dim EmpCity As String
Dim EmpSal As Double
Dim EmpId As Integer
'declaring five fields of different data types in the structure
End Structure

Sub Main()
Dim san As New Employee()
'creating an instance of Employee
san.EmpName = "Sandeep"
san.EmpDesignation = "Software Developer"
san.EmpCity = "Sydney"
san.EmpSal = 60000
san.EmpId = 2707
'assigning values to member variables
WriteLine("EmpName" + " " + san.EmpName)
WriteLine("EmpDesignation" + " " + san.EmpDesignation)
WriteLine("EmpCity" + " " + san.EmpCity)
WriteLine("EmpSalary" + " " + san.EmpSal.ToString)
WriteLine("EmpID" + " " + san.EmpId.ToString)
'accessing member variables with the period/dot operator
Read()
End Sub

End Module

The output of above code is the image below.

Abstract Classes

2011-07-15T09:11:00.001-07:00

An abstract class is the one that is not used to create objects. An abstract class is designed to act as a base class (to be inherited by other classes). Abstract class is a design concept in program development and provides a base upon which other classes are built. Abstract classes are similar to interfaces. After declaring an abstract class, it cannot be instantiated on it's own, it must be inherited. Like interfaces, abstract classes can specify members that must be implemented in inheriting classes. Unlike interfaces, a class can inherit only one abstract class. Abstract classes can only specify members that should be implemented by all inheriting classes.
Creating Abstract Classes
In Visual Basic .NET we create an abstract class by using the MustInherit keyword. An abstract class like all other classes can implement any number of members. Members of an abstract class can either be Overridable (all the inheriting classes can create their own implementation of the members) or they can have a fixed implementation that will be common to all inheriting members. Abstract classes can also specify abstract members. Like abstract classes, abstract members also provide no details regarding their implementation. Only the member type, access level, required parameters and return type are specified. To declare an abstract member we use the MustOverride keyword. Abstract members should be declared in abstract classes.
Implementing Abstract Class
When a class inherits from an abstract class, it must implement every abstract member defined by the abstract class. Implementation is possible by overriding the member specified in the abstract class. The following code demonstrates the declaration and implementation of an abstract class.

Module Module1

Public MustInherit Class AbstractClass
'declaring an abstract class with MustInherit keyword
Public MustOverride Function Add() As Integer
Public MustOverride Function Mul() As Integer
'declaring two abstract members with MustOverride keyword
End Class

Public Class AbstractOne
Inherits AbstractClass
'implementing the abstract class by inheriting
Dim i As Integer = 20
Dim j As Integer = 30
'declaring two integers

Public Overrides Function Add() As Integer
Return i + j
End Function
'implementing the add method

Public Overrides Function Mul() As Integer
Return i * j
End Function
'implementing the mul method

End Class

Sub Main()
Dim abs As New AbstractOne()
'creating an instance of AbstractOne
WriteLine("Sum is" & " " & abs.Add())
WriteLine("Multiplication is" & " " & abs.Mul())
'displaying output
Read()
End Sub

End Module

The output of above code is the image below.

Interfaces

2011-07-15T09:10:00.001-07:00

Interface keyword to create an interface and implements keyword to implement the interface. Once you create an interface you need to implement all the methods specified in that interface. The following code demonstrates the use of interface.

Imports System.Console
Module Module1

Sub Main()
Dim OneObj As New One()
Dim TwoObj As New Two()
'creating objects of class One and Two
OneObj.disp()
OneObj.multiply()
TwoObj.disp()
TwoObj.multiply()
'accessing the methods from classes as specified in the interface
End Sub

End Module

Public Interface Test
'creating an Interface named Test
Sub disp()
Function Multiply() As Double
'specifying two methods in an interface
End Interface

Public Class One
Implements Test
'implementing interface in class One

Public i As Double = 12
Public j As Double = 12.17

Sub disp() Implements Test.disp
'implementing the method specified in interface
WriteLine("sum of i+j is" & i + j)
Read()
End Sub

Public Function multiply() As Double Implements Test.Multiply
'implementing the method specified in interface
WriteLine(i * j)
Read()
End Function

End Class

Public Class Two
Implements Test
'implementing the interface in class Two

Public a As Double = 20
Public b As Double = 32.17

Sub disp() Implements Test.disp
WriteLine("Welcome to Interfaces")
Read()
End Sub

Public Function multiply() As Double Implements Test.Multiply
WriteLine(a * b)
Read()
End Function

End Class

Output of above code is the image below.

Polymorphism

2011-07-15T09:09:00.001-07:00

Polymorphism is one of the crucial features of OOP. It means "one name, multiple forms". It is also called as Overloading which means the use of same thing for different purposes. Using Polymorphism we can create as many functions we want with one function name but with different argument list. The function performs different operations based on the argument list in the function call. The exact function to be invoked will be determined by checking the type and number of arguments in the function.
The following code demonstrates the implementation of Polymorphism.

Module Module1

Sub Main()
Dim two As New One()
WriteLine(two.add(10))
'calls the function with one argument
WriteLine(two.add(10, 20))
'calls the function with two arguments
WriteLine(two.add(10, 20, 30))
'calls the function with three arguments
Read()
End Sub

End Module

Public Class One
Public i, j, k As Integer

Public Function add(ByVal i As Integer) As Integer
'function with one argument
Return i
End Function

Public Function add(ByVal i As Integer, ByVal j As Integer) As Integer
'function with two arguments
Return i + j
End Function

Public Function add(ByVal i As Integer, ByVal j As Integer, ByVal k As Integer) As Integer
'function with three arguments
Return i + j + k
End Function

End Class

Output of the above code is shown in the image below.

<="" p="p">

Inheritance

2011-07-15T09:08:00.001-07:00

A key feature of OOP is reusability. It's always time saving and useful if we can reuse something that already exists rather than trying to create the same thing again and again. Reusing the class that is tested, debugged and used many times can save us time and effort of developing and testing it again. Once a class has been written and tested, it can be used by other programs to suit the program's requirement. This is done by creating a new class from an existing class. The process of deriving a new class from an existing class is called Inheritance. The old class is called the base class and the new class is called derived class. The derived class inherits some or everything of the base class. In Visual Basic we use the Inherits keyword to inherit one class from other. The general form of deriving a new class from an existing class looks as follows:

Public Class One
---
---
End Class

Public Class Two
Inherits One
---
---
End Class

Using Inheritance we can use the variables, methods, properties, etc, from the base class and add more functionality to it in the derived class. The following code demonstrates the process of Inheritance in Visual Basic.

Imports System.Console
Module Module1

Sub Main()
Dim ss As New Two()
WriteLine(ss.sum())
Read()
End Sub

End Module

Public Class One
'base class
Public i As Integer = 10
Public j As Integer = 20

Public Function add() As Integer
Return i + j
End Function

End Class

Public Class Two
Inherits One
'derived class. class two inherited from class one
Public k As Integer = 100

Public Function sum() As Integer
'using the variables, function from base class and adding more functionality
Return i + j + k
End Function

End Class

Output of above code is sum of i, j, k as shown in the image below.