Technical Interview Questions
& .Com Interview Question
.Net Web Interview Questions
.Net Interview Questions
Programming Source Codes
Asp VB Script Source Codes
Asp .Net Source Codes
C/C++ Source Codes
C# Source Codes
.Net Interview Questions and Answers
What is the difference between VB and VB.NET?
Now VB.NET is object-oriented language. The following
are some of the differences:
Data Type Changes
The .NET platform provides Common Type System to all the
supported languages. This means that all the languages
must support the same data types as enforced by common
language runtime. This eliminates data type
incompatibilities between various languages. For example
on the 32-bit Windows platform, the integer data type
takes 4 bytes in languages like C++ whereas in VB it
takes 2 bytes. Following are the main changes related to
data types in VB.NET:
. Under .NET the integer data type in VB.NET is also 4
bytes in size.
. VB.NET has no currency data type. Instead it provides
decimal as a replacement.
. VB.NET introduces a new data type called Char. The
char data type takes 2 bytes and can store Unicode
. VB.NET do not have Variant data type. To achieve a
result similar to variant type you can use Object data
type. (Since every thing in .NET including primitive
data types is an object, a variable of object type can
point to any data type).
. In VB.NET there is no concept of fixed length strings.
. In VB6 we used the Type keyword to declare our
user-defined structures. VB.NET introduces the structure
keyword for the same purpose.
Consider this simple example in VB6:
Dim x,y as integer
In this example VB6 will consider x as variant and y as
integer, which is somewhat odd behavior. VB.NET corrects
this problem, creating both x and y as integers.
Furthermore, VB.NET allows you to assign initial values
to the variables in the declaration statement itself:
br> Dim str1 as string = Hello
VB.NET also introduces Read-Only variables. Unlike
constants Read-Only variables can be declared without
initialization but once you assign a value to it, it
cannot be changes.
Dim readonly x as integer
In later code
Now x canít be changed
X=200 *********** Error **********
In VB.NET, we anymore don't have separate declarations
for Get and Set/Let. Now, everything is done in a single
property declaration. This can be better explained by
the following example.
Public [ReadOnly | WriteOnly] Property PropertyName as
M_var = value
Private _message as String
Public Property Message As String
_message = Value
ByVal is the default - This is a crucial difference
betwen VB 6.0 and VB.NET, where the default in VB 6.0
was by reference. But objects are still passed by
Invoking Subroutines In previous versions of VB, only
functions required the use of parentheses around the
parameter list. But in VB.NET all function or subroutine
calls require parentheses around the parameter list.
This also applies, even though the parameter list is
User-Defined Types - VB.NET does away with the keyword
Type and replaces it with the keyword Structure
Public Structure Student
Dim strName as String
Dim strAge as Short
Procedures and Functions
In VB6 all the procedure parameters are passed by
reference (ByRef) by default. In VB.NET they are passed
by value (ByVal) by default. Parantheses are required
for calling procedures and functions whether they accept
any parameters or not. In VB6 functions returned values
using syntax like: FuntionName = return_value. In VB.NET
you can use the Return keyword (Return return_value) to
return values or you can continue to use the older
syntax, which is still valid.
Scoping VB.NET now supports block-level scoping of
variables. If your programs declare all of the variables
at the beginning of the function or subroutine, this
will not be a problem. However, the following VB 6.0
will cause an issue while upgrading to VB .NET
Do While objRs.Eof
Dim J as Integer
If objRs("flag")="Y" then
If J Then
Msgbox "Flag is Y"
In the above example the variable J will become out of
scope just after the loop, since J was declared inside
the While loop.
The most wanted feature in earlier versions of VB was
its error handling mechanism. The older versions relied
on error handlers such as "On Error GoTo and On Error
Resume Next. VB.NET provides us with a more stuructured
approach. The new block structure allows us to track the
exact error at the right time. The new error handling
mechanism is refered to as
Try...Throw...Catch...Finally. The following example
will explain this new feature.
Open "myFile" For Output As #1
Write #1, myOutput
The keyword SET is gone - Since everything in VB.NET is
an object. So the keyword SET is not at all used to
differentiate between a simple variable assignment and
an object assignment. So, if you have the following
statement in VB 6.0
Set ObjConn = Nothing
Should be replaced as
ObjConn = Nothing.
Constructor and Destructor
The constructor procedure is one of the many new
object-oriented features of VB.NET. The constructor in
VB.NET replaces the Class_Initialize in VB 6.0. All
occurance of Class_Initialize in previous versions of VB
should now be placed in a class constructor. In VB.NET,
a constructor is added to a class by adding a procedure
called New. We can also create a class destructor, which
is equivalent to Class_Terminate event in VB 6.0, by
adding a sub-procedure called Finalize to our class.
Usage of Return In VB.NET, we can use the keyword return
to return a value from any function. In previous
versions, we used to assign the value back with the help
of the function name itself. The following example
Public Function Sum (intNum1 as Integer, intNum2 as
Integer) as Integer
Dim intSum as Integer
intSum = intNum1 + intNum2
VB.NET now allows you to create static methods in your
classes. Static methods are methods that can be called
without requiring the developer to create instance of
the class. For example, if you had a class named Foo
with the non-static method NonStatic() and the static
method Static(), you could call the Static() method like
However, non-static methods require than an instance of
the class be created, like so:
Create an instance of the Foo class
Dim objFoo as New Foo()
Execute the NonStatic() method
To create a static method in a VB.NET, simply prefix the
method definition with the keyword Shared.
What is a Strong Name?
A strong name consists of the assembly's identity its
simple text name, version number, and culture
information (if provided) plus a public key and a
digital signature. It is generated from an assembly file
(the file that contains the assembly manifest, which in
turn contains the names and hashes of all the files that
make up the assembly), using the corresponding private
key. Assemblies with the same strong name are expected
to be identical.
Strong names guarantee name uniqueness by relying on
unique key pairs. No one can generate the same assembly
name that you can, because an assembly generated with
one private key has a different name than an assembly
generated with another private key.
When you reference a strong-named assembly, you expect
to get certain benefits, such as versioning and naming
protection. If the strong-named assembly then references
an assembly with a simple name, which does not have
these benefits, you lose the benefits you would derive
from using a strong-named assembly and revert to DLL
conflicts. Therefore, strong-named assemblies can only
reference other strong-named assemblies.
There are two ways to sign an assembly with a strong
1. Using the Assembly Linker (Al.exe) provided by the
.NET Framework SDK.
2. Using assembly attributes to insert the strong name
information in your code. You can use either the
AssemblyKeyFileAttribute or the AssemblyKeyNameAttribute,
depending on where the key file to be used is located.
To create and sign an assembly with a strong name using
the Assembly Linker, at the command prompt, type the
al /out: /keyfile:
In this command, assembly name is the name of the
assembly to sign with a strong name, module name is the
name of the code module used to create the assembly, and
file name is the name of the container or file that
contains the key pair.
The following example signs the assembly MyAssembly.dll
with a strong name using the key file sgKey.snk.
al /out:MyAssembly.dll MyModule.netmodule /keyfile:sgKey.snk
To sign an assembly with a strong name using attributes
In a code module, add the AssemblyKeyFileAttribute or
the AssemblyKeyNameAttribute, specifying the name of the
file or container that contains the key pair to use when
signing the assembly with a strong name. The following
code example uses the AssemblyKeyFileAttribute with a
key file called sgKey.snk.
Page Numbers :