[Ultimate Guide] Visual Basic .NET

Welcome to my guide on mastering Visual Basic .NET
I used Visual Studio Ultimate 2010 while creating this, and you can download a trial for free at [Only registered and activated users can see links. Click Here To Register...] or find a cracked version on the web. I created this guide specifically for silkroad online gamers and coders. I am guiding the exact way I learned. I am very limited on time, so I will post lessons when I can. I have a total of 14 lesons, and I will always keep the post up to date on my latest lesson I posted.
Current Lesson #: 2

Lesson #1

Spoiler

Writing Your First "Hello World" Console Application in VB.Net
As follows, we will build our first VB.Net application without and then with Visual Studio.Net. Instructions below show, how to write, compile, and execute a VB.Net application.
Without Visual Studio.Net
Open "Notepad" or a text editor of your choice and type the following code:

Code:

Imports System
Module Module1
    Sub Main()
        Console.WriteLine("Hello World!")
    End Sub
End Module

Save this with any file name with the extension ".vb" (for example, 'MyFirstApplication.vb'). To compile the program, go to Visual Studio command prompt and type:

Code:

vbc MyFirstApplication.vb

Note: You may have to change the directory to where you saved your file.
This will compile your program and create an .exe file (MyFirstApplication.exe) in the same directory. Errors will be reported if there are any. To run your program, type:

Code:

MyFirstApplication

(or whatever you named it)
This action will print "Hello World!" on the console screen.
With Visual Studio.Net
Start Microsoft Visual Studio.Net and from the menu select File > New > Project. A "New Project" dialog will now be displayed. Select "Visual Basic Project" from "Project Type" and select "Console Application" from "Templates". Type "MyHelloWorldApplication" (without "") in the "Name" text box below, then click OK.
Change the name of module from Module1 to "MyHelloWorldApplication" and type

Code:

Module MyHelloWorldApplication
    Sub Main()
        Console.WriteLine("Hello World")
    End Sub
End Module

To compile and execute your application, select "Start" from the "Debug" menu or to run the application without Debug press Ctrl+F5. A new console window containing the words Hello World will now be displayed. Press any key to terminate the program and close the console window.

Let's build on this code and include some more VB.NET syntax. Modify your code as below:

Code:

Imports System
Namespace MyHelloWorldApplication
    Module MyHelloWorldModule
        Sub Main()
            Console.WriteLine("Hello World")
        End Sub
    End Module
End Namespace

Understanding the Hello World Application Code:
The first line of our program (Imports System) usually appears in all VB.Net programs. It gives us access to the core functionality of programming. This shall be covered later. Before then, the second line (Namespace MyHelloWorldApplication) shall be discussed.

Namespaces in VB.Net
A namespace is simply a logical collection of related classes in VB.Net. We bundle our related classes (like those related with database activity for example) in a named collection, hence calling it a namespace (e.g., DataActivity).

VB.Net does not allow two classes with the same name to be used in a program. The sole purpose of using namespaces is to prevent the name conflict, which may happen if your working with a large number of classes. It is the same case in the Framework Class Library (FCL). It is highly possible that the Connection Class in DataActivity conflicts with the Connection Class of InternetActivity. To avoid this, these classes are made part of their respective namespace. The fully qualified name of these classes will be DataActivity.Connection and InternetActivity.Connection, hence resolving any ambiguity for the compiler.
In the second line of the code there is a declaration classes (enclosed in Namespace...EndNamespace block) which are part of the MyHelloWorldApplication namespace.

Code:

Namespace MyHelloWorldApplication
...
End Namespace

The VB.Net namespaces have NO physical mapping, as is the case in Java. Classes within the same namespace can be in different folders. The C# concept of mapping is similar to "packages" in Java and "namespace" in standard C++. The namespace may contain modules, classes, interfaces, events, exceptions, delegates and even other namespaces which are known as "Internal namespace". These internal namespaces can be defined like this:

Code:

Namespace Parent
		Namespace Child
		...
	End Namespace
End Namespace

The Imports Keyword
The first line of our program is

Code:

Imports System

The "Imports" keyword in the code sample above enables us to use classes in the "System" namespace. For example, Its possible to access the Console class from the Main() sub. One point to remember here is that "Imports" allows access to classes in the referenced namespace only and not in its internal/child namespaces. Hence we might need to write:

Code:

Imports System.Collections

In order to access the classes defined in Collection namespace which is a sub/internal namespace of the System namespace.
The Module Keyword
A VB.Net program may contain one or more modules. The Main() sub-procedure usually resides in one of these modules. Modules in VB.Net are a combination of general data (fields) and general functions (methods) that are accessible to any code that can access the namespace of a module. All the members (fields, methods, properties) defined inside a module are shared by default.

The concept of a Module will be discussed in more detail in future lessons. Modules in VB.Net are defined using the Module statement, followed by the name of the module. The end of a module is marked with the End Module statement.

Code:

  Module MyHelloWorldModule
	...
    End Module

This is the standard layout of a Main sub-procedure within a VB.Net module. The Main() sub-procedure is the entry point of a program, i.e. a VB.Net program starts its execution from the first line in the Main sub-procedure and ceases to exist with the termination of the Main sub-procedure. We can also define the Main method inside a class, e.g.

Code:

Imports System

Code:

Namespace MyHelloWorldApplication
    Class MyHelloWorldClass
        Public Shared Sub Main()
            Console.WriteLine("Hello World")
        End Sub
    End Class
End Namespace

The main sub-procedure is designated as "Shared" as it can be called by the Common Language Runtime (CLR) without creating any objects from our MyHelloWorldClass (this is the definition of Shared methods, fields and properties). The sub-procedure is also declared as "Public" so that classes outside its namespace and assembly may call this method. Main is the (standard) name of this method. More evidence of this shall be shown later.

One interesting point is that it is legitimate to have multiple Main() methods in VB.Net program. However, you have to explicitly identify which Main method is the entry point for the program.
Printing on the Console
The next line of code prints "Hello World" on the Console screen:

Code:

Console.WriteLine("Hello World")

In the code,WriteLine() is called. It is a "Shared" method of the Console class that is defined in the System namespace. This method takes a string (enclosed in double quotes) as its parameter and prints it on the Console window.

VB.Net, like other Object Oriented languages, uses the dot (.) operator to access the member variables (fields) and methods of a class. Also, parenthatsis () are used to identify methods in the code. String literals are enclosed in double quotation marks ("). Lastly, it must be remembered that VB.Net is a case-insensitive language; hence Console and conSole are the same words (identifiers) in VB.Net.

Comments
Comments are created by programmers who wish to explain the code. Comments are ignored by the compiler and are not included in the executable code. VB.Net uses similar syntax for comments as used in VB and assembly language. The text following a single quotation mark (' any comment) is a line comment. the ending is the end of the line.

Code:

  ' This is my main method
        Public Shared Sub Main()
            Console.WriteLine("Hello World") ' It will print Hello World
        End Sub

Important points to remember

Your VB.Net executable program resides in a class or module.
The entry point to a program is the Shared sub-procedure Main()
VB.Net is not a case sensitive language so integer and Integer mean the same thing
Horizontal whitespaces (tabs and spaces) are ignored by the compiler between the code. Hence, the following is also a valid declaration of the Main() method (although not recommended):

Code:

        Public   Shared 		Sub 	Main()
            Console.WriteLine    (   "Hello World"     )
[/ul]        End Sub

You DON'T need to save your program with the same file name as that of the class or module containing the Main() method
There can be multiple Main() methods in your program, but you have to specify which one is the entry point
The boundaries of a namespace, class, module and method are defined by their respective statements and closed with an End statement
A namespace is only a logical collection of classes with no physical mapping on disk (unlike Java)
The "Imports" keyword is used to inform the compiler where to look for the definition of the classes (namespaces) that you want to use
Comments are ignored by the VB.Net compiler and are used only to enhance the readability and understandability of the program for developers only.
Enclosing your classes or modules in a namespace is optional. Its possible to write a program where any classes or modules are not enclosed in a namespace
It is not mandatory that the Main method of a program does not take any argument. It may take arguments, such as:

Code:

        Public Sub Main(ByVal CmdArgs() As String)
            Console.WriteLine("Hello World")
[/ul]       End Sub

A more interactive Hello World Application
Up to this point we have seen a very static Hello World application that greets the whole world when it is executed. Lets now make a more interactive hello world that greets its current user. This program will ask the user's name and will greet them using their name, like 'Hello Faraz', when the user named 'Faraz' runs it. Let's see the code first:

Code:

Module MyHelloWorldModule
    Sub Main()
        Console.Write("Plz, write your good name: ")	' line 1
        Dim name As String = Console.ReadLine()		' line 2
        Console.WriteLine("Hello {0}, Good Luck in VB.Net", name)   ' line 3
    End Sub
End Module

Discussing a more interactive Hello World Application
In the first line of Main, there is another method, Write(). Which is part of the Console class. This is similar to the WriteLine() method discussed in the previous program, but the cursor does not move to a new line after printing the string on the console.

In the second line, there is a declared String variable named "name". Then, a line of input is taken from the user through the ReadLine() method of the Console class. The result is stored in the "name" variable. The variables are placeholders (in memory) for storing data temporarily during the execution of the program. Variables can hold different types of data depending on their data-type, e.g., Integer variables can store integers (numbers with no decimal places), while String variables can store strings ( a series) of characters. The ReadLine() method of the Console class (contrary to WriteLine()) reads a line of input typed at the Console Window. It returns this input as a string, in which the "name" variable is stored.

Author's Note: String is implicit data-type in VB.Net contrary to other languages

The third line prints the name given by the user at second line along with a greeting text. Once again, the WriteLine() method of the Console Class is used. The substitution parameter {0} is used to specify the position in the line of text where the data from the variable "name" should be written after the WriteLine() method is called.

Code:

Console.WriteLine("Hello {0}, Good Luck in VB.Net", name);

When the compiler finds a substitution parameter {n} it replaces it with the (n+1) variable following the string in double quotation marks separated by comma. Hence, when the compiler finds {0}, it replaces it with (0+1), i.e., 1st variable "name" following the double quotes separated by comma. At run-time, the CLR will read it as:

Code:

Console.WriteLine("Hello Faraz, Good Luck in VB.Net");

If the value of the variable "name" = "Faraz" at run-time.

Alternatively, it can also be written as:

Code:

Console.WriteLine("Hello " + name + ", Good Luck in VB.Net");

Removing the substitution parameter altogether. Here we concatenate (add) the strings together to form a message. (The first approach is similar to C's printf() function while the second is similar to Java's System.out.println() method)

When we compile and run this program the output will be as follows:

"Plz, write your good name: Faraz Hello Faraz, Good Luck in VB.Net"

Lesson #2

Spoiler

Basic Data Types and their mapping to the CTS (Common Type System)
There are two kinds of data types in VB.Net
1. Value type (implicit data types, Structure and Enumeration)
2. Reference Type (objects, delegates)
Value types are passed to methods by passing an exact copy while Reference types are passed to methods by passing only their reference (handle). Implicit data types are defined in the language core by the language vendor, while explicit data types are types that are made by using or composing implicit data types.

As we saw in the first lesson, implicit data types in .net compliant languages are mapped to types in Common Type System (CTS) and CLS (Common Language Specification). Hence, each implicit data type in VB.Net has its corresponding .Net type. The implicit data types in VB.Net are:

VB.Net type	Corresponding .Net type	Size in bytes	Description
Boolean	Boolean	1	Contains either True or False
Char	Char	2	Contains any single Unicode character enclosed in double quotation marks followed by a c, for example "x"c
Integral types
Byte	Byte	1	May contain integers from 0-255
Short	Int16	2	Ranges from -32,768 to 32,767
Integer(default)	Int32	4	Ranges from -2,147,483,648 to 2,147,483,647
Long	Int64	8	Ranges from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
Floating point types
Single	Single	4	Ranges from �1.5 � 10-45 to �3.4 � 1038 with 7 digits precision. Requires the suffix 'f' or 'F'
Double(default)	Double	8	Ranges from �5.0 � 10-324 to �1.7 � 10308 with 15-16 digits precision.
Decimal	Decimal	12	Ranges from 1.0 � 10-28 to 7.9 � 1028 with 28-29 digits precision. Requires the suffix 'm' or 'M'

Implicit data types are represented in language using 'keywords'; so each of above is a keyword in VB.Net (Keyword are the words defined by the language and can not be used as identifiers). It is worth-noting that string is also an implicit data type in VB.Net, so String is a keyword in VB.Net. Last point about implicit data types is that they are value types and thus stored at the stack, while user defined types or referenced types are stored at heap. Stack is a data structure that store items in last in first out (LIFO) fashion. It is an area of memory supported by the processor and its size is determined at the compile time. Heap is the total memory available at run time. Reference types are allocated at heap dynamically (during the execution of program). Garbage collector searches for non-referenced data in heap during the execution of program and returns that space to Operating System.
Variables
During the execution of program, data is temporarily stored in memory. A variable is the name given to a memory location holding particular type of data. So, each variable has associated with it a data type and value. In VB.Net, a variables is declared as:

Code:

  Dim <variable> as <data type>

Example:

Code:

 Dim i As Integer

The above line will reserve an area of 4 bytes in memory to store integer type values, which will be referred in the rest of program by identifier 'i'. You can initialize the variable as you declare it (on the fly) and can also declare/initialize multiple variables of same type in a single statement, e.g.,

Code:

    Dim isReady As Boolean = True
    Dim percentage = 87.88, average = 43.9 As Single
    Dim digit As Char = "7"c

VB.Net Option Strict and Option Explicit Settings
There are two 'bad' features in VB.Net, which are inherent from earlier versions (VB5 and VB6):

* You can declare a variable without specifying its type. VB.Net, in this case, assumes the type of the variable as System.Object class
* You can convert values (or objects) to incompatible types, e.g., String to Integer.

Why I called the two options bad? The use of these two features results in quite a number of bugs and makes the overall design of application bad, complex and difficult to follow. With incompatible type conversion, the program does compile without any error but throw a runtime error (exception). But these two features can be turned off by using the Option Explicit and Option Strict statements.

Option Explicit Statement
Option Explicit, when turned on, do not allow to use any variable without proper declaration.

There are two methods to apply the Option Explicit Statement.

* To apply the Option Explicit settings to the complete project in Visual Studio.Net, right click the project name in the solution explorer and select Properties. It will open the Property Pages window. Now in the Common Properties tree at left, select Build, it will show the following window
From here, you can turn the Option Explicit (as well as Option Strict) on or off.
To apply the Option Explicit settings to the current file, use the Option Explicit statement before any statement as,

Code:

Option Explicit On

When Option Explicit is on, it will cause the compile time error to write

Code:

myName = "Faraz"    ' compile time error with Option Explicit On

Rather, you would have to write,

Code:

Dim myName As String = "Faraz"

Option Strict Statement
When the Option Strict statement is turned on, incompatible type conversion are not allowed. Option Strict can be turned on or off in the similar fashion as Option Explicit. You can either use Option Strict Statement as

Code:

Option Strict On

Or you can set it from the project properties. When Option Strict is On, the following program will cause a compile time error

Code:

Sub Main()
Dim strNum As String = "1"
Dim intNum As Integer = strNum
Console.WriteLine(intNum)
End Sub

But if the Option Strict is turned off, the above program will actually compile and run without error to print 1 on the Console!

It is important to remember that Option Strict also does not allow using un-declared types and hence there is no use turning the Option Explicit on if you are already using Option Strict.

Finally, we do not discourage our readers to turn Option Explicit and Option Strict off; It's strongly advised not to do so! Throughout the VB.Net School, we will implicitly assume that the Option Strict is turned On

Constant or Symbols
Constants values once defined cannot be changed in the program. Constants are declared using Const keyword, like:

Code:

Dim Const PI As Double = 3.142

Constants must be initialized as they are declared.

Code:

Dim Const MARKS As Integer

It is a notation convention to use capital letters while naming constants.

Naming Conventions for variables and methods
Microsoft suggests using Camel Notation (first letter in lowercase) for variables and Pascal Notation (first letter in uppercase) for methods. Each word after the first word in the name of both variable and method should start with capital letter. For example, variable names following Camel notation could be

Code:

salary			totalSalary		
myMathsMarks		isPaid

Some typical names of method following Pascal Notation are

Code:

GetTotal()			Start()
WriteLine()			LastIndexOf()

Although it is not mandatory to follow this convention, it is highly recommended to follow it. Microsoft no longer uses Hungarian notation. An example wooul be "iMarks" for an integer variable. Also, using underscores _ in names is also not encouraged.

Breaking lines in VB.Net
The VB.Net compiler identifies the end of statement by the end of line. Hence, it is not possible to write a single statement on multiple lines (as done in C/C++, Java, C#). The following code will raise a syntax error:

Code:

Dim myName As String = "My name is 
Faraz Rasheed"

The compiler treats the two lines as two instructions and will cause syntax errors upon finding these two lines. To expand a single statement on to multiple lines, you must use the underscore _ character at line breaks. For example, the above code is perfectly valid when modified as below

Code:

Dim myName As String = 	"My name is " & _
					"Faraz Rasheed and, " & _
					"I like .Net as ..."
Console.WriteLine(myName)

The above code fragment will result in following output at Console

My name is Faraz Rasheed and, I like .Net as...

Operators in VB.Net

Arithmetic Operators
Several common arithmetic operators are allowed in VB.Net like

+ (add)
- (subtract)
* (multiply)
/ (divide)
Mod (remainder or modulo)

The program below uses these operators

Code:

Imports System
Module ArithmeticOperators
    ' The program shows the use of arithmetic operators 
    ' + - * / Mod 
    Sub Main()
        ' result of addition, subtraction, multiplication and modulus operator
        Dim sum, difference, product, modulo As Integer
        sum = 0
        difference = 0
        product = 0
        modulo = 0
        Dim quotient As Double = 0  ' result of division
        Dim num1 As Integer = 10    ' operand variables
        Dim num2 As Integer = 2
        sum = num1 + num2
        difference = num1 - num2
        product = num1 * num2
        quotient = num1 / num2
        modulo = 3 Mod num2         ' remainder of 3/2
        Console.WriteLine("num1 = {0}, num2 = {1}", num1, num2)
        Console.WriteLine()
        Console.WriteLine("Sum        of {0} and {1} is {2}", num1, num2, sum)
        Console.WriteLine("Difference of {0} and {1} is {2}", num1, num2, difference)
        Console.WriteLine("Product    of {0} and {1} is {2}", num1, num2, product)
        Console.WriteLine("Quotient   of {0} and {1} is {2}", num1, num2, quotient)
        Console.WriteLine()
        Console.WriteLine("Remainder when 3 is divided by {0} is {1}", num2, modulo)
    End Sub
End Module

Although the program above is quite simple, Lets discuss some concepts. In the Console.WriteLine() method, we have used format-specifiers {int} to indicate the position of variables in the string.

Code:

Console.WriteLine("Sum of {0} and {1} is {2}", num1, num2, sum)

Here, {0}, {1} and {2} will be replaced by the values of num1, num2 and sum variables. In {i}, i specifies that the (i+1)th variable after the double quotes will replace it when printed on the Console. Hence, {0} will be replaced by first, {1} will be replaced by second variable and so on.

Assignment Operators
Assignment operators are used to assign values to variables. Common assignment operators in VB.Net are:

= (simple assignment)
+= (additive assignment) -= (subtractive assignment)

* = (multiplicative assignment) /= (division assignment)[/pre]

The Equal operator is used to assign a value to a variable or a reference. For example, the instruction

Code:

Dim isPaid As Boolean = false

assigns the value 'False' to the isPaid variable of Boolean type. The Left and right hand side of the equal or any other assignment operator must be compatible otherwise the compiler will complain of a syntax error.
Sometimes casting is used for type conversion, e.g., to convert and store values in a variable of type Double to a variable of type Integer. We need to apply integer cast using VB.Net's CType() built-in method

Code:

Dim doubleValue As Double = 4.67
Dim intValue As Integer	 = CType(doubleValue, Integer)	' intValue would be equal to 4

The method CType() is used for compatible type conversions. It takes two arguments; the first being the source variable to convert to, while the second argument is the target type of conversion. Hence, the above call to the method CType() will convert the value in the variable 'doubleValue' of type Double to a variable of type Integer and will return the converted Integer type value that will be stored in the Integer variable 'intValue'
Of course, with narrow casting (from bigger type to smaller type) there is always a danger of some loss of precision; as in the case above, we only got 4 of the original 4.67.

Code:

Dim intValue As Integer	= 32800
Dim shortValue As Short	= CType(intValue, Short)

When the second of these lines is run an error will be given, stating that "Arithmetic operation resulted in an overflow." Why is it so? Variables of type Short can only take a maximum value of 32767. The cast above can not assign 32800 to a shortValue. This is detected at runtime and an error is given.
If you try to do an invalid cast of incompatible types like below

Code:

Dim strValue As String = "Faraz"
Dim intValue As Integer = CType(strValue, Integer)

Then again it will get compiled but will crash the program at runtime.

Relational Operators
Relational operators are used for comparison purposes in conditional statements. The common relational operators in VB.Net are:

= (equality check) <> (un-equality check)
> (greater than) < (less than)
>= (greater than or equal to) <= (less than or equal to)

Relational operators always result in a Boolean statement; either True or False. For example if we have two variables

Code:

	Dim num1 = 5, num2 = 6 As Integer

then,

num1 = num2 will result in false
num1 <> num2 will result in true
num1 > num2 will result in false
num1 < num2 will result in true
num1 <= num2 will result in true
num1 >= num2 will result in false

Only compatible data types can be compared. It is invalid to compare a Boolean with an Integer, if

Code:

Dim i = 1 As Integer
	Dim b = True As Boolean

then it is a syntax error to compare i and b for equality (i=b)

Logical and Bitwise Operators
These operators are used for logical and bitwise calculations. The common logical and bitwise operators in VB.NET are:

And (bitwise AND) Or (bitwise OR)
Xor (bitwise XOR) Not (bitwise NOT)
AndAlso (Logical or short circuit AND) OrElse (Logical or short circuit OR)

The operators And, Or and Xor are rarely used in usual programming practice. The Not operator is used to negate a Boolean or bitwise expression like:

Code:

Dim b = False As Boolean
Dim bb As Boolean = Not b	' bb would be true

Logical Operators And, Or, AndAlso and OrElse are also used to combine comparisons like

Code:

Dim i=6, j=12 As Integer
Dim firstVar  As Boolean = i>3 And j < 10 ' firstVar would be false
Dim secondVar As Boolean = i>3 Or j < 10 ' secondVar would be true

In the first comparison case: i>3 And j<10 will result in true only if both the conditions i>3 and j<10 result in true. While in the second comparison: i>3 Or j<10 will result in true if any of the conditions i>3 and j<10 result in true. You can of course use the combination of And, Or, AndAlso and OrElse in a single statement like:

Code:

bool firstVar	= (i>3 And j<10) OrElse (i<7 And j>10)	
                  'firstVar would be true

In the above statement we used brackets to group our conditional expressions to avoid any ambiguity.

You can also use And and Or operators in place of AndAlso and OrElse respectively; but for combining conditional expressions, AndAlso and OrElse are more efficient as they use "short circuit evaluation", i.e., if in (i>3 AndAlso j<10) expression, i>3 evaluates to false, it would not check the second expression j<10 and will return false (as in AND, if one of the participant operand is false, the whole operation will result in false). Hence, one should be very careful to use assignment expressions with AndAlso and OrElse operators. The And and Or operators don't do short circuit evaluation and do execute all the comparisons before returning the result.

Other Operators
There are other operators present in VB.Net. A short description of these is given below:

(member access for objects) () (indexing operator used in arrays and collections)

Operator Precedence
All operators are not treated equally. There is a concept of operator precedence in VB.Net as in

Code:

Dim i As Integer = 2 + 3 * 6		' i would be 20 not 30

3 will be multiplied by 6 first then the result will be added to 2. This is because the multiplication operator * has precedence over the addition operator +. For a complete table of operator precedence, consult msdn or the .net framework documentation.

Flow Control And Conditional Statements

If�Then�Else statement
Condition checking has always been the most basic and important construct in any language. VB.Net provides conditional statements in the form of the If...Then...Else statement. The structure of this statement is:

Code:

If Boolean expression Then
	Statement or block of statement
Else
	Statement or block of statement
End If

The Else clause above is optional. The typical example is

Code:

If i=5 Then
	Console.WriteLine("Thanks God, i finally becomes 5")
End If

In the above example, the console message will be printed only if the expression i=5 evaluates to True. If action is needed in the case when the condition does not evaluate to true you can use the Else clause.

Code:

If i=5 Then
        Console.WriteLine("Thanks God, I finally becomes 5")
Else
	Console.WriteLine("Missed...When will I become 5?")
End If

Only the first message will be printed in the case of i being 5. In any other case (when i is not 5), the second message will be printed. You can also use a block of statements (more than one statement) under any If and Else.

Code:

If i=5 Then
j = i*2
Console.WriteLine("Thanks God, i finally becomes 5")
Else
j = i/2
Console.WriteLine("Missed...When will i become 5?")
End If

You may write If...Then or If...Then...Else in the single line, like

Code:

If i=5 Then Console.WriteLine("Thanks God, I finally became 5")

As you might have picked from the above two statements. When an If...Then and If...Then...Else are used on the same line, we do not need to write an End If. The reason is quite simple; End is used to mark the end of a block in VB.Net. With these two statements, we do not create or use any blocks of statements

I would always recommend to use If...Then and If...Then...Else statements in block format with End If. It increases the readability and prevents many bugs that otherwise can be produced in the code.

You can also have an If after an Else for further conditioning

Code:

If i=5 Then	'line 1
	Console.WriteLine("Thanks God, i finally becomes 5")
ElseIf i=6	'line 3
	Console.WriteLine("Ok, 6 is also closer to 5")
Else		'line 5
	Console.WriteLine("Missed...When will i become 5 or closed to 5?")
End If

ElseIf i=6 is executed only if the first condition i=5 is false. An Else at line 5 will be executed only if the second condition i=6 (line 3) executes and fails (that is both the first and second condition fails). The point being is that Else at line 5 is related to the If on line 3

As If...Then...Else is also an statement, you can use it under other If...Then...Else statements, like:

Code:

If i>5 Then	' line 1
If i=6 Then	' line 2
	Console.WriteLine("Ok, 6 is also closer to 5")
Else		' line 4
	Console.WriteLine("Oops! i is greater than 5 but not 6")
End If
	Console.WriteLine("Thanks God, i finally becomes greater than 5")
Else		' line 8
	Console.WriteLine("Missed...When will i become 5 or closed to 5?")
End If

The Else on line 4 is clearly related to the If...Then on line 2 while the Else on line 8 belongs to the If on line 1. Finally, do note (VB6 and C/C++ programmers especially) that the If statement expects only Boolean expression and not an Integer value. It is indeed an error to write

Code:

Dim flag As Integer = 0
If flag Then
	' do something...
End If

Instead, you can either use

Code:

Dim flag As Integer = 0
If flag = 1	Then		' note ==
	' do something�
End If

Code:

Dim flag As Boolean = False
If flag Then	' Boolean expression
		' do something...
End If

The key to avoid confusion when using a complex combination of If...Then...Else is the
Select�Case statement

If you need to perform a series of specific checks, Select...Case is present in VB.Net and is just the ticket for this. The general structure of Select...Case statement is as follows:

Code:

Select <any implicit data type expression>
       Case expression
	statements
	' some other case blocks
	...
	Case Else
	statements
End Select

It takes much less time to use the Select...Case than using several If...Then...ElseIf statements. Let's understand it with an example

Code:

Imports System
' To execute the program write "SwitchCaseExample 2" or 
' any other number at command line, 
' if the name of .exe file is "SwitchCaseExample.exe"
Module ArithmeticOperators
    ' Demonstrates the use of switch...case statement along with
    ' the use of command line argument
    Sub Main(ByVal userInput() As String)
    ' convert the string input to integer
    ' Will through run-time exception if there is no input
    ' at run-time or input is not castable to integer
      Dim input As Integer = Integer.Parse(userInput(0))
      Select Case input ' what is input?
           Case 1  ' if it is 1
           Console.WriteLine("You typed 1 (one) as first command line argument")
           Case 2 ' if it is 2
               Console.WriteLine("You typed 2 (two) as first command line argument")
           Case 3 To 5  ' if it is 3
               Console.WriteLine("You typed number from 3 (three) to 
                                 five (five) as first command line argument")
           Case Else  ' if it is not of the above
               Console.WriteLine("You typed other than 1, 2, 3, 4 and 5")
        End Select
    End Sub
End Module

An integer must be supplied for the command line argument. Firstly, compile the program (at command line or in Visual Studio.Net). Suppose we made an exe with name "SelectCaseExample.exe". Now run it at the command line like so:

C:\>VBDotNetSchoolLesson3 2
You typed 2 (two) as command line argument
or,
C:> VBDotNetSchoolLesson3 4
You typed number from 3 (three) to five (five) as first command line argument
or,
C:> VBDotNetSchoolLesson3 7
You typed other than 1, 2, 3, 4 and 5

If you did not enter any command line argument or give a non-integer argument, the program will raise an exception

Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
at VBDotNetSchoolLesson3.ArithmeticOperators.Main(Str ing[] userInput) in C:\Documents and Settings\farazr.YEVOLVE\My Documents\Visual Studio Projects\VBDotNe tSchoolLesson3\Module1.vb:line 14

Lets come to the internal workings. We converted the first command line argument (userInput(0)) into an Integer variable input. For conversion, we used static Parse() method of the Integer data type. This method takes a String and returns an equivalent integer or raises an exception if the conversion can�t be completed. Next we checked the value of input variable using switch the statement

Code:

Select Case input 
...
End Select

Later on in the basis of the input values, we took specific actions under the respective case statements. Case 1 ' if it is 1 Console.WriteLine("You typed 1 (one) as the first command line argument")

We can also specify a range in the Case Expression to match

Code:

Case 3 To 5  ' if it is 3
     Console.WriteLine("You typed number from 3 (three) 
                       to five (five) as first command line argument")

If all the specific checks fail (input is neither 1,2,3,4 or 5), the statements under �Case Else� will execute.

Code:

Case Else  ' if it is not of the above
     Console.WriteLine("You typed other than 1, 2, 3, 4 and 5")

There are some important points to remember when using switch�case statement in VB.Net

* You can use any implicit data type in the Select statement
* You can use multiple statements under a single case statement as follows

Code:

Case "Pakistan"
     continent = "Asia"
     Console.WriteLine("Pakistan is an Asian Country")
     Case Else
     continent = "Un-recognized"
     Console.WriteLine("Un-recognized country discovered")

* Statements under Case Else will only be executed if and only if all Case checks fail.
* You can't have more than one Case Else block in a single Select statement.

Loops In VB.Net
Loops are used for iteration purposes, i.e., performing a task multiple times (usually until a termination condition is met)

For�Next Loop
The most common type of loop in VB.Net is the For...Next loop. The basic structure of the For...Next loop is exactly the same as in VB6 and is like so:

Code:

For variable = startingValue To lastValue
	statement or block of statements 
Next

Lets see a For...Next loop that will write integers from 1 to 10 on the console

Code:

Dim i As Integer
For i = 1 to 10
    Console.WriteLine("In the loop, value of i is " & i)
Next

At the start, an integer variable i is initialized with the value of 1, then the statements under the For are executed until the value of i does not equal 10. Each time i is incremented by 1.

The important points about for loop are:

* You can use an Exit For statement in a For...Next loop or any other loop to change the normal execution flow
* An Exit For statement terminates the loop and transfers the execution point outside the for loop as below:

Code:

For i=1 to 10
    If i>5 Then
    Exit For
End If
    Console.WriteLine("In the loop, value of i is {0}.", i)
Next

The loop will terminate once the value of i gets greater than 5. If some statements are present after Exit For, it should be enclosed under some conditions. Otherwise the lines following the break point will not execute

Code:

For i = 1 To 10
    Exit For
    Console.WriteLine()
Next

You can define the increment/decrement (change) in each iteration of a For...Next Loop using the Step statement. The code below will increment by 2 in the value of i in each cycle of the loop

Code:

For i = 1 To 10 Step 2
    Console.WriteLine("Value of i is {0}", i)
Next

The following is the output on the Console,

Value of i is 1
Value of i is 3
Value of i is 5
Value of i is 7
Value of i is 9
Press any key to continue Note that the increment starts after the first iteration. You can also specify the negative increment (i.e., decrement) in a Step. The following code will output Integers from 10 to 1

Value of i is 10
Value of i is 9
Value of i is 8
Value of i is 7
Value of i is 6
Value of i is 5
Value of i is 4
Value of i is 3
Value of i is 2
Value of i is 1
Press any key to continue

Do While�Loop
The general structure of the Do While...Loop is

Code:

Do While Boolean expression
     Statement or block of statements
Loop

The statements under Do While will run continuously as long as the Boolean expression evaluates to true. The similar code for printing integers 1 to 10 on Console using the Do While...Loop is

Code:

Dim i As Integer =1
Do While i<=10
     Console.WriteLine("In the loop, value of i is " & i)
i = i + 1
Loop

Do�Loop While
A Do...Loop While is similar to a Do While...Loop, except that it does not check the condition before entering the first iteration (execution of code inside the body of loop). The general form of the a Do...Loop While is:

Code:

Do 
statement or block of statements
Loop While Boolean expression

The statements under the Do will be executed first and then the Boolean condition is checked. The loop will continue until the condition remains true. The code which prints integers 1 to 10 on console using Do...Loop While is

Code:

Dim i As Integer = 1
Do
Console.WriteLine("In the loop, value of i is " & i)
i = i + 1
Loop While i<=10

The important point is that the statements in a Do...Loop While execute at least once.

Do�Loop Until
A Do...Loop Until is similar to the Do...Loop While, except that it continues to execute the containing statements until the condition against the Until part evaluates to True or the condition against the Until remains False. The general form of the Do...Loop Until is as follows:

Code:

Do 
	statement or block of statements
Loop Until Boolean expression

The statements under the Do will execute first and then the condition is checked. The loop will continue until the condition remains false. The following code will print integers from 1 to 10 on console using the Do...Loop Until.

Code:

Dim i As Integer = 1
Do
     Console.WriteLine("In the loop, value of i is " & i)
i = i + 1
Loop Until i=10

Again the statements in Do...Loop Until execute at least once.

Arrays in VB.Net

Declaration
An Array is a collection of values of similar data type. Technically, VB.Net arrays are of reference type. Each array in VB.Net is an object and is inherited from the System.Array class. Arrays are declared as follows:

Code:

Dim <identifier>(<size of array>) As <data type>

Lets define an array of Integer type to hold 10 integers.

Code:

Dim myIntegers(9) As Integer

The above will create an array of 10 integers from the index of 0 to 9. The size of an array is fixed and must be defined before use. You can also use variables to define the size of array like so:

Code:

Dim size As Integer = 10
Dim myIntegers(10-1) As Integer

You can optionally perform declaration and initialization in separate steps like below:

Code:

Dim myIntegers() As Integer
myIntegers = New Integer() {1, 2, 3, 4, 5}

Here we initialized the array myIntegers using the values it holds. Note, we must enclose the values in curly brackets and separate the individual values with commas. This will create an array size of 5, whose successive values will be 1, 2, 3, 4, 5

It is important to note that when an array declaration and initialization are performed separately, you must provide values for each element.

Accessing the values stored in array
To access the values in an Array, we use the indexing operator (Integer index) by passing an Integer to indicate which particular index value we wish to access. It's important to note that index values in VB.Net starts from 0. So, if an array contains 5 elements, first element would be at index 0, second at index 1 and last (fifth) at index 4. The following code demonstrates how to access the 3rd element of an array

Code:

Dim myIntArray() As Integer
myIntArray = New Integer() {5, 10, 15, 20}
Dim j As Integer = myIntArray(2)

Lets make a program that uses an integral array.

Code:

' demonstrates the use of arrays in VB.Net
Public Sub Main()
' declaring and initializing an array of type integer
Dim myIntegers() As Integer = New Integer() {3, 7, 2, 14, 65} 
' iterating through the array and printing each element
Dim i As Integer 
For i = 0 to 4
Console.WriteLine(myIntegers(i))
Next
End Sub

Here we used the For...Next loop to iterate through an array and use the Console.WriteLine() method to print each individual element of the array. Note how the indexing operator () is used.

The above program is quite simple and efficient, but we have to hard-code the size of the array in the For...Next loop. As we mentioned earlier, arrays in VB.Net are reference type and are a sub-class of the System.Array Class. This class has a lot of useful properties and methods that can be applied to any instance of an array. Properties are very much like a combination of getter and setter methods in common Object Oriented languages. Properties are context sensitive; meaning the compiler can un-ambiguously identify whether it should call a getter or a setter in certain contexts. We will discuss properties in detail in the coming chapters. System.Array has a very useful read only property �Length� that can be used to find the length or the size of an array programmatically. Using the Length property, the For...Next loop from the previous code example can be written as follows

Code:

For i = 0 to myIntegers.Length - 1
    Console.WriteLine(myIntegers(i))
Next

This type of loop is very flexible and can be applied to an array of any size and of any data-type.

We can also understand the common description of the Main() Sub procedure. Main is also declared as

Code:

Public Main(ByVal args As String())

The command line arguments that we pass when executing our program are available in our programs through an array of String type, which is identified by args string array.

The For Each Loop
There is another type of loop that is very simple and useful to iterate through arrays and other collections. This is a For Each loop. The basic structure of the For Each loop is

Code:

For Each <identifier> in <array or collection>
         <statements or block of statements>
End For

Lets now make our previous code iterate through an array with a For Each loop

Code:

' demonstrates the use of arrays in VB.Net
Public Sub Main()
' declaring and initializing an array of type integer
Dim myIntegers() As Integer = New Integer() {3, 7, 2, 14, 65} 
' iterating through the array and printing each element
Dim i As Integer 
For Each i in myIntegers
    Console.WriteLine(i)
Next
End Sub

Simple and more readable! Isn't it?

Code:

For Each i in myIntegers

We declared the variable 'i' to hold individual values of array 'myIntegers' in each iteration. It is necessary to specify the type of variable 'i' same as the type of elements in the collection (Integer in our case).

Important points to note here are

* Variables are used to hold individual elements of an array in each iteration (i in the above example) are readonly. You can't change the elements of an array through it, you can only read it. This means For Each only allows you to iterate through the array or collection and not to change the contents of it. If you wish to perform some work on array elements such as to change the individual elements, you should use the For...Next loop.
* For Each can be used to iterate through arrays or collections. By collection, we mean any class, struct or interface that implements an IEnumerable interface. (Just go through this point and come back to it once we complete the lesson describing classes and interfaces)
* The String class is also a collection of characters (implements IEnumerable interface and returns the Char value in the Current property). The following code example demonstrates this and prints all the characters of a string.

Code:

Public Sub Main()
Dim name As String = "Faraz Rasheed"
Dim ch As Char
For Each ch in name
    Console.WriteLine(ch)
End For
End Sub

This will print each character of the name variable on a separate line.
Lesson #3 coming soon!