Murray Gordon

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.

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

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

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)

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")

End Select

switch(n)

{

   case 0:

      Console.WriteLine("Zero");

      break;

   case 1:

      Console.WriteLine("One");

      break;

   case 2:

      Console.WriteLine("Two");

      break;

   default:

      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 "&_

    "class: " & DObj.Z)

    BObj.Test()

    DObj.Test()

  End Sub

End Class

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}",

      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