Coalesce
Differences Between Microsoft Visual
Basic .NET and Microsoft Visual C# .NET
Visual Basic .NET and Visual C# .NET differ in terms of case sensitivity, variable declaration
and assignment, data types, statement termination, statement blocks, use of parentheses
versus brackets, operators, conditional statements, error handling, overflow checking,
parameter passing, late binding, ways of handling unmanaged code, and keywords.
Coalesce
INTRODUCTION
Because of the past differences between Microsoft® Visual Basic™, Microsoft®
Visual C™, and Microsoft® Visual C++™, many developers have the impression
that Microsoft® Visual C# .NET™ is a more powerful language than Microsoft®
Visual Basic .NET™. Some developers assume that many things that are possible
in Visual C# .NET are impossible in Visual Basic .NET, just as many things that
are possible in Microsoft® Visual C™ 6.0 and earlier or Microsoft® Visual C++™
6.0 and earlier are impossible in Microsoft® Visual Basic™ 6.0 and earlier. This
assumption is incorrect. Although differences exist between Visual Basic .NET and
Visual C# .NET, they are both first-class programming languages that are based
on the Microsoft® .NET Framework, and they are equally powerful. Visual Basic
.NET is a true object-oriented programming language that includes new and
improved features such as inheritance, polymorphism, interfaces, and
overloading. Both Visual Basic .NET and Visual C# .NET use the common
language runtime in the .NET Framework, and almost no performance issues now
exist between them. Visual Basic .NET may be oriented more toward ease of use
by providing features such as late binding, and Visual C# .NET may have a few
more “power” features, such as handling unmanaged code, but the differences
are very small compared to what they were in the past.
This document discusses differences between Visual Basic .NET and Visual C#
.NET. However, the key point to keep in mind is that .NET is intended to be
language-independent. The choice between Visual Basic .NET and Visual C# .NET
is typically based on your personal preference and past experience; for example,
it is easier for Visual Basic 6.0 developers to use Visual Basic .NET, and for Visual
C++ and Java programmers to use Visual C# .NET. The existing experience of a
programmer far outweighs the small differences between the two languages.
1
Coalesce
DIFFERENCES BETWEEN VISUAL BASIC .NET AND VISUAL C# .NET
Syntactically, Visual Basic .NET and Visual C# .NET are two different languages,
just as Visual Basic, Visual C, and Visual C++ are different languages. Visual C#
.NET looks more familiar to Visual C, Visual C++, and Java programmers, and
Visual Basic .NET looks more familiar to Visual Basic developers. The biggest
differences between the languages fall into the following categories:
• Case sensitivity
• Variable declaration and assignment
• Data types
• Statement termination
• Statement blocks
• Use of () vs. []
• Operators
• Conditional statements
• Error handling
• Overflow checking
• Parameter passing
• Late binding
• Handling unmanaged code
• Keywords
Case Sensitivity
Identifier names in Visual Basic .NET are not case-sensitive, but identifier names
in Visual C# .NET are. This primarily presents a problem when you write code,
and is not an issue in debugging a program that already compiles.
Variable Declaration and Assignment
Variables in Visual Basic .NET are declared with the variable before the data type.
In Visual C# .NET, the data type precedes the variables.
Visual Basic .NET Visual C# .NET
Dim i, j As Integer int i, j;
Dim i As Integer = 7 int i = 7;
Dim i(6) As Integer int[] i = new int[6];
or
Dim i() As Integer = New Integer(6) {}
Dim con As SqlConnection SqlConnection con;
Dim x As New Y("ABC") Y x = new Y("ABC");
or
Dim x As Y = New Y("ABC")
2
Coalesce
Data Types
Simple data types have different names in Visual Basic .NET and Visual C# .NET. For
example, Integer in Visual Basic .NET is int in Visual C# .NET. However,
System.Int32, the .NET Framework base type for which Integer and int are
aliases, can be used in both languages. Visual C# .NET also supports the signed
byte, unsigned short, unsigned int, and unsigned long data types, which are
not available in Visual Basic .NET.
The following table lists the different data type names in each language and the base
types for which they are aliases.
Visual Basic .NET Visual C# .NET .NET Framework
Boolean bool System.Boolean
Byte byte System.Byte
Short short System.Int16
Integer int System.Int32
Long long System.Int64
Single float System.Single
Double double System.Double
Decimal decimal System.Decimal
Date System.DateTime System.DateTime
String string System.String
Char char System.Char
Object object System.Object
n/a sbyte System.Sbyte
n/a ushort System.UInt16
n/a uint System.UInt32
n/a ulong System.UInt64
Statement Termination
Statements in Visual Basic .NET are terminated by the end of the line. You can use
the colon (:) to put multiple statements in a line, and you can use the line
continuation (_) character to make a statement span several lines.
Statements in Visual C# .NET are terminated by the semicolon (;). You can use
multiple statements per line, and statements can span multiple lines.
3
Coalesce
Visual Basic .NET Visual C# .NET
A = 5 A = 5;
B = 7 : C = 8 B = 7; C = 8;
MySub (Arg1, _ MySub (Arg1,
Arg2, _ Arg2,
Arg3) Arg3);
Statement Blocks
Visual Basic .NET does not use arbitrary statement blocks. Instead, certain
keywords that have a specialized terminating statement are used instead of the
statement blocks.
In Visual C# .NET, braces ({}) are used to delimit a statement block; otherwise, a
single statement is assumed.
Visual Basic .NET Visual C# .NET
If A = 5 Then If (a == 5)
DoSomething() {
DoSomethingAgain() DoSomething();
End If DoSomethingAgain();
}
or
if (a == 5)
DoSomething();
DoSomethingAgain(); //This is not
part of
//the if statement.
Use of () vs. [ ]
Visual Basic .NET uses parentheses () to delimit array elements, function arguments,
and property indexes.
Visual C# .NET uses parentheses () to delimit function arguments, and brackets ([])
to delimit array elements and property indexes.
Purpose Visual Basic .NET Visual C# .NET
Declare an array Dim a() As Long int[] x = new int[5];
Dim a(3, 5) as Integer
Initialize an array Dim a() As Long = {3, 4, int[] x = new int[5] {1,
5} 2, 3, 4, 5};
Reallocate array Redim n/a
Functions Arguments X= A(5) MySub(A, B, C);
MySub (A, B, C)
Property Indexes Y = MyDataSet.Tables_ Y =
("Author").Rows(5)._ MyDataSet.Tables["Author
Columns("AuthorID") "].Rows[5].Columns["Auth
orID"]
4
Coalesce
Operators
The operators that are used in Visual Basic .NET and Visual C# .NET are quite
different. The following table lists the main operators. This information can also be
found in the Microsoft® Visual Studio .NET™ documentation.
Operator Visual Basic .NET Visual C# .NET
Additive
Addition + +
Subtraction - -
Multiplicative
Multiplication * *
Division / /
Integer division \ / (depending on the operands)
Modulus (division returning Mod %
only the remainder)
Exponentiation ^ n/a
Assignment
Assignment = =
+= -= *= /* += -= *= /*
Integer division \= /= (depending on the operands)
Concatenate &= +=
Modulus n/a %=
Left shift n/a <<=
Right shift n/a >>=
Bitwise AND n/a &=
XOR n/a ^=
OR n/a |=
Relational and equality
Less than < <
Less than or equal to <= <=
Greater than > >
Greater than or equal to >= >=
Equal = ==
Not equal <> !=
5
Coalesce
Operator Visual Basic .NET Visual C# .NET
Compare two object Is ==
reference variables
Compare object reference TypeOf x Is Class1 x is Class1
type
Compare strings = == or String.Equals()
Concatenate strings & +
Shortcircuited Boolean AND AndAlso &&
Shortcircuited Boolean OR OrElse ||
Shift
Left shift n/a <<
Right shift n/a >>
Scope resolution
Scope resolution . ., base
Postfix
Type cast Cint, CDbl, …, CType (type)
Member selection . .
Postfix increment n/a --
Postfix decrement n/a --
Unary
Indirection n/a * (unsafe mode only)
Address of AddressOf & (unsafe mode only)
Logical NOT Not !
One's complement Not ~
Prefix increment n/a ++
Prefix decrement n/a --
Size of type n/a sizeof
Bitwise
Bitwise NOT Not ~
Bitwise AND And &
Bitwise XOR Xor ^
Bitwise OR Or |
6
Coalesce
Operator Visual Basic .NET Visual C# .NET
Logical
Logical AND, OR And &&
Logical OR Or ||
Conditional
Conditional IIf ?:
Pointer to member
Pointer to member n/a . (Unsafe mode only)
Conditional Statements
The following table lists the differences in the conditional statements that Visual
Basic .NET and Visual C# .NET use.
Conditional Statement Visual Basic .NET Visual C# .NET
Decision structure (selection) Select Case …, Case, Case switch, case, default,
Else, End Select
Decision structure (if … then) If … Then, ElseIf … Then, if, else
Else, End If
Loop structure (conditional) While… End While, Do do, while, continue
[While, Until] …, Loop
[While, Until]
Loop structure (iteration) For …, [Exit For,] Next for, foreach
For Each …, [Exit For,]
Next
Control flow statement Exit, GoTo, Stop, End, break, continue, goto,
Return, return,
throw
Error Handling
Unstructured error handling is for backward compatibility. Visual Basic .NET supports
both structured and unstructured error handling, but Visual C# .NET supports only
structured error handling.
7
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Structured error handling Try try, catch, finally,
… throw
Catch
…
Finally
…
End Try
Unstructured error handling On Error GoTo … n/a
On Error Resume Next
Overflow Checking
Visual Basic .NET has a project level setting to check for overflow. However, the
checking can only be turned on and off at the project level, instead of at the level of
an expression or a block of code. To turn overflow checking on and off, follow these
steps:
1. On the Project menu, click Properties.
2. Under Configuration Properties, select Optimizations, and then select or
clear Remove integer overflow checks.
Visual C# .NET statements can run in either a checked or an unchecked context. In a
checked context, arithmetic overflow raises an exception error. In an unchecked
context, arithmetic overflow is ignored and the result is truncated. This can be used
on an expression or a block of code.
Parameter Passing
Visual Basic .NET uses ByVal for passing parameters by value, and uses ByRef for
passing parameters by reference. Visual Basic .NET can also force parameters to be
passed by value, regardless of how they are declared, by enclosing the parameters in
extra parentheses. Visual Basic .NET also supports optional parameters, which are
not available in Visual C# .NET.
Visual C# .NET does not have a way to pass reference types (objects) strictly by
value. You can either pass the reference (basically a pointer) or a reference to the
reference (a pointer to a pointer). Unmanaged Visual C# .NET methods can take
pointers just like Visual C++ methods. To pass a parameter by reference, Visual C#
.NET uses the ref keyword. To use a ref parameter, the argument must explicitly be
passed to the method as a ref argument. The value of a ref argument is passed to
the ref parameter.
8
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Pass by value Public Sub ABC (ByVal y void ABC(int x)
As Long) {
… ...
End Sub }
ABC(x) ABC(i);
ABC((x))
Pass by reference Public Sub ABC(ByRef y As void ABC(ref int x)
Long) {
… ...
End Sub }
ABC(x) ABC(ref i);
Optional parameter Supported n/a
Late Binding
Both Visual Basic .NET and Visual C# .NET can implement implicit late binding
through reflection. However, implementing late binding in Visual Basic .NET is much
easier than in Visual C# .NET.
In Visual Basic .NET, as in Visual Basic 6.0, the Visual Basic compiler calls a helper
method behind the scenes that uses reflection to obtain the object type. The
arguments that are passed to the helper method cause the appropriate method to be
invoked at run time. These arguments are the object on which to invoke the method,
the name of the invoked method that is a string, and the arguments that are passed
to the invoked method that is an array of objects. Additionally, you can implement
late binding explicitly in code through reflection.
Imports System
Module Hello
Sub Main()
' Set up variable.
Dim helloObj As Object
' Create the object.
helloObj = new HelloWorld()
' Invoke the print method as if it was early bound
' even though it is really late bound.
helloObj.PrintHello("Visual Basic Late Bound")
End Sub
End Module
In Visual C# .NET, implementing late binding is more difficult than in Visual Basic
.NET. Instead of having the compiler implement late binding, you must explicitly
implement late binding in code by using reflection.
9
Coalesce
Handing Unmanaged Code
Visual C# .NET permits you to write unmanaged code. In unmanaged code, you can
do things such as declare and operate on pointers, perform conversions between
pointers and integral types, and take the address of variables. In a sense, writing
unmanaged code is much like writing Visual C code in a Visual C# .NET program.
Because code that is written by using an unmanaged context cannot be verified to be
safe, it is run only when the code is fully trusted. Do not use unmanaged context to
try to write Visual C code in Visual C# .NET. Unmanaged code must be clearly
marked with the modifier unsafe so that developers cannot use unmanaged features
accidentally, and the execution engine works to make sure that unmanaged code
cannot be run in a non-trusted environment. The scope of the unmanaged context
extends from the parameter list to the end of the function, so pointers can also be
used in the parameter list.
In Visual Basic .NET, you cannot write unmanaged code.
Keywords
The following table lists the keywords that Visual Basic .NET and Visual C# .NET use
in several categories. This information can also be found in the Visual Studio .NET
online documentation.
Purpose Visual Basic .NET Visual C# .NET
Object Oriented
Programming
Indicates a class constructor Public Class Class1 public class Class1
Public Sub New(..) {
MyBase.New public Class1(..)
… {
End Sub …
… }
End Class ….
Note: You have to call the }
base class constructor Note: The call to the base
class constructor (base()) is
explicitly in Visual Basic
generated automatically by
.NET. the compiler in Visual C#
.NET if you do not include
constructor initializers.
Indicates a class destructor Protected Overrides Sub public class Class1
Finalize() {
Note: The Destructor or m_Gadget = Nothing public ~Class1()
m_Gear = Nothing {
Finalize method is called by MyBase.Finalize() ….
garbage collection. End Sub }
}
Declares a class Class class
Indicates class inheritance Public Class A public class A : B
Inherits B {
… …
End Class }
10
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Indicates that the class can MustInherit abstract
only be inherited and cannot
be instantiated
Indicates that the class NotInheritable sealed
cannot be inherited
Calls your own MyClass None
implementation of the
method instead of an
overridden method in the
derived class
Refers to a base class from MyBase base
the derived class
Declares a type-safe Delegate delegate
reference to a class method
Indicates that the method or Overrides override
the property overrides the
implementation in its base
class
Indicates that these methods MustOverride abstract
(in MustInherit (in abstract
have no implementation and class) class)
must be implemented in
derived classes
Indicates that the method or NotOverridable sealed
Note: By default, methods are
the property cannot be not overridable.
overridden in derived classes
Indicates that the method or Overridable virtual
the property can be
overridden in an inheriting
class
Overloads a procedure, a Overloads None. Define functions
with same name but
function, or a method different signatures.
Specifies that a variable can WithEvents No specific keyword
contain an object whose
events you want to handle
Specifies the events for Handles (Event procedures n/a
can still be associated
which an event procedure with a WithEvents variable
will be called by naming pattern.)
11
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Evaluates an object With objExpr n/a
<.member>
expression one time to <.member>
access multiple members End With
Refers to the current object Me This
Declares an enumerated Enum Enum
…
type End Enum
Declares an interface Interface interface
Implements an interface Implements class C1 : I1
Indicates an indexer Default Property public string this[int
index]
{
get {return
List[index];}
set {List[index]=value;}
}
Class Access Modifiers
Indicates that the modifier is Public public
accessible outside the
project or the assembly
Indicates that the modifier is Friend internal
accessible inside the
assembly only
Indicates that the modifier is Private private
accessible only in the project
(for nested classes, in the
enclosing class)
Class Member Access
Modifiers
Indicates that the modifier is Public public
accessible outside the class
and the project
Indicates that the modifier is Friend internal
accessible outside the class,
but in the project
Indicates that the modifier is Private private
only accessible in a class or
a module
Indicates that the modifier is Protected protected
accessible only to current
and derived classes
12
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Indicates the union of Protected Friend protected internal
Protected and Friend or
Internal
Indicates that the members Shared static
are shared across all
instances
Miscellaneous Lifetime
Preserves the local variables Static n/a
for the procedure
Other
Calls the Windows API Declare statement use Platform Invoke
Indicates a comment ‘, Rem //, /* */ for miltine
comments,
/// for XML comments
Indicates a constant Const Const, readonly
Creates a new object New, CreateObject new
Declares a function or a Sub void
method with no return value
Declares that an object can n/a volatile
be modified asynchronously
Declares a variable Private, Public, Friend, declarators (keywords
Protected, Static, Shared, include user-defined types
Dim and built-in types)
Declares a variable explicitly Option Explicit None (All variables must
be declared before use)
Declares and raises an event Event, RaiseEvent event
Declares a structure Structure struct
…
End Structure
Defines a default property Default by using indexers
Declares a null object Nothing null
Declares a namespace Namespace Namespace
… {
End Namespace …
}
Indicates namespace usage Imports using
Retrieves a character from a GetChar Function [ ]
string
13
Coalesce
Purpose Visual Basic .NET Visual C# .NET
Returns the address of a AddressOf (For class delegate
members, this operator
function returns a reference to a
function in the form of a
delegate instance)
Tests for a null object Obj Is Nothing obj == null
Tests for a database null IsDbNull n/a
expression
14
