C# to VB.Net

Case sensitive

Not case sensitive

;

[CrLf]

[CrLf]

_

//

'
    Or
                REM

/* ... */

[Unavailable]

"

"

'

'

null

Nothing

[]

GetChar([String], [Index])

"\r\n"

vbCrLf

&

And

&&

AndAlso

|

Or

||

OrElse

==

=

+

+

-

-

*

*

/

/

!=

<>

>

>

<

<

>=

>=

<=

<=

!

Not

%

Mod

++

[Unavailable]

--

[Unavailable]

+=

+=

-=

-=

private

Private

public

Public

protected

Protected

internal

Friend

protected internal

Protected Friend

static

Shared

[Automatic with different signature]

Overloads

sealed (class)

NotInheritable

sealed (method)

NotOverridable

abstract (class)

 MustInherit

abstract (method)

MustOverride

new

Shadows

override

Overrides

virtual

Overridable

readonly

ReadOnly

volatile

[Unavailable]

using [Namespace];

Imports [Namespace]

namespace [name] 
{
    ...
}

Namespace [name]
    ...
End Namespace

[Modifier] class [Name] 
{
    ...
}

[Modifier] Class [Name]
    ...
End Class

:

Inherits

: [Class*], [Interface]

Implements

static

MustInherit NotInheritable

[Modifier] [class name] ([Parameters]) 
{
    ...
}

[Modifier] Sub New ([Parameters])
    ...
End Sub

new [Type]([Parameters]

New [Type]([Parameters])

[Type] [Name];

Dim [Name] As [Type]

[Type] [Name] = [Value];

Dim [Name] As [Type] = [Value]

[Modifier] void [Name]() 
{
    ...
}

[Modifier] Sub [Name]([Parameters])
    ...
End Sub

[Modifier] [Type] [Name]([Parameters]) 
{
    ...
}

[Modifier] Function [Name]() As [Type]
    ...
End Function

[Default]

ByVal

out

ByRef

ref

ByRef

[Unavailable]

Optional

params

ParamArray

this

Me

base

MyClass

base

MyBase

return

Return

[Modifier] [Type] [Name] 
{
    get {...}
    set {...}
}

[Modifier] Property [Name]() As [Type]
    Get
    ...
    End Get

    Set(ByVal Value As [Type])
    ...
    End Set
End Property

[Modifier] [Type] [Name] 
{
    get 
    {
        ...
    }
    set 
    {
        ...
    }
}

[Modifier] ReadOnly Property [Name]() As [Type]
    Get
        ...
    End Get
End Property

[Modifier] [Type] [Name] 
{                    
    get 
    {
        ...
    }
    set 
    {
        ...
    }
}

[Modifier] WriteOnly Property [Name]() As [Type]
    Set(ByVal Value As [Type])
        ...
    End Set            
End Property

[Modifier] [Type] this([Parameters]) 
{
    get 
    {
        ...
    }
    set 
    {
        ...
    }                
}

Default [Modifier] Property [Name]([Parameters]) As [Type]
    Get
        ...
    End Get
    Set(ByVal Value As [Type])
        ...
    End Set
End Property

[Modifier] delegate void [Name] ([parameters]);

[Modifier] Sub Delegate [Name] ([Parameters])

[Modifier] delegate [Return type] [Name] ([parameters]);

[Modifier] Function Delegate [Name] ([Parameters]) 
As Return type]

[Instance].[event]+= new [EventHandler] ( [method] )

[Modifier] WithEvents [field] As [Type] [method] 
Handles [Field].[Event]

[Instance] . [event] += new [EventHandler] ( [method] )

AddHandler [Instance] . [Event], AddressOf [Method]

[Instance] . [event] -= new [EventHandler] ( [method] )

RemoveHandler [Instance] . [event], AddressOf [method]

[Modifier] [Delegate type] event

[Modifier] Event [Delegate type]

[Event]([Parameters])

RaiseEvent [Event name]([Parameters])

//Samples :
int[] t0;
                    
int[4] t1;
                    
int[] t2;
                    
int[] t3 = new int[3];
                    
int[] t4 = {1, 2, 3};
                    
int[] t4 = {1, 2, 3}

'Samples :                 
Dim t0() As Integer
                    
Dim t1(3) As Integer
                    
Dim t2 As Integer()
                    
Dim t3 As Integer() = New Integer(2) {} 'Array with 3 items
                    
Dim t4 As Integer() = New Integer() {1, 2, 3}
                    
Dim t5 As Integer() = New Integer(2) {1, 2, 3}

[]

()

[Unavailable]

ReDim

[Modifier] enum [Name] 
{
    ...
}

[Modifier] Enum [Name]
    ...
End Enum

[Modifier] struct [Name] 
{
    ...
}

[Modifier] Structure [Name]
    ...
End Structure

[Modifier] interface [Name] 
{
    ...
}

[Modifier] Interface [Name]
    ...
End Interface

([Type name]) / as

CType, CBool, CByte, CChar, CDate, CDbl, 
CDec, CInt, CLng, CObj, CShort, CSng, CStr

typeof ( [Type name] )

GetType ( [Type name] )

is

TypeOf ([Instance]) Is [Type]

[Modifier] const [Type ][Name] = [Value]

[Modifier] Const [Name] As [Type] = [Value]

if ([Bool expression]) 
{
    ...
}

If [Bool expression]
    ...
End If

for( int I = [i]; I < [ii + 1]; i+=[iii]) 
{
    ...
}

For i = [i] To [ii] Step [iii]
    ...
Next i

foreach ([Type] [Name] in [Collection Instance]) 
{
    ...
}

For Each [Name] As [Type] In [Collection instance]
    ...
Next

//Samples:
switch (Welcome) 
{
    case "Hello" :
        return "Hello";
    case "Hi" :
        break;
    case "Goodbye" :   
    default :
        return "Goodbye";
}

'Samples:
Select Case counter
    Case 1 ' counter egals 1.
        Return counter * 0.1
    Case 2, 3 ' counter equals 2 ou 3.
        Return counter * 0.09
    Case 5 To 7 ' counter equals 5, 6, ou 7.
        Return counter * 0.07
    Case 4, 8 To 10 ' counter equals 4, 8, 9, ou 10.
        Return counter * 0.05
    Case Is < 15 ' counter equals 0, 11, 12, 13, ou 14.
        Return 100
    Case Else
        Return 0
End Select

while ( [Bool expression] ) 
{
    ...
}

While [Bool expression ]
    ...
End While

try 
{
    ...
} 
catch ([Exception type] [Name]) 
{
    ...
} 
finally 
{
    ...
}

Try
    ...
Catch [Name] As [Exception type]
    ...
Finally
    ...
End Try

throw new [Exception type]([Parameters])

Throw New [Exception type]([Parameters])

[Unavailable]

Option Strict Off

[ [Name] ([Parameters]) ]

< [Name] ( [Parameters] ) > _

public static [Result type ] operator [symbol] 
( [parameters] )
{
    ...
}

Public Shared Operator [symbol] ( [parameters] ) 
As [Result type]
    ...
End Operator

public static [implicit or explicit] 
operator [Result type] ( [Original type )
{
    ...
}

Public Shared [Narrowing | Widening] Operator 
CType(ByVal Param1 As [Type1]) As [Result type]
    ...
End Operator

extern
DllImport

Declare
DllImport

[Unavailable]

With [Instance]
...
End With

lock ([Instance]) 
{
    ...
}

SyncLock [Instance]
    ...
End SyncLock

<struct>?
Ex: int?

Nullable(Of <struct>)
Ex: Nullable(Of Integer)