OVERVIEW

Visual Basic .NET (VB.NET) is an object-oriented computer programming language implemented on

the .NET Framework. Although it is an evolution of classic Visual Basic language, it is not backwards-
compatible with VB6, and any code written in the old version does not compile under VB.NET.
Like all other .NET languages, VB.NET has complete support for object-oriented concepts. Everything
in VB.NET is an object, including all of the primitive types (Short, Integer, Long, String, Boolean, etc.)
and user-defined types, events, and even assemblies. All objects inherits from the base class Object.
VB.NET is implemented by Microsoft's .NET framework. Therefore, it has full access to all the libraries
in the .Net Framework. It's also possible to run VB.NET programs on Mono, the open-source alternative
to .NET, not only under Windows, but even Linux or Mac OSX.
The following reasons make VB.Net a widely used professional language −
 Modern, general purpose.
 Object oriented.
 Component oriented.
 Easy to learn.
 Structured language.
 It produces efficient programs.
 It can be compiled on a variety of computer platforms.
 Part of .Net Framework.

Strong Programming Features VB.Net

VB.Net has numerous strong programming features that make it endearing to multitude of programmers
worldwide. Let us mention some of these features −
 Boolean Conditions
 Automatic Garbage Collection
 Standard Library
 Assembly Versioning
 Properties and Events
 Delegates and Events Management
 Easy-to-use Generics
 Indexers
 Conditional Compilation
 Simple Multithreading
ENVIRONMENT SETUP
We have already mentioned that VB.Net is part of .Net framework and used for writing .Net
applications. Therefore before discussing the available tools for running a VB.Net program, let us
understand how VB.Net relates to the .Net framework.

The .Net Framework

The .Net framework is a revolutionary platform that helps you to write the following types of
applications −
 Windows applications
 Web applications
 Web services
The .Net framework applications are multi-platform applications. The framework has been designed in
such a way that it can be used from any of the following languages: Visual Basic, C#, C++, Jscript, and
COBOL, etc.
All these languages can access the framework as well as communicate with each other.
The .Net framework consists of an enormous library of codes used by the client languages like VB.Net.
These languages use object-oriented methodology.
Following are some of the components of the .Net framework −
 Common Language Runtime (CLR)
 The .Net Framework Class Library
 Common Language Specification
 Common Type System
 Metadata and Assemblies
 Windows Forms
 ASP.Net and ASP.Net AJAX
 ADO.Net
 Windows Workflow Foundation (WF)
 Windows Presentation Foundation
 Windows Communication Foundation (WCF)
 LINQ
For the jobs each of these components perform, please see ASP.Net - Introduction, and for details of
each component, please consult Microsoft's documentation.

Integrated Development Environment (IDE) For VB.Net

Microsoft provides the following development tools for VB.Net programming −

 Visual Studio 2010 (VS)
 Visual Basic 2010 Express (VBE)
 Visual Web Developer
PROGRAM STRUCTURE

VB.Net Hello World Example

A VB.Net program basically consists of the following parts −

 Namespace declaration
 A class or module
 One or more procedures
 Variables
 The Main procedure
 Statements & Expressions
 Comments
Let us look at a simple code that would print the words "Hello World" −

Live Demo
Imports System
Module Module1
'This program will display Hello World
Sub Main()
Console.WriteLine("Hello World")
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
Hello, World!
Let us look various parts of the above program −
 The first line of the program Imports System is used to include the System namespace in the
program.
 The next line has a Module declaration, the module Module1. VB.Net is completely object
oriented, so every program must contain a module of a class that contains the data and
procedures that your program uses.
 Classes or Modules generally would contain more than one procedure. Procedures contain the
executable code, or in other words, they define the behavior of the class. A procedure could be
any of the following −
o Function

o Sub

o Operator

o Get

o Set
 o AddHandler

o RemoveHandler

o RaiseEvent

 The next line( 'This program) will be ignored by the compiler and it has been put to add
additional comments in the program.
 The next line defines the Main procedure, which is the entry point for all VB.Net programs. The
Main procedure states what the module or class will do when executed.
 The Main procedure specifies its behavior with the statement
Console.WriteLine("Hello World") WriteLine is a method of the Console class defined in
the System namespace. This statement causes the message "Hello, World!" to be displayed on
the screen.
 The last line Console.ReadKey() is for the VS.NET Users. This will prevent the screen from
running and closing quickly when the program is launched from Visual Studio .NET.

Compile & Execute VB.Net Program

If you are using Visual Studio.Net IDE, take the following steps −
 Start Visual Studio.
 On the menu bar, choose File → New → Project.
 Choose Visual Basic from templates
 Choose Console Application.
 Specify a name and location for your project using the Browse button, and then choose the OK
button.
 The new project appears in Solution Explorer.
 Write code in the Code Editor.
 Click the Run button or the F5 key to run the project. A Command Prompt window appears that
contains the line Hello World.
You can compile a VB.Net program by using the command line instead of the Visual Studio IDE −
 Open a text editor and add the above mentioned code.
 Save the file as helloworld.vb
 Open the command prompt tool and go to the directory where you saved the file.
 Type vbc helloworld.vb and press enter to compile your code.
 If there are no errors in your code the command prompt will take you to the next line and would
generate helloworld.exe executable file.
 Next, type helloworld to execute your program.
 You will be able to see "Hello World" printed on the screen.
BASIC SYNTAX
B.Net is an object-oriented programming language. In Object-Oriented Programming methodology, a
program consists of various objects that interact with each other by means of actions. The actions that an
object may take are called methods. Objects of the same kind are said to have the same type or, more
often, are said to be in the same class.
When we consider a VB.Net program, it can be defined as a collection of objects that communicate via
invoking each other's methods. Let us now briefly look into what do class, object, methods and instance
variables mean.
 Object − Objects have states and behaviors. Example: A dog has states - color, name, breed as
well as behaviors - wagging, barking, eating, etc. An object is an instance of a class.
 Class − A class can be defined as a template/blueprint that describes the behaviors/states that
objects of its type support.
 Methods − A method is basically a behavior. A class can contain many methods. It is in methods
where the logics are written, data is manipulated and all the actions are executed.
 Instance Variables − Each object has its unique set of instance variables. An object's state is
created by the values assigned to these instance variables.

A Rectangle Class in VB.Net

For example, let us consider a Rectangle object. It has attributes like length and width. Depending upon
the design, it may need ways for accepting the values of these attributes, calculating area and displaying
details.
Let us look at an implementation of a Rectangle class and discuss VB.Net basic syntax on the basis of
our observations in it −

Live Demo
Imports System
Public Class Rectangle
Private length As Double
Private width As Double

'Public methods
Public Sub AcceptDetails()
length = 4.5
width = 3.5
End Sub

Public Function GetArea() As Double

GetArea = length * width
End Function
Public Sub Display()
Console.WriteLine("Length: {0}", length)
Console.WriteLine("Width: {0}", width)
Console.WriteLine("Area: {0}", GetArea())
 End Sub

Shared Sub Main()

Dim r As New Rectangle()
r.Acceptdetails()
r.Display()
Console.ReadLine()
End Sub
End Class
When the above code is compiled and executed, it produces the following result −
Length: 4.5
Width: 3.5
Area: 15.75
In previous chapter, we created a Visual Basic module that held the code. Sub Main indicates the entry
point of VB.Net program. Here, we are using Class that contains both code and data. You use classes to
create objects. For example, in the code, r is a Rectangle object.
An object is an instance of a class −
Dim r As New Rectangle()
A class may have members that can be accessible from outside class, if so specified. Data members are
called fields and procedure members are called methods.
Shared methods or static methods can be invoked without creating an object of the class. Instance
methods are invoked through an object of the class −

Shared Sub Main()

Dim r As New Rectangle()
r.Acceptdetails()
r.Display()
Console.ReadLine()
End Sub

Identifiers

An identifier is a name used to identify a class, variable, function, or any other user-defined item. The
basic rules for naming classes in VB.Net are as follows −
 A name must begin with a letter that could be followed by a sequence of letters, digits (0 - 9) or
underscore. The first character in an identifier cannot be a digit.
 It must not contain any embedded space or symbol like ? - +! @ # % ^ & * ( ) [ ] { } . ; : " ' /
and \. However, an underscore ( _ ) can be used.
 It should not be a reserved keyword.
Data types refer to an extensive system used for declaring variables or functions of different types. The
type of a variable determines how much space it occupies in storage and how the bit pattern stored is
interpreted.

Data Types Available in VB.Net

VB.Net provides a wide range of data types. The following table shows all the data types available −

Data Type Storage Allocation Value Range

Boolean Depends on implementing platform True or False

Byte 1 byte 0 through 255 (unsigned)

Char 2 bytes 0 through 65535 (unsigned)

Date 8 bytes 0:00:00 (midnight) on January 1, 0001 through

11:59:59 PM on December 31, 9999

Decimal 16 bytes 0 through +/-79,228,162,514,264,337,593,543,950,335

(+/-7.9...E+28) with no decimal point; 0 through +/-
7.9228162514264337593543950335 with 28 places to
the right of the decimal

Double 8 bytes
-1.79769313486231570E+308 through -
4.94065645841246544E-324, for negative values
4.94065645841246544E-324 through
1.79769313486231570E+308, for positive values

Integer 4 bytes -2,147,483,648 through 2,147,483,647 (signed)

Long 8 bytes -9,223,372,036,854,775,808 through

9,223,372,036,854,775,807(signed)

Object Any type can be stored in a variable of type Object

4 bytes on 32-bit platform
 8 bytes on 64-bit platform

SByte 1 byte -128 through 127 (signed)

Short 2 bytes -32,768 through 32,767 (signed)

Single 4 bytes
-3.4028235E+38 through -1.401298E-45 for negative
values;
1.401298E-45 through 3.4028235E+38 for positive
values

String Depends on implementing platform 0 to approximately 2 billion Unicode characters

UInteger 4 bytes 0 through 4,294,967,295 (unsigned)

ULong 8 bytes 0 through 18,446,744,073,709,551,615 (unsigned)

User- Depends on implementing platform Each member of the structure has a range determined
Defined by its data type and independent of the ranges of the
other members

UShort 2 bytes 0 through 65,535 (unsigned)

Example

The following example demonstrates use of some of the types −

Live Demo

Module DataTypes
Sub Main()
Dim b As Byte
Dim n As Integer
Dim si As Single
Dim d As Double
Dim da As Date
Dim c As Char
Dim s As String
Dim bl As Boolean

b=1
n = 1234567
 si = 0.12345678901234566
d = 0.12345678901234566
da = Today
c = "U"c
s = "Me"

If ScriptEngine = "VB" Then

bl = True
Else
bl = False
End If

If bl Then
'the oath taking
Console.Write(c & " and," & s & vbCrLf)
Console.WriteLine("declaring on the day of: {0}", da)
Console.WriteLine("We will learn VB.Net seriously")
Console.WriteLine("Lets see what happens to the floating point variables:")
Console.WriteLine("The Single: {0}, The Double: {1}", si, d)
End If
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
U and, Me
declaring on the day of: 12/4/2012 12:00:00 PM
We will learn VB.Net seriously
Lets see what happens to the floating point variables:
The Single:0.1234568, The Double: 0.123456789012346

he Type Conversion Functions in VB.Net

VB.Net provides the following in-line type conversion functions −

Sr.No Functions & Description

.

1
CBool(expression)
Converts the expression to Boolean data type.

2
CByte(expression)
Converts the expression to Byte data type.
3
CChar(expression)
Converts the expression to Char data type.

4
CDate(expression)
Converts the expression to Date data type

5
CDbl(expression)
Converts the expression to Double data type.

6
CDec(expression)
Converts the expression to Decimal data type.

7
CInt(expression)
Converts the expression to Integer data type.

8
CLng(expression)
Converts the expression to Long data type.

9
CObj(expression)
Converts the expression to Object type.

10
CSByte(expression)
Converts the expression to SByte data type.

11
CShort(expression)
Converts the expression to Short data type.

12
CSng(expression)
Converts the expression to Single data type.

13
CStr(expression)
Converts the expression to String data type.
 14
CUInt(expression)
Converts the expression to UInt data type.

15
CULng(expression)
Converts the expression to ULng data type.

16
CUShort(expression)
Converts the expression to UShort data type.

Example

The following example demonstrates some of these functions −

Live Demo

Module DataTypes
Sub Main()
Dim n As Integer
Dim da As Date
Dim bl As Boolean = True
n = 1234567
da = Today

Console.WriteLine(bl)
Console.WriteLine(CSByte(bl))
Console.WriteLine(CStr(bl))
Console.WriteLine(CStr(da))
Console.WriteLine(CChar(CChar(CStr(n))))
Console.WriteLine(CChar(CStr(da)))
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
True
-1
True
12/4/2012
1
1
VARIABLES
A variable is nothing but a name given to a storage area that our programs can manipulate. Each variable
in VB.Net has a specific type, which determines the size and layout of the variable's memory; the range
of values that can be stored within that memory; and the set of operations that can be applied to the
variable.
We have already discussed various data types. The basic value types provided in VB.Net can be
categorized as −

Type Example

Integral types SByte, Byte, Short, UShort, Integer, UInteger, Long, ULong and Char

Floating point types Single and Double

Decimal types Decimal

Boolean types True or False values, as assigned

Date types Date

VB.Net also allows defining other value types of variable like Enum and reference types of variables
like Class. We will discuss date types and Classes in subsequent chapters.

Variable Declaration in VB.Net

The Dim statement is used for variable declaration and storage allocation for one or more variables. The
Dim statement is used at module, class, structure, procedure or block level.
Syntax for variable declaration in VB.Net is −
[ < attributelist > ] [ accessmodifier ] [[ Shared ] [ Shadows ] | [ Static ]]
[ ReadOnly ] Dim [ WithEvents ] variablelist
Where,
 attributelist is a list of attributes that apply to the variable. Optional.
 accessmodifier defines the access levels of the variables, it has values as - Public, Protected,
Friend, Protected Friend and Private. Optional.
 Shared declares a shared variable, which is not associated with any specific instance of a class or
structure, rather available to all the instances of the class or structure. Optional.
 Shadows indicate that the variable re-declares and hides an identically named element, or set of
overloaded elements, in a base class. Optional.
 Static indicates that the variable will retain its value, even when the after termination of the
procedure in which it is declared. Optional.
 ReadOnly means the variable can be read, but not written. Optional.
  WithEvents specifies that the variable is used to respond to events raised by the instance
assigned to the variable. Optional.
 Variablelist provides the list of variables declared.
Each variable in the variable list has the following syntax and parts −
variablename[ ( [ boundslist ] ) ] [ As [ New ] datatype ] [ = initializer ]
Where,
 variablename − is the name of the variable
 boundslist − optional. It provides list of bounds of each dimension of an array variable.
 New − optional. It creates a new instance of the class when the Dim statement runs.
 datatype − Required if Option Strict is On. It specifies the data type of the variable.
 initializer − Optional if New is not specified. Expression that is evaluated and assigned to the
variable when it is created.
Some valid variable declarations along with their definition are shown here −

Dim StudentID As Integer

Dim StudentName As String
Dim Salary As Double
Dim count1, count2 As Integer
Dim status As Boolean
Dim exitButton As New System.Windows.Forms.Button
Dim lastTime, nextTime As Date

Variable Initialization in VB.Net

Variables are initialized (assigned a value) with an equal sign followed by a constant expression. The
general form of initialization is −
variable_name = value;
for example,

Dim pi As Double
pi = 3.14159
You can initialize a variable at the time of declaration as follows −

Dim StudentID As Integer = 100

Dim StudentName As String = "Bill Smith"

Example

Try the following example which makes use of various types of variables −

Live Demo
Module variablesNdataypes
Sub Main()
 Dim a As Short
Dim b As Integer
Dim c As Double

a = 10
b = 20
c=a+b
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c)
Console.ReadLine()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
a = 10, b = 20, c = 30

Accepting Values from User

The Console class in the System namespace provides a function ReadLine for accepting input from the
user and store it into a variable. For example,

Dim message As String

message = Console.ReadLine
The following example demonstrates it −

Module variablesNdataypes
Sub Main()
Dim message As String
Console.Write("Enter message: ")
message = Console.ReadLine
Console.WriteLine()
Console.WriteLine("Your Message: {0}", message)
Console.ReadLine()
End Sub
End Module
When the above code is compiled and executed, it produces the following result (assume the user inputs
Hello World) −
Enter message: Hello World
Your Message: Hello World

Lvalues and Rvalues

There are two kinds of expressions −

 lvalue − An expression that is an lvalue may appear as either the left-hand or right-hand side of
an assignment.
 rvalue − An expression that is an rvalue may appear on the right- but not left-hand side of an
assignment.
Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are
rvalues and so may not be assigned and can not appear on the left-hand side. Following is a valid
statement −
Dim g As Integer = 20
But following is not a valid statement and would generate compile-time error −
20 = g

CONSTANT AND ENUMERATION

The constants refer to fixed values that the program may not alter during its execution. These fixed
values are also called literals.
Constants can be of any of the basic data types like an integer constant, a floating constant, a character
constant, or a string literal. There are also enumeration constants as well.
The constants are treated just like regular variables except that their values cannot be modified after their
definition.
An enumeration is a set of named integer constants.

Declaring Constants

In VB.Net, constants are declared using the Const statement. The Const statement is used at module,
class, structure, procedure, or block level for use in place of literal values.
The syntax for the Const statement is −
[ < attributelist > ] [ accessmodifier ] [ Shadows ]
Const constantlist
Where,
 attributelist − specifies the list of attributes applied to the constants; you can provide multiple
attributes separated by commas. Optional.
 accessmodifier − specifies which code can access these constants. Optional. Values can be either
of the: Public, Protected, Friend, Protected Friend, or Private.
 Shadows − this makes the constant hide a programming element of identical name in a base
class. Optional.
 Constantlist − gives the list of names of constants declared. Required.
Where, each constant name has the following syntax and parts −
constantname [ As datatype ] = initializer
 constantname − specifies the name of the constant
 datatype − specifies the data type of the constant
 initializer − specifies the value assigned to the constant
For example,
'The following statements declare constants.'
Const maxval As Long = 4999
Public Const message As String = "HELLO"
Private Const piValue As Double = 3.1415

Example

The following example demonstrates declaration and use of a constant value −

Live Demo
Module constantsNenum
Sub Main()
Const PI = 3.14149
Dim radius, area As Single
radius = 7
area = PI * radius * radius
Console.WriteLine("Area = " & Str(area))
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
Area = 153.933

Print and Display Constants in VB.Net

VB.Net provides the following print and display constants −

Sr.No Constant & Description

.

1
vbCrLf
Carriage return/linefeed character combination.

2
vbCr
Carriage return character.

3
vbLf
Linefeed character.

4
vbNewLine
 Newline character.

5
vbNullChar
Null character.

6
vbNullString
Not the same as a zero-length string (""); used for calling external procedures.

7
vbObjectError
Error number. User-defined error numbers should be greater than this value. For example:
Err.Raise(Number) = vbObjectError + 1000

8
vbTab
Tab character.

9
vbBack
Backspace character.

Declaring Enumerations

An enumerated type is declared using the Enum statement. The Enum statement declares an
enumeration and defines the values of its members. The Enum statement can be used at the module,
class, structure, procedure, or block level.
The syntax for the Enum statement is as follows −
[ < attributelist > ] [ accessmodifier ] [ Shadows ]
Enum enumerationname [ As datatype ]
memberlist
End Enum
Where,
 attributelist − refers to the list of attributes applied to the variable. Optional.
 accessmodifier − specifies which code can access these enumerations. Optional. Values can be
either of the: Public, Protected, Friend or Private.
 Shadows − this makes the enumeration hide a programming element of identical name in a base
class. Optional.
 enumerationname − name of the enumeration. Required
 datatype − specifies the data type of the enumeration and all its members.
  memberlist − specifies the list of member constants being declared in this statement. Required.
Each member in the memberlist has the following syntax and parts:
[< attribute list >] member name [ = initializer ]
Where,
 name − specifies the name of the member. Required.
 initializer − value assigned to the enumeration member. Optional.
For example,

Enum Colors
red = 1
orange = 2
yellow = 3
green = 4
azure = 5
blue = 6
violet = 7
End Enum

Example

The following example demonstrates declaration and use of the Enum variable Colors −

Live Demo
Module constantsNenum
Enum Colors
red = 1
orange = 2
yellow = 3
green = 4
azure = 5
blue = 6
violet = 7
End Enum

Sub Main()
Console.WriteLine("The Color Red is : " & Colors.red)
Console.WriteLine("The Color Yellow is : " & Colors.yellow)
Console.WriteLine("The Color Blue is : " & Colors.blue)
Console.WriteLine("The Color Green is : " & Colors.green)
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
The Color Red is: 1
The Color Yellow is: 3
The Color Blue is: 6
The Color Green is: 4

STATEMENT
A statement is a complete instruction in Visual Basic programs. It may contain keywords, operators,
variables, literal values, constants and expressions.
Statements could be categorized as −
 Declaration statements − these are the statements where you name a variable, constant, or
procedure, and can also specify a data type.
 Executable statements − these are the statements, which initiate actions. These statements can
call a method or function, loop or branch through blocks of code or assign values or expression
to a variable or constant. In the last case, it is called an Assignment statement.

Declaration Statements

The declaration statements are used to name and define procedures, variables, properties, arrays, and
constants. When you declare a programming element, you can also define its data type, access level, and
scope.
The programming elements you may declare include variables, constants, enumerations, classes,
structures, modules, interfaces, procedures, procedure parameters, function returns, external procedure
references, operators, properties, events, and delegates.
Following are the declaration statements in VB.Net −

Sr.No Statements and Description Example

1 Dim number As
Dim Statement
Integer
Declares and allocates storage space for one or more variables. Dim quantity As
Integer = 100
Dim message As
String = "Hello!"

2 Const maximum As
Const Statement
Long = 1000
Declares and defines one or more constants. Const
naturalLogBase As
Object
=
CDec(2.7182818284)

3 Enum
Enum Statement
CoffeeMugSize
Declares an enumeration and defines the values of its members. Jumbo
ExtraLarge
 Large
Medium
Small
End Enum

4 Class Box
Class Statement
Public length As
Declares the name of a class and introduces the definition of the variables, Double
properties, events, and procedures that the class comprises. Public breadth As
Double
Public height As
Double
End Class

5 Structure Box
Structure Statement
Public length As
Declares the name of a structure and introduces the definition of the Double
variables, properties, events, and procedures that the structure comprises. Public breadth As
Double
Public height As
Double
End Structure

6 Public Module
Module Statement
myModule
Declares the name of a module and introduces the definition of the Sub Main()
variables, properties, events, and procedures that the module comprises. Dim user As String =
InputBox("What is
your name?")
MsgBox("User name
is" & user)
End Sub
End Module

7 Public Interface
Interface Statement
MyInterface
Declares the name of an interface and introduces the definitions of the Sub doSomething()
members that the interface comprises. End Interface

8 Function myFunction
Function Statement
(ByVal n As Integer)
Declares the name, parameters, and code that define a Function procedure. As Double
Return 5.87 * n
End Function

9 Sub mySub(ByVal s
Sub Statement
 Declares the name, parameters, and code that define a Sub procedure. As String)
Return
End Sub

10 Declare Function
Declare Statement
getUserName
Declares a reference to a procedure implemented in an external file. Lib "advapi32.dll"
Alias
"GetUserNameA"
(
ByVal lpBuffer As
String,
ByRef nSize As
Integer) As Integer

11 Public Shared
Operator Statement
Operator +
Declares the operator symbol, operands, and code that define an operator (ByVal x As obj,
procedure on a class or structure. ByVal y As obj) As
obj
Dim r As New obj
' implemention code
for r = x + y
Return r
End Operator

12 ReadOnly Property
Property Statement
quote() As String
Declares the name of a property, and the property procedures used to store Get
and retrieve the value of the property. Return
quoteString
End Get
End Property

13 Public Event
Event Statement
Finished()
Declares a user-defined event.

14 Delegate Function
Delegate Statement
MathOperator(
Used to declare a delegate. ByVal x As
Double,
ByVal y As Double
) As Double

Executable Statements
An executable statement performs an action. Statements calling a procedure, branching to another place
in the code, looping through several statements, or evaluating an expression are executable statements.
An assignment statement is a special case of an executable statement.
Example
The following example demonstrates a decision making statement −

Live Demo

Module decisions
Sub Main()
'local variable definition '
Dim a As Integer = 10

' check the boolean condition using if statement '

If (a < 20) Then
' if condition is true then print the following '
Console.WriteLine("a is less than 20")
End If
Console.WriteLine("value of a is : {0}", a)
Console.ReadLine()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
a is less than 20;
value of a is : 10

The VB.Net compiler directives give instructions to the compiler to preprocess the information before
actual compilation starts. All these directives begin with #, and only white-space characters may appear
before a directive on a line. These directives are not statements.
VB.Net compiler does not have a separate preprocessor; however, the directives are processed as if there
was one. In VB.Net, the compiler directives are used to help in conditional compilation. Unlike C and
C++ directives, they are not used to create macros.

Compiler Directives in VB.Net

VB.Net provides the following set of compiler directives −

 The #Const Directive
 The #ExternalSource Directive
 The #If...Then...#Else Directives
 The #Region Directive
The #Const Directive
This directive defines conditional compiler constants. Syntax for this directive is −
#Const constname = expression
Where,
  constname − specifies the name of the constant. Required.
 expression − it is either a literal, or other conditional compiler constant, or a combination
including any or all arithmetic or logical operators except Is.
For example,
#Const state = "WEST BENGAL"
Example
The following code demonstrates a hypothetical use of the directive −

Live Demo

Module mydirectives
#Const age = True
Sub Main()
#If age Then
Console.WriteLine("You are welcome to the Robotics Club")
#End If
Console.ReadKey()
End Sub
End Module
When the above code is compiled and executed, it produces the following result −
You are welcome to the Robotics Club
The #ExternalSource Directive
This directive is used for indicating a mapping between specific lines of source code and text external to
the source. It is used only by the compiler and the debugger has no effect on code compilation.
This directive allows including external code from an external code file into a source code file.
Syntax for this directive is −
#ExternalSource( StringLiteral , IntLiteral )
[ LogicalLine ]
#End ExternalSource
The parameters of #ExternalSource directive are the path of external file, line number of the first line,
and the line where the error occurred.
Example
The following code demonstrates a hypothetical use of the directive −

Module mydirectives
Public Class ExternalSourceTester

Sub TestExternalSource()

#ExternalSource("c:\vbprogs\directives.vb", 5)
Console.WriteLine("This is External Code. ")
#End ExternalSource
 End Sub
End Class

Sub Main()
Dim t As New ExternalSourceTester()
t.TestExternalSource()
Console.WriteLine("In Main.")
Console.ReadKey()

End Sub
When the above code is compiled and executed, it produces the following result −
This is External Code.
In Main.
The #If...Then...#Else Directives
This directive conditionally compiles selected blocks of Visual Basic code.
Syntax for this directive is −
#If expression Then
statements
[ #ElseIf expression Then
[ statements ]
...
#ElseIf expression Then
[ statements ] ]
[ #Else
[ statements ] ]
#End If
For example,

#Const TargetOS = "Linux"

#If TargetOS = "Windows 7" Then
' Windows 7 specific code
#ElseIf TargetOS = "WinXP" Then
' Windows XP specific code
#Else
' Code for other OS
#End if
Example
The following code demonstrates a hypothetical use of the directive −

Live Demo

Module mydirectives
#Const classCode = 8

Sub Main()
#If classCode = 7 Then
 Console.WriteLine("Exam Questions for Class VII")
#ElseIf classCode = 8 Then
Console.WriteLine("Exam Questions for Class VIII")
#Else
Console.WriteLine("Exam Questions for Higher Classes")
#End If
Console.ReadKey()

End Sub
End Module
When the above code is compiled and executed, it produces the following result −
Exam Questions for Class VIII
The #Region Directive
This directive helps in collapsing and hiding sections of code in Visual Basic files.
Syntax for this directive is −
#Region "identifier_string"
#End Region
For example,

#Region "StatsFunctions"
' Insert code for the Statistical functions here.
#End Region

OPERATORS
An operator is a symbol that tells the compiler to perform specific mathematical or logical
manipulations. VB.Net is rich in built-in operators and provides following types of commonly used
operators −
 Arithmetic Operators
 Comparison Operators
 Logical/Bitwise Operators
 Bit Shift Operators
 Assignment Operators
 Miscellaneous Operators
This tutorial will explain the most commonly used operators.

Arithmetic Operators

Following table shows all the arithmetic operators supported by VB.Net. Assume variable A holds 2 and
variable B holds 7, then −
Show Examples
 Operato Description Example
r

^ Raises one operand to the power of another B^A will give 49

+ Adds two operands A + B will give 9

- Subtracts second operand from the first A - B will give -5

* Multiplies both operands A * B will give 14

/ Divides one operand by another and returns a floating point B / A will give 3.5
result

\ Divides one operand by another and returns an integer result B \ A will give 3

MOD Modulus Operator and remainder of after an integer division B MOD A will give 1

Comparison Operators

Following table shows all the comparison operators supported by VB.Net. Assume variable A holds 10
and variable B holds 20, then −
Show Examples

Operato Description Example

r

= Checks if the values of two operands are equal or not; if yes, then condition becomes (A = B)
true. is not
true.

<> Checks if the values of two operands are equal or not; if values are not equal, then (A <> B)
condition becomes true. is true.
 > Checks if the value of left operand is greater than the value of right operand; if yes, (A > B)
then condition becomes true. is not
true.

< Checks if the value of left operand is less than the value of right operand; if yes, then (A < B)
condition becomes true. is true.

>= Checks if the value of left operand is greater than or equal to the value of right (A >= B)
operand; if yes, then condition becomes true. is not
true.

<= Checks if the value of left operand is less than or equal to the value of right operand; (A <= B)
if yes, then condition becomes true. is true.

Apart from the above, VB.Net provides three more comparison operators, which we will be using in
forthcoming chapters; however, we give a brief description here.
 Is Operator − It compares two object reference variables and determines if two object references
refer to the same object without performing value comparisons. If object1 and object2 both refer
to the exact same object instance, result is True; otherwise, result is False.
 IsNot Operator − It also compares two object reference variables and determines if two object
references refer to different objects. If object1 and object2 both refer to the exact same object
instance, result is False; otherwise, result is True.
 Like Operator − It compares a string against a pattern.

Logical/Bitwise Operators

Following table shows all the logical operators supported by VB.Net. Assume variable A holds Boolean
value True and variable B holds Boolean value False, then −
Show Examples

Operato Description Example

r

And It is the logical as well as bitwise AND operator. If both the operands are true, then (A And
condition becomes true. This operator does not perform short-circuiting, i.e., it B) is
evaluates both the expressions. False.
 Or It is the logical as well as bitwise OR operator. If any of the two operands is true, (A Or B)
then condition becomes true. This operator does not perform short-circuiting, i.e., it is True.
evaluates both the expressions.

Not It is the logical as well as bitwise NOT operator. Use to reverses the logical state of Not(A
its operand. If a condition is true, then Logical NOT operator will make false. And B)
is True.

Xor It is the logical as well as bitwise Logical Exclusive OR operator. It returns True if A Xor B
both expressions are True or both expressions are False; otherwise it returns False. is True.
This operator does not perform short-circuiting, it always evaluates both expressions
and there is no short-circuiting counterpart of this operator.

AndAlso It is the logical AND operator. It works only on Boolean data. It performs short- (A
circuiting. AndAlso
B) is
False.

OrElse It is the logical OR operator. It works only on Boolean data. It performs short- (A
circuiting. OrElse
B) is
True.

IsFalse It determines whether an expression is False.

IsTrue It determines whether an expression is True.

Bit Shift Operators

We have already discussed the bitwise operators. The bit shift operators perform the shift operations on
binary values. Before coming into the bit shift operators, let us understand the bit operations.
Bitwise operators work on bits and perform bit-by-bit operations. The truth tables for &, |, and ^ are as
follows −

p q p&q p|q p^q

0 0 0 0 0
 0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Assume if A = 60; and B = 13; now in binary format they will be as follows −
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
We have seen that the Bitwise operators supported by VB.Net are And, Or, Xor and Not. The Bit shift
operators are >> and << for left shift and right shift, respectively.
Assume that the variable A holds 60 and variable B holds 13, then −
Show Examples

Operator Description Example

And Bitwise AND Operator copies a bit to the result if it (A AND B) will give 12, which is 0000
exists in both operands. 1100

Or Binary OR Operator copies a bit if it exists in either (A Or B) will give 61, which is 0011
operand. 1101

Xor Binary XOR Operator copies the bit if it is set in (A Xor B) will give 49, which is 0011
one operand but not both. 0001

Not Binary Ones Complement Operator is unary and (Not A ) will give -61, which is 1100
 has the effect of 'flipping' bits. 0011 in 2's complement form due to a
signed binary number.

<< Binary Left Shift Operator. The left operands value A << 2 will give 240, which is 1111
is moved left by the number of bits specified by the 0000
right operand.

>> Binary Right Shift Operator. The left operands A >> 2 will give 15, which is 0000 1111
value is moved right by the number of bits specified
by the right operand.

Assignment Operators

There are following assignment operators supported by VB.Net −

Show Examples

Operator Description Example

= Simple assignment operator, Assigns values from C = A + B will assign value of A + B

right side operands to left side operand into C

+= Add AND assignment operator, It adds right C += A is equivalent to C = C + A

operand to the left operand and assigns the result to
left operand

-= Subtract AND assignment operator, It subtracts C -= A is equivalent to C = C - A

right operand from the left operand and assigns the
result to left operand

*= Multiply AND assignment operator, It multiplies C *= A is equivalent to C = C * A

right operand with the left operand and assigns the
result to left operand

/= Divide AND assignment operator, It divides left C /= A is equivalent to C = C / A

operand with the right operand and assigns the
result to left operand (floating point division)
\= Divide AND assignment operator, It divides left C \= A is equivalent to C = C \A
operand with the right operand and assigns the
result to left operand (Integer division)

^= Exponentiation and assignment operator. It raises C^=A is equivalent to C = C ^ A

the left operand to the power of the right operand
and assigns the result to left operand.

<<= Left shift AND assignment operator C <<= 2 is same as C = C << 2

>>= Right shift AND assignment operator C >>= 2 is same as C = C >> 2

&= Concatenates a String expression to a String

Str1 &= Str2 is same as
variable or property and assigns the result to the
variable or property. Str1 = Str1 & Str2

Decision making structures require that the programmer specify one or more conditions to be evaluated
or tested by the program, along with a statement or statements to be executed if the condition is
determined to be true, and optionally, other statements to be executed if the condition is determined to be
false.
Following is the general form of a typical decision making structure found in most of the programming
languages −

VB.Net provides the following types of decision making statements. Click the following links to check
their details.

Statement Description

If ... Then statement An If...Then statement consists of a boolean expression followed by

one or more statements.

If...Then...Else statement An If...Then statement can be followed by an optional Else statement,

 which executes when the boolean expression is false.

You can use one If or Else if statement inside another If or Else

nested If statements
if statement(s).

Select Case statement A Select Case statement allows a variable to be tested for equality
against a list of values.

nested Select Case statements You can use one select case statement inside another select
case statement(s).