>>
http://www.codeproject.com/dotnet/vbnet_c__difference.asp
Complete Comparison for
VB.NET and C#
By
Amalorpavanathan Yagulasamy(AMAL)
This article explains about advantages, differences and new
features of VB.NET and C#.
C#, VB.NET
Windows, .NET
Win32, VS (VS.NET2003),
WinForms, WebForms
CEO, Arch, DB, Dev, QA
Posted 30 Mar 2005 14:53
Updated 18 Apr 2005 9:26
22,120 views
47 members have rated this article. Result:
. Rating: 4.48 out of 5.
Contents
1. Introduction
2. Advantages of both languages
3. Keyword Differences
4. Data types Differences
5. Operators Differences
6. Programming Difference
7. New Features of both languages in 2005 version
8. Conclusion
9. History
Introduction
Some people like VB.NET's natural language, case-insensitive approach, others like
C#'s terse syntax. But both have access to the same framework libraries. We will
discuss about the differences in the following topics:
1. Advantages of both languages
2. Keyword Differences
3. Data types Differences
4. Operators Differences
5. Programming Difference
Advantages of both languages
VB.NET
C#
●
Support for optional parameters - very
handy for some COM interoperability.
●
Support for late binding with Option
Strict off - type safety at compile time
goes out of the window, but legacy
libraries which don't have strongly typed
interfaces become easier to use.
●
Support for named indexers.
●
Various legacy VB functions (provided in
the
Microsoft.VisualBasic
namespace, and can be used by other
languages with a reference to the
Microsoft.VisualBasic.dll). Many of these
can be harmful to performance if used
unwisely, however, and many people
believe they should be avoided for the
most part.
●
The
with
construct: it's a matter of
debate as to whether this is an
advantage or not, but it's certainly a
difference.
●
Simpler (in expression - perhaps more
complicated in understanding) event
handling, where a method can declare
that it handles an event, rather than the
handler having to be set up in code.
●
The ability to implement interfaces with
methods of different names. (Arguably
this makes it harder to find the
implementation of an interface,
however.)
●
Catch
...
When
... clauses, which allow
exceptions to be filtered based on
runtime expressions rather than just by
type.
●
The VB.NET parts of Visual Studio .NET
compiles your code in the background.
While this is considered as an advantage
for small projects, people creating very
large projects have found that the IDE
slows down considerably as the project
gets larger.
●
XML documentation generated
from source code comments. (This
is coming in VB.NET with Whidbey
(the code name for the next
version of Visual Studio and .NET),
and there are tools which will do it
with existing VB.NET code
already.)
●
Operator overloading - again,
coming to VB.NET in Whidbey.
●
Language support for unsigned
types (you can use them from
VB.NET, but they aren't in the
language itself). Again, support for
these is coming to VB.NET in
Whidbey.
●
The
using
statement, which
makes unmanaged resource
disposal simple.
●
Explicit interface implementation,
where an interface which is
already implemented in a base
class can be re-implemented
separately in a derived class.
Arguably this makes the class
harder to understand, in the same
way that member hiding normally
does.
●
Unsafe code. This allows pointer
arithmetic etc, and can improve
performance in some situations.
However, it is not to be used
lightly, as a lot of the normal
safety of C# is lost (as the name
implies). Note that unsafe code is
still managed code, i.e., it is
compiled to IL, JITted, and run
within the CLR.
Keyword Differences
Purpose
VB.NET
C#
Declare a variable
Private
,
Public
,
Friend
,
Protected
,
Static1
,
Shared
,
Dim
declarators
(keywords include
user-defined types and built-in
types)
Declare a named
constant
Const
const
Create a new object
New
,
CreateObject()
new
Function/method
does not return a
value
Sub
void
Overload a function
or method (Visual
Basic: overload a
procedure or
method)
Overloads
(No language keyword required for
this purpose)
Refer to the current
object
Me
this
Make a nonvirtual
call to a virtual
method of the
current object
MyClass
n/a
Retrieve character
from a string
GetChar
Function
[]
Declare a compound
data type (Visual
Basic: Structure)
Structure
<members>
End
Structure
struct
,
class
,
interface
Initialize an object
(constructors)
Sub
New
()
Constructors, or system default type
constructors
Terminate an object
directly
n/a
n/a
Method called by the
system just before
garbage collection
reclaims an object7
Finalize
destructor
Initialize a variable
where it is declared
Dim
x
As
Long
=
5
Dim
c
As
New
_
Car(FuelTypeEnum.Gas)
// initialize to a value:
int
x =
123
;
// or use default
// constructor:
int
x =
new
int
();
Take the address of
a function
AddressOf
(For class
members, this operator
returns a reference to a
function in the form of a
delegate instance)
delegate
Declare that an
object can be
modified
asynchronously
n/a
volatile
Force explicit
declaration of
variables
Option
Explicit
n/a. (All variables must be declared
prior to use)
Test for an object
variable that does
not refer to an
object
obj =
Nothing
obj ==
null
Value of an object
variable that does
not refer to an
object
Nothing
null
Test for a database
null expression
IsDbNull
n/a
Test whether a
Variant variable has
been initialized
n/a
n/a
Define a default
property
Default
by using indexers
Refer to a base class
MyBase
base
Declare an interface
Interface
interface
Specify an interface
to be implemented
Implements
(statement)
class
C1 : I1
Declare a class
Class
<implementation>
class
Specify that a class
can only be
inherited. An
instance of the class
cannot be created.
MustInherit
abstract
Specify that a class
cannot be inherited
NotInheritable
sealed
Declare an
enumerated type
Enum
<members>
End
Enum
enum
Declare a class
constant
Const
const
(Applied to a field
declaration)
Derive a class from
a base class
Inherits
C2
class
C1 : C2
Override a method
Overrides
override
Declare a method
that must be
implemented in a
deriving class
MustOverride
abstract
Declare a method
that can't be
overridden
NotOverridable
(Methods
are not
overridable
by
default.)
sealed
Declare a virtual
method, property
(Visual Basic), or
property accessor
(C#, C++)
Overridable
virtual
Hide a base class
member in a derived
class
Shadowing
n/a
Declare a typesafe
reference to a class
method
Delegate
delegate
Specify that a
variable can contain
an object whose
events you wish to
handle
WithEvents
(Write code - no specific keyword)
Specify the events
for which an event
procedure will be
called
Handles
(Event procedures
can still be associated with a
WithEvents
variable by
naming pattern.)
n/a
Evaluate an object
expression once, in
order to access
multiple members
With
objExpr
<.member>
<.member>
End
With
n/a
Structured exception
handling
Try
<attempt>
Catch
<handle errors>
Finally
<always execute>
End
Try
try
,
catch
,
finally
,
throw
Decision structure
(selection)
Select
Case
...
,
Case
,
Case
Else
,
End
Select
switch
,
case
,
default
,
goto
,
break
Decision structure (if
... then)
If
...
Then
,
ElseIf
...
Then
,
Else
,
End
If
if
,
else
Loop structure
(conditional)
While
,
Do
[
While
,
Until
]
...
,
Loop
[
While
,
Until
]
do
,
while
,
continue
Loop structure
(iteration)
For
...
,
[
Exit
For
],
Next
For
Each
..., [
Exit
For
,]
Next
for
,
foreach
Declare an array
Dim
a()
As
Long
int
[] x =
new
int
[
5
];
Initialize an array
Dim
a()
As
Long
= {
3
,
4
,
5
}
int
[] x =
new
int
[
5
] {
1
,
2
,
3
,
4
,
5
};
Reallocate array
Redim
n/a
Visible outside the
project or assembly
Public
public
Invisible outside the
assembly (C#/Visual
Basic) or within the
package (Visual J#,
JScript)
Friend
internal
Visible only within
the project (for
nested classes,
within the enclosing
class)
Private
private
Accessible outside
class and project or
module
Public
public
Accessible outside
the class, but within
the project
Friend
internal
Only accessible
within class or
module
Private
private
Only accessible to
current and derived
classes
Protected
protected
Preserve procedure's
local variables
Static
n/a
Shared by all
instances of a class
Shared
static
Comment code
'
Rem
//, /* */
for multi-line comments
///
for XML comments
Case-sensitive?
No
Yes
Call Windows API
Declare
<API>
use Platform Invoke
Declare and raise an
event
Event
,
RaiseEvent
event
Threading primitives
SyncLock
lock
Go to
Goto
goto
Data types Differences
Purpose/Size
VB.NET
C#
Decimal
Decimal
decimal
Date
Date
DateTime
(varies)
String
string
1 byte
Byte
byte
2 bytes
Boolean
bool
2 bytes
Short
,
Char
(
Unicode
character)
short
,
char (
Unicode
character)
4 bytes
Integer
int
8 bytes
Long
long
4 bytes
Single
float
8 bytes
Double
double
Operators Differences
Purpose
VB.NET
C#
Integer division
\
/
Modulus (division
returning only the
remainder)
Mod
%
Exponentiation
^
n/a
Integer division
Assignment
\=
/=
Concatenate
&= NEW
+=
Modulus
n/a
%=
Bitwise-AND
n/a
&=
Bitwise-exclusive-OR
n/a
^=
Bitwise-inclusive-OR
n/a
|=
Equal
=
==
Not equal
<>
!=
Compare two object
reference variables
Is
==
Compare object
reference type
TypeOf
x
Is
Class1
x is Class1
Concatenate strings
&
+
Shortcircuited Boolean
AND
AndAlso
&&
Shortcircuited Boolean
OR
OrElse
||
Scope resolution
.
.
and
base
Array element
()
[ ]
Type cast
Cint
,
CDbl
, ...,
CType
(type)
Postfix increment
n/a
++
Postfix decrement
n/a
--
Indirection
n/a
*
(unsafe mode only)
Address of
AddressOf
&
(unsafe mode only; also see
fixed)
Logical-NOT
Not
!
One's complement
Not
~
Prefix increment
n/a
++
Prefix decrement
n/a
--
Size of type
n/a
sizeof
Bitwise-AND
And
&
Bitwise-exclusive-OR
Xor
^
Bitwise-inclusive-OR
Or
|
Logical-AND
And
&&
Logical-OR
Or
||
Conditional
If
Function
()
?:
Pointer to member
n/a
.
(Unsafe mode only)
Programming Difference
Purpose
VB.NET
C#
Declaring
Variables
Dim
x
As
Integer
Public
x
As
Integer
=
10
int
x;
int
x =
10
;
Comments
' comment
x =
1
' comment
Rem comment
// comment
/* multiline
comment */
Assignment
Statements
nVal =
7
nVal =
7
;
Conditional
Statements
If
nCnt <= nMax
Then
' Same as nTotal =
' nTotal + nCnt.
nTotal += nCnt
' Same as nCnt = nCnt + 1.
nCnt +=
1
Else
nTotal += nCnt
nCnt -=
1
End
If
if
(nCnt <= nMax)
{
nTotal += nCnt;
nCnt++;
}
else
{
nTotal +=nCnt;
nCnt--;
}
Selection
Statements
Select
Case
n
Case
0
MsgBox (
"Zero"
)
' Visual Basic .NET exits
' the Select at
' the end of a Case.
Case
1
MsgBox (
"One"
)
Case
2
MsgBox (
"Two"
)
Case
Else
MsgBox (
"Default"
)
switch
(n)
{
case
0
:
Console.WriteLine(
"Zero"
);
break
;
case
1
:
Console.WriteLine(
"One"
);
break
;
case
2
:
Console.WriteLine(
"Two"
);
break
;
default
:
End
Select
Console.WriteLine(
"?"
);
break
;
}
FOR Loops
For
n =
1
To
10
MsgBox(
"The number is "
& n)
Next
For
Each
prop
In
obj
prop =
42
Next
prop
for
(
int
i =
1
; i <=
10
; i++)
Console.WriteLine(
"The number is {0}"
, i);
foreach
(prop current
in
obj)
{
current=
42
;
}
Hiding
Base Class
Members
Public
Class
BaseCls
' The element to be shadowed
Public
Z
As
Integer
=
100
public
Sub
Test()
System.Console.WriteLine( _
"Test in BaseCls"
)
End
Sub
End
Class
Public
Class
DervCls
Inherits
BaseCls
' The shadowing element.
Public
Shadows
Z
As
String
=
"*"
public
Shadows
Sub
Test()
System.Console.WriteLine( _
"Test in DervCls"
)
End
Sub
End
Class
Public
Class
UseClasses
' DervCls widens to BaseCls.
Dim
BObj
As
BaseCls =
New
DervCls()
' Access through derived
' class.
Dim
DObj
As
DervCls =
New
DervCls()
Public
Sub
ShowZ()
System.Console.WriteLine( _
"Accessed through base "
&_
"class: "
& BObj.Z)
System.Console.WriteLine(_
"Accessed through derived "
&_
public
class
BaseCls
{
// The element to be hidden
public
int
Z =
100
;
public
void
Test()
{
System.Console.WriteLine(
"Test in BaseCls"
);
}
}
public
class
DervCls : BaseCls
{
// The hiding element
public
new
string
Z =
"*"
;
public
new
void
Test()
{
System.Console.WriteLine(
"Test in DervCls"
);
}
}
public
class
UseClasses
{
// DervCls widens to BaseCls
BaseCls BObj =
new
DervCls();
// Access through derived
//class
DervCls DObj =
new
DervCls();
public
void
ShowZ()
{
System.Console.WriteLine(
"Accessed through "
+
"base class: {0}"
,
"class: "
& DObj.Z)
BObj.Test()
DObj.Test()
End
Sub
End
Class
BObj.Z);
System.Console.WriteLine(
"Accessed through"
+
" derived class:{0}"
,
DObj.Z);
BObj.Test();
DObj.Test();
}
}
WHILE
Loops
' Test at start of loop
While
n <
100
.
' Same as n = n + 1.
n +=
1
End
While
'
while
(n <
100
)
n++;
Parameter
Passing by
Value
' The argument Y is
'passed by value.
Public
Sub
ABC( _
ByVal
y
As
Long
)
'If ABC changes y, the
' changes do not affect x.
End
Sub
ABC(x)
' Call the procedure.
' You can force parameters to
' be passed by value,
' regardless of how
' they are declared,
' by enclosing
' the parameters in
' extra parentheses.
ABC((x))
/* Note that there is
no way to pass reference
types (objects) strictly
by value. You can choose
to either pass the reference
(essentially a pointer), or
a reference to the reference
(a pointer to a pointer).*/
// The method:
void
ABC(
int
x)
{
...
}
// Calling the method:
ABC(i);
Parameter
Passing by
Reference
Public
Sub
ABC(
ByRef
y
As
Long
)
' The parameter y is declared
'by referece:
' If ABC changes y, the changes are
' made to the value of x.
End
Sub
ABC(x)
' Call the procedure.
/* Note that there is no
way to pass reference types
(objects) strictly by value.
You can choose to either
pass the reference
(essentially a pointer),
or a reference to the
reference (a pointer to a
pointer).*/
// Note also that unsafe C#
//methods can take pointers
//just like C++ methods. For
//details, see unsafe.
// The method:
void
ABC(
ref
int
x)
{
...
}
// Calling the method:
ABC(
ref
i);
Structured
Exception
Handling
Try
If
x =
0
Then
Throw
New
Exception( _
"x equals zero"
)
Else
Throw
New
Exception( _
"x does not equal zero"
)
End
If
Catch
err
As
System.Exception
MsgBox( _
"Error: "
& Err.Description)
Finally
MsgBox( _
"Executing finally block."
)
End
Try
// try-catch-finally
try
{
if
(x ==
0
)
throw
new
System.Exception(
"x equals zero"
);
else
throw
new
System.Exception(
"x does not equal zero"
);
}
catch
(System.Exception err)
{
System.Console.WriteLine(
err.Message);
}
finally
{
System.Console.WriteLine(
"executing finally block"
);
}
Set an
Object
Reference
to Nothing
o =
Nothing
o =
null
;
Initializing
Value
Types
Dim
dt as
New
System.DateTime( _
2001
,
4
,
12
,
22
,
16
,
49
,
844
)
System.DateTime dt =
new
System.DateTime(
2001
,
4
,
12
,
22
,
16
,
49
,
844
);
New Features of both languages in 2005 version
VB.NET
C#
Visual Basic 2005 has many new and
improved language features -- such as
inheritance, interfaces, overriding,
shared members, and overloading -- that
make it a powerful object-oriented
programming language. As a Visual Basic
developer, you can now create
multithreaded, scalable applications using
explicit multithreading. This language has
following new features,
1.
Continue
Statement, which
immediately skips to the next
iteration of a
Do
,
For
, or
While
loop.
2.
IsNot
operator, which you can
avoid using the
Not
and
Is
operators in an awkward order.
3. 3.
Using...
End
.
Using
statement
block ensures disposal of a system
resource when your code leaves the
block for any reason.
Public
Sub
setbigbold( _
ByVal
c
As
Control)
Using nf
As
New
_
System.Drawing.Font(
"Arial"
,_
12
.0F, FontStyle.Bold)
c.Font = nf
c.Text =
"This is"
&_
With the release of Visual Studio 2005, the
C# language has been updated to version
2.0. This language has following new
features:
1. Generics types are added to the
language to enable programmers to
achieve a high level of code reuse and
enhanced performance for collection
classes. Generic types can differ only
by arity. Parameters can also be forced
to be specific types.
2. Iterators make it easier to dictate
how a for each loop will iterate over a
collection's contents.
// Iterator Example
public
class
NumChar
{
string
[] saNum = {
"One"
,
"Two"
,
"Three"
,
"Four"
,
"Five"
,
"Six"
,
"Seven"
,
"Eight"
,
"Nine"
,
"Zero"
};
public
System.Collections.IEnumerator
GetEnumerator()
{
foreach
(
string
num
in
saNum)
yield
return
num;
}
"12-point Arial bold"
End
Using
End
Sub
4. Explicit Zero Lower Bound on an
Array, Visual Basic now permits an
array declaration to specify the
lower bound (0) of each dimension
along with the upper bound.
5. Unsigned Types, Visual Basic now
supports unsigned integer data
types (
UShort
,
UInteger
, and
ULong
) as well as the signed type
SByte
.
6. Operator Overloading, Visual
Basic now allows you to define a
standard operator (such as
+
,
&
,
Not
, or
Mod
) on a class or structure
you have defined.
7. Partial Types, to separate
generated code from your authored
code into separate source files.
8. Visual Basic now supports type
parameters on generic classes,
structures, interfaces, procedures,
and delegates. A corresponding
type argument specifies at
compilation time the data type of
one of the elements in the generic
type.
9. Custom Events. You can declare
custom events by using the Custom
keyword as a modifier for the
Event
statement. In a custom event, you
specify exactly what happens when
code adds or removes an event
handler to or from the event, or
when code raises the event.
10. Compiler Checking Options, The
/nowarn and /warnaserror options
provide more control over how
warnings are handled. Each one of
these compiler options now takes a
list of warning IDs as an optional
}
// Create an instance of
// the collection class
NumChar oNumChar =
new
NumChar();
// Iterate through it with foreach
foreach
(
string
num
in
oNumChar)
Console.WriteLine(num);
3.
Partial
type definitions allow a single
type, such as a class, to be split into
multiple files. The Visual Studio
designer uses this feature to separate
its generated code from user code.
4.
Nullable
types allow a variable to
contain a value that is undefined.
5.
Anonymous
Method is now possible to
pass a block of code as a parameter.
Anywhere a delegate is expected, a
code block can be used instead: There
is no need to define a new method.
button1.Click +=
delegate
{ MessageBox.Show(
"Click!"
) };
6. . The namespace alias qualifier (
::
)
provides more control over accessing
namespace members. The global
::
alias allows to access the root
namespace that may be hidden by an
entity in your code.
7.
Static
classes are a safe and
convenient way of declaring a class
containing static methods that cannot
be instantiated. In C# v1.2 you would
have defined the class constructor as
private to prevent the class being
instantiated.
8. 8. There are eight new compiler
options:
a. /langversion option: Can be
used to specify compatibility with
a specific version of the language.
parameter, to specify to which
warnings the option applies.
11. There are eight new command-line
compiler options:
a. The /codepage option
specifies which codepage to
use when opening source files.
b. The /doc option generates an
XML documentation file based
on comments within your
code.
c. The /errorreport option
provides a convenient way to
report a Visual Basic internal
compiler error to Microsoft.
d. The /filealign option specifies
the size of sections in your
output file.
e. The /noconfig option causes
the compiler to ignore the
Vbc.rsp file.
f. The /nostdlib option prevents
the import of mscorlib.dll,
which defines the entire
System namespace.
g. The /platform option
specifies the processor to be
targeted by the output file, in
those situations where it is
necessary to explicitly specify
it.
h. The /unify option suppresses
warnings resulting from a
mismatch between the
versions of directly and
indirectly referenced
assemblies.
b. /platform option: Enables you to
target IPF (IA64 or Itanium) and
AMD64 architectures.
c. #pragma warning: Used to
disable and enable individual
warnings in code.
d. /linkresource option: Contains
additional options.
e. /errorreport option: Can be
used to report internal compiler
errors to Microsoft over the
Internet.
f. /keycontainer and /keyfile:
Support specifying cryptographic
keys.
Conclusion
I think that this article will help you understand both language features and also you
can choose a language based on your taste. I will update this article in future if there
are any changes.
History
●
14 Apr 2005 - Topic added - "New features of both languages in 2005 version"
●
30 Mar 2005 - Initial version.
About Amalorpavanathan Yagulasamy(AMAL)
Amalorpavanathan Yagulasamy (AMAL) is a Software Engineer for Protech Solution Inc.
and has designed and implemented projects for Arkansas Child Support, Arkansas
Budgetting, Michigan Child Support , Massachusetts Child Support, National Informatics
Center-India and Indian Oil Corporation. His background is in developing relational
databases and n-tier applications on Windows platforms in CMM Level Standards. He can
be reached at amal_forum@hotmail.com
to view Amalorpavanathan Yagulasamy(AMAL)'s online profile.
Discussions and Feedback
53 comments have been posted for this article. Visit
http://www.codeproject.com/dotnet/vbnet_c__difference.asp
post and view comments on this article.
Updated: 18 Apr 2005 9:26
Article content copyright Amalorpavanathan Yagulasamy(AMAL), 2005
, 1999-2005.