Option Explicit and Option Strict
Option Explicit and Option Strict are compiler options that can be globally assigned to a
project and are interpreted at compile time. Setting these options enables programmers to
resolve some of the errors (e.g. typological errors) at compile time and thus prevent
runtime errors.

Option Explicit
Option Explicit was a feature of VB 6.0 and it has been made a part of .NET environment
too. This option can be used only at the module level. When this option is turned on, it
forces explicit declaration of variables in that module. This option can be turned "On" or
"Off". When it is not specified, by default, it is set to "Off".
Syntax: Option Explicit [On / Off]
When it is set to "On", it checks for any undeclared variables in the module at compile
time. If any undeclared variable is found, it generates a compile time error since the
compiler would not recognize the type of the undeclared variable. When it is set to "On",
variables can be declared using Dim, Public, Private or ReDim statements. Setting this
option to "On" helps programmers do away with any typological errors in the code.
When it is set to "Off", all undeclared variables are considered to be of type Object.
It is preferable to set this option to "On".

Option Strict
Visual Basic language in general does not require explicit syntax to be used when
performing operations that might not be optimally efficient (e.g. late binding) or that
might fail at run time (e.g. narrowing conversions). This permissive semantics often
prevents detection of coding errors and also affects the performance of the application.
VB.NET enables a programmer to enforce strict semantics by setting this option to "On".
When used, this option should appear before any other code. This option can be set to
"On" or "Off". If this statement is not specified, by default, it is set to "Off".
Syntax: Option Strict [On / Off]

When it is set to "On", it disallows any narrowing conversions to occur without an
explicit cast operator, late binding and does not let the programmer omit "As" clause in
the declaration statement. Since setting it to "On" requires explicit conversion, it also
requires that the compiler be able to determine the type of each variable. Thus it is
implied that Option Strict also means Option Explicit.
Visual Basic .NET allows implicit conversions of any data type to any other data type.
However, data loss can occur if the value of one data type is converted to a data type with
less precision or a smaller capacity. Setting this option to "On" ensures compile-time
notification of these types of conversions so they may be avoided.
Explicit conversions happen faster than the implicit conversions performed by the
system. In case of implicit conversions, the system has to identify the types involved in
the conversion and then obtain the correct handler to perform the conversion. In case of
explicit conversions, processing time gets reduced since the type of conversion is
explicitly mentioned.
From programmer point of view, explicit conversion may seem to be a burden since it
slows the development of a program by forcing the programmer to explicitly define each
conversion that needs to occur.
It is always recommended that you set Option Strict to "On" and use explicit conversions.
ByVal is Default
When implementing functions/procedures we often need to pass information. This
information can be passed to the called function/procedure through parameters.
Parameters can be passed by value or by reference.
When ByVal keyword is used, it causes the parameter to be passed by value. In this case,
a copy of the original parameter is passed to the called module. Thus any changes made
to the copy of the parameter do not affect the original value of the parameter.
When ByRef keyword is used, it sends a reference (pointer) to the original value to the
called module rather than its copy. Thus any changes made to the parameter in the
function/procedure will cause the original value to be modified.
With ByRef you are exposing a variable to modification which can lead to an unexpected
behavior. If that procedure calls another procedure and passes the same parameter ByRef,
the chances of unintentionally changing the original variable are increased.
In VB.NET, every parameter, by default, is passed by value if nothing is explicitly
specified. Thus it protects arguments against modification.

Example:
Public Class SampleClass
Sub Proc(ByVal a As Integer, b As Integer, ByRef c As Integer)
a = a + 2
b = b + 3
c = c + 4
End Sub
End Class
Sub Main()
Dim num1, num2, num3 As Integer
Dim Obj As New SampleClass()
num1 = 2
num2 = 3
num3 = 4
Obj.Proc(num1, num2, num3)
System.Console.WriteLine(num1)
System.Console.WriteLine(num2)
System.Console.WriteLine(num3)
End Sub


Explanation:
In the class SampleClass, there is one procedure Proc that takes three integers as
arguments. In Main(), a variable of type SampleClass is defined and three other integer
variables num1,num2,num3 are declared and given some initial values. The procedure is
then called passing these three variables as arguments. First variable num1 is passed by
value, second variable num2 is also passed by value since nothing is specified explicitly
and the last variable num3 is passed by reference since it is explicitly mentioned.
After calling the procedure, when the values of the three variables are checked, you will
notice that num1 and num2 retain their original values since they are passed by value
whereas the value of num3 changes to 8 since it was passed by reference.
Sub and Functions with Parenthesis
In VB.NET, both functions and procedures require parentheses around the parameter list,
even if it is empty.

Example:
Consider the following code that contains two functions and one procedure. The first
function named "HelloWorld" accepts no argument and returns "Hello World". The
second function named "HelloName" accepts an argument and appends that argument to
the string "Hello World" and finally returns the appended string. The procedure named
"Hello" displays the string "Hello World" on the console.

Public Class SampleClass
Function HelloWorld( ) As String
Helloworld = "Hello World"
End Function
Function HelloName(ByVal name As String) As String
HelloName = "Hello " & name
End Function
Sub Hello()
System.Console.WriteLine("Hello World")
End Sub
End Class
Sub Main()
Dim Obj As New SampleClass()
Dim str1 As String
Dim str2 As String
str1 = Obj.HelloWorld()
str2 = Obj.HelloName(" Everybody")
Obj.Hello()
End Sub


Explanation:
As mentioned, while calling the procedure Hello, parentheses have to be used even
though it does not require any argument. Similar treatment has to done for functions.
Structures Replace User Defined Types
In VB.NET, structures can be defined using Structure keyword. Unlike user defined
types, structures share many features with classes. Explicit mention of access modifier for
each member is necessary in VB.NET. Access modifiers can be Public, Protected,
Friend, Protected Friend, or Private. You can also use the Dim statement, which
defaults to public access.
Let us take an example of a Person that will have some characteristics as Name, Address,
Tel, Age etc. Now if we were to use this number of times, it will be better to have a type
called Person. The example below shows how to handle this.

Structure Person
Structure Person
Dim Name as String
Private Address as String
Dim Tel as String
Public Age as Integer
End Structure
As shown in the above code, explicit mention of the access specifier for each member is a
must.
Structures, like classes, can contain data members as well as data methods. Structures are
value types and are hence allocated on the stack where as classes are reference types and
require heap allocation.
Block Level Scope
The scope of block level variables is restricted to the block in which they are defined.
This block can be a function, procedure, a loop structure etc. A block level variable is not
accessible anywhere, outside its block.

Example:
Consider the sample code segment.
Sub BlockScope()
Dim a As Integer = 1
Dim i As Integer = 1
While (i <= 2)
Dim j As Integer = 1
j = j + 1
i = i + 1
End While
a = a + j
End Sub


Explanation:
The above code segment will give a compile-time error, since the scope of the variable ‘j’
is restricted to the while block and hence it is not accessible outside the while block.
Though block level variables cannot be accessed outside their block, their lifetime is still
that of the procedure containing them.

Early Vs Late Binding
In case of early binding, the compiler knows the object's data type at compile time and
hence can directly compile code to invoke the methods on the object. This enables the
compiler to discover the appropriate method and ensure that the referenced method does
exist and the parameters provided are in sync with that of the referenced method.
Since object types are known ahead of time, the IDE aids the programmer by providing
support for IntelliSense. This helps the programmer do away with any typological and
syntactical errors. If the method being referenced is not found, the programmer is notified
at compile time thus letting him rectify it rather than making him wait till the application
is run.
In case of late binding, the compiler cannot determine the object's data type and thus the
code interacts with the object dynamically at runtime. To make an object late-bound, it is
defined as a variable of type Object. This variable can reference any type of object and
allows programmers to attempt arbitrary method calls against the object even though the
Object datatype does not implement those methods. Since type of the object is not
known until runtime, neither compile-time syntax checking nor IntelliSense is possible.
The typological errors also go undetected until the application is run. However, there is
an unprecedented flexibility, since code that makes use of late binding can talk to any
object from any class as long as those objects implement the methods we require.
The discovery of the referenced method is done dynamically done at runtime and is then
invoked. This discovery takes time and the mechanism used to invoke a method through
late binding is not as efficient as that used to call a method that is known at compile time.
Thus, though late binding is flexible, it is error-prone and slower as compared to early
binding.
When Option Strict is "On", it does not support late binding since the datatype of the
object should be known at compile time.

Example:
Consider the below given code segment
Public Class SampleClass
Public Sub Proc()
MessageBox("This method is discovered dynamically at runtime")
End Sub
End Class
Public Class MainClass
Shared Sub Main()
Dim Obj As Object
Obj = New SampleClass()
Obj.Proc()
End Sub
End Class


Explanation:
The above code segment implements late-binding. There are two classes viz.
SampleClass and MainClass. The class SampleClass contains a procedure named Proc
that takes no arguments. This procedure displays an appropriate message in a message
box. The class MainClass declares a variable Obj of type Object. Thus at compile-time,
the actual data type of the variable is not known. At runtime, the system finds that it is
referencing a variable of type Sampleclass. This reference to the class is achieved using
new operator. The referenced method Proc is discovered at runtime and is finally
invoked.
Ctype Function
Ctype is a general cast keyword that coerces an expression into any type. It returns the
result of explicitly converting an expression to a specified data type, object, structure,
class, or interface. If no conversion exists from the type of the expression to the specified
type, a compile-time error occurs. When Ctype is used to perform explicit conversion,
execution is faster since it is compiled inline and hence no call to a procedure is involved
to perform the conversion.
Syntax: Ctype (expression, type name)

Example:
Consider the below given code segment
Public Class TrialClass
Sub Proc (obj as Object)
Dim Obj1 As OtherClass( )
Obj1 = Ctype (obj, OtherClass)
Obj1.OtherProc( )
End Sub
End Class


Explanation:
The variable Obj1 is of type OtherClass. This class has a procedure named OtherProc.
In the above code segment, the procedure Proc takes one parameter of type Object. The
Ctype statement gains an early bound reference to the object of type OtherClass. Thus
performance benefits of early binding can be achieved.

Changes to Boolean Operators
In Visual Basic.NET, And, Or, Xor, and Not are the boolean operators and BitAnd,
BitOr, BitXor, and BitNot are used for bitwise operations.
VB.NET has introduced the concept of short-circuiting. According to this concept, if the
first operand of an And operator evaluates to False, the remainder of the logical
expression is not evaluated. Similarly, if the first operand of an Or operator evaluates to
True, the remainder of the logical expression is not evaluated.
To perform the above mentioned functionality, VB.NET has introduced two new
operators viz. AndAlso and OrElse. AndAlso performs short-circuiting logical
conjunction on two expressions whereas OrElse performs short-circuiting logical
disjunction on two expressions
Syntax : expression1 AndAlso expression2
expression1 OrElse expression2
Structured Error Handling
The whole idea behind error handling is to accurately trap the error. VB.NET has
introduced a structured approach for handling errors, in order to keep in sync with the
features offered by all Object Oriented languages viz. C#, Java etc. This structured
approach is implemented using a Try…Catch…Finally block structure and is known as
Exception Handling.
Try statement comes before the block of code that needs to tested for errors, Catch
statement handles specific errors and hence surrounds the block of code that handles
those errors and Finally block of code is always executed and contains cleanup routines
for exception situations. Since Catch block is specific to the type of error that needs to be
caught, a single Try statement can have multiple Catch blocks associated with it.

Example:
Consider the below given code segment
Dim num1 As Integer
Dim num2 As Integer
Dim num3 As Integer
Dim str As String
num1 = CType(System.Console.ReadLine( ), Integer)
num2 = CType(System.Console.ReadLine( ), Integer)
str = System.Console.ReadLine( )
Try
num3 = num1 / num2
num1 = CType(str, Integer)
Catch e1 As System.InvalidCastException
System.Console.WriteLine("There is a casting error")
Catch e2 As System.OverflowException
System.Console.WriteLine("There is an overflow error")
Finally
System.Console.Writeline("Please enter valid input")
End Try


Explanation:
The above code segment has been written with an intention of creating an error to explain
the structured way of trapping errors. As shown, it accepts two integers and one string
from the user and tries to divide first number by the second number and also tries to
convert the entered string to an integer. Since the statements that divide the numbers and
perform casting are critical, they are put in the Try…Catch…Finally block structure.
The code segment has two Catch statements viz. first statement handles the casting
(wrong format) error while the second one handles the overflow (division) error.
If the user will enter zero as the second number, then the code will throw an overflow
exception which will be handled by displaying the error message on the Console.
Similarly, if the user will enter a string say "Hello" as the third argument, the code will
throw an invalidcast exception which will be handled by displaying the error message on
the Console. In both the cases, the Finally block of code is always executed. Finally
block is even executed, when there is no error in the program. Thus it is the right place to
perform cleanup routines.
This structured approach provided by VB.NET lets the programmer track the precise
location of the error in the code.
Data Type Changes
Integer
Integer Type VB.NET CLR Type
8-bit Integer Byte System.Byte
16-bit Integer Short System.Int16
32-bit Integer Integer System.Int32
64-bit Integer Long System.Int64
Boolean
A Boolean variable can be assigned one of the two states viz. True or False.
In VB.NET, when numeric types are converted to Boolean values, 0 becomes False and
all other values become True.
When Boolean values are converted to Integer values, True maps to -1 and False maps
to 0.
String
To be inline with other .NET languages, VB.NET has updated string length declaration.
In VB.NET, you cannot declare a string to have a fixed length. You must declare the
string without a length. When a value gets assigned to the string, the length of the value
determines the length of the string.