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 = 2
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, foreach |
| Declare an array |
 Collapse | Copy CodeDim a() As Long
|
Collapse | Copy Codeint[] x = new int[5];
|
| Initialize an array |
Collapse | Copy CodeDim a() As Long = {3, 4, 5}
|
Collapse | Copy Codeint[] 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 | Collapse | Copy CodeDim x As Integer
Public x As Integer = 10
|
Collapse | Copy Codeint x;
int x = 10;
|
| Comments | Collapse | Copy Code' comment
x = 1 ' comment
Rem comment
|
Collapse | Copy Code// comment
/* multiline
comment */
|
| Assignment Statements | Collapse | Copy CodenVal = 7
|
Collapse | Copy CodenVal = 7;
|
| Conditional Statements | Collapse | Copy CodeIf nCnt <= nMax Then
' Same as nTotal =
' nTotal + nCnt.
nTotal += nCnt
' Same as nCnt = nCnt + 1.
nCnt += 1
Else
nTotal += nCnt
nCnt -= 1
End If
|
Collapse | Copy Codeif (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
{
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,
|
With the release of Visual Studio 2005, the C# language has been
updated to version 2.0. This language has following new features:
|
No comments:
Post a Comment