The Code Project - Complete Comparison for VB.NET and C#

Complete Comparison for

VB.NET and C#

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:

Popularity: 7.49

. 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

●

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

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

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

End

Structure

struct

class

interface

Initialize an object

(constructors)

Sub

New

()

Constructors, or system default type

constructors

Terminate an object

directly

n/a

Method called by the

system just before

garbage collection

reclaims an object7

Finalize

destructor

Initialize a variable

where it is declared

Dim

Long

Dim

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

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

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

End

Enum

enum

Declare a class

constant

Const

const

(Applied to a field

declaration)

Derive a class from

a base class

Inherits

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

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>

End

With

n/a

Structured exception

handling

Try

Catch

Finally

End

Try

try

catch

finally

throw

Decision structure

(selection)

Select

Case

...

Case

Else

End

Select

switch

case

default

goto

break

Decision structure (if

... then)

...

Then

ElseIf

...

Then

Else

End

else

Loop structure

(conditional)

While

[

While

Until

]

...

Loop

[

While

Until

]

while

continue

Loop structure

(iteration)

For

...

[

Exit

For

Next

For

Each

..., [

Exit

For

Next

for

foreach

Declare an array

Dim

a()

Long

int

[] x =

new

int

[

];

Initialize an array

Dim

a()

Long

= {

}

int

[] x =

new

int

[

] {

};

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?

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

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

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

Compare object

reference type

TypeOf

Class1

x is Class1

Concatenate strings

Shortcircuited Boolean

AND

AndAlso

Shortcircuited Boolean

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

Logical-AND

And

Logical-OR

Conditional

Function

()

Pointer to member

n/a

(Unsafe mode only)

Programming Difference

Purpose

VB.NET

Declaring

Variables

Dim

Integer

Public

Integer

int

x =

;

Comments

' comment

x =

' comment

Rem comment

// comment

/* multiline

comment */

Assignment

Statements

nVal =

;

Conditional

Statements

nCnt <= nMax

Then

' Same as nTotal =

' nTotal + nCnt.

nTotal += nCnt

' Same as nCnt = nCnt + 1.

nCnt +=

Else

nTotal += nCnt

nCnt -=

End

(nCnt <= nMax)

{

nTotal += nCnt;

nCnt++;

}

else

{

nTotal +=nCnt;

nCnt--;

}

Selection

Statements

Select

Case

MsgBox (

"Zero"

)

' Visual Basic .NET exits

' the Select at

' the end of a Case.

Case

MsgBox (

"One"

)

Case

MsgBox (

"Two"

)

Case

Else

MsgBox (

"Default"

)

switch

(n)

{

case

Console.WriteLine(

"Zero"

);

break

;

case

Console.WriteLine(

"One"

);

break

;

case

Console.WriteLine(

"Two"

);

break

;

default

End

Select

Console.WriteLine(

"?"

);

break

;

}

FOR Loops

For

n =

MsgBox(

"The number is "

& n)

Next

For

Each

prop

obj

prop =

Next

prop

for

(

int

i =

; i <=

; i++)

Console.WriteLine(

"The number is {0}"

, i);

foreach

(prop current

obj)

{

current=

;

}

Hiding

Base Class

Members

Public

Class

BaseCls

' The element to be shadowed

Public

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

String

"*"

public

Shadows

Sub

Test()

System.Console.WriteLine( _

"Test in DervCls"

)

End

Sub

End

Class

Public

Class

UseClasses

' DervCls widens to BaseCls.

Dim

BObj

BaseCls =

New

DervCls()

' Access through derived

' class.

Dim

DObj

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 +=

End

While

while

(n <

100

)

n++;

Parameter

Passing by

Value

' The argument Y is

'passed by value.

Public

Sub

ABC( _

ByVal

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

{

...

}

// Calling the method:

ABC(i);

Parameter

Passing by

Reference

Public

Sub

ABC(

ByRef

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

{

...

}

// Calling the method:

ABC(

ref

i);

Structured

Exception

Handling

Try

x =

Then

Throw

New

Exception( _

"x equals zero"

)

Else

Throw

New

Exception( _

"x does not equal zero"

)

End

Catch

err

System.Exception

MsgBox( _

"Error: "

& Err.Description)

Finally

MsgBox( _

"Executing finally block."

)

End

Try

// try-catch-finally

try

{

(x ==

)

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

844

)

System.DateTime dt =

new

System.DateTime(

2001

844

);

New Features of both languages in 2005 version

VB.NET

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,

Continue

Statement, which

immediately skips to the next

iteration of a

For

, or

While

loop.

IsNot

operator, which you can

avoid using the

Not

and

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

Control)

Using nf

New

System.Drawing.Font(

"Arial"

.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

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

oNumChar)

Console.WriteLine(num);

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.

Nullable

types allow a variable to

contain a value that is undefined.

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.

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

Click

here

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.

All Topics

.NET

General

Updated: 18 Apr 2005 9:26

CodeProject

, 1999-2005.

Document Outline