Comparison of C Sharp and Visual Basic .

NET
From Wikipedia, the free encyclopedia

C# and Visual Basic are the two primary languages used to program on the .NET Framework.

Language history
C# and VB.NET are syntactically very different languages with very different history. As the
name suggests, the C# syntax is based on the core C language originally developed by Bell Labs
(AT&T) in the 1970s [1] and eventually evolved into the fully object oriented C++ language still
in use today. Much of the Java syntax is also based on this same C++ language,[2] which is one of
the reasons the two share a common look and feel. See Comparison of Java and C Sharp for
more on this topic.

VB.NET has its roots in the BASIC language of the '60s with its name being an acronym for
"Beginner's All-purpose Symbolic Instruction Code". In its beginning, BASIC was used in the
college community as a "basic" language for first exposure to computer programming and the
acronym represented the language accurately.[3] In the '70s, the language was picked up by
microcomputer manufacturers of the era to be used as both a simple ROM embedded
programming language as well as a quasi operating system for input/output control.[4] In the early
'80s, the language was picked up by Microsoft and expanded significantly beyond its original
intent into their "Visual Basic" language/platform that was sold throughout the 1990s as a "rapid
application development" (RAD) tool for Windows programming.[5] It competed directly against
other RAD tools of the 1990s such as PowerBuilder.[6] Even though Visual Basic was a
successful development platform, it was discontinued after its 6th version (VB6) when Microsoft
introduced the .NET Framework and its related Visual Studio development platform in the early
2000s.

Language comparison
Though C# and VB.NET are syntactically very different, that is where the differences mostly
end. Microsoft developed both of these languages to be part of the same .NET Framework
development platform. They are both developed, managed, and supported by the same language
development team at Microsoft.[7] They compile to the same intermediate language (IL), which
runs against the same .NET Framework runtime libraries.[8] Although there are some differences
in the programming constructs (discussed further below), their differences are primarily syntactic
and, assuming one avoids the Visual Basic "Compatibility" libraries provided by Microsoft to aid
conversion from VB6, almost every command in VB has an equivalent command in C# and vice
versa. Lastly, both languages reference the same Base Classes of the .NET Framework to extend
their functionality. As a result, with few exceptions, a program written in either language can be
run through a simple syntax converter to translate to the other. There are many open source and
commercially available products for this purpose.
Runtime multi-language support
One of the main goals of .NET has been its multi-language support. The intent of the design was
that all of the various Microsoft languages should have the same level of access to all OS
features, should be able to expose the same level of power and usability, and simplify calling
from a module in one language to that written in another language.

In implementation, all .NET programming languages share the same runtime engine, uniform
Abstract syntax tree, and Common Intermediate Language. Additionally all .NET languages
have access to platform features including garbage collection, cross language inheritance,
exception handling, and debugging. This allows the same output binary to be produced from
any .NET programming language.

Development environment
Visual Studio provides minor differences in the development environment for C# and VB.Net.
With each subsequent release of Visual Studio, the differences between development
environments for these languages have been reduced. For instance early versions of Visual
Studio had poor support for Intellisense in C# compared to Visual Basic .NET, and did not offer
background compilation for C#.[9] Currently, the main differences in the development
environments are additional features for Visual Basic .NET that originated in VB6, including:

 The default namespace is hidden (but can be disabled)

 Certain project files are hidden (the user can show them)
 The auto-generated My.* namespaces contain many commonly-used shortcuts brought
over from VB6, such as methods for operating on the registry and application
configuration file

Background compilation is a feature of the Visual Studio IDE whereby code is compiled as it is
written by the programmer with the purpose of identifying compilation errors without requiring
the solution to be built. This feature has been available for Visual Basic since .NET 1.1 and was
present in early versions of Visual Studio for Visual Basic .NET. However, background
compilation is a relatively new concept for Visual C# and is available with service pack 1 for
Visual Studio 2008 Standard Edition and above. A distinct disadvantage for C# is that the Error
List panel does not update until the solution is rebuilt. Refactoring large projects in C# is made
more difficult by the need to frequently rebuild the solution in order to highlight compilation
errors.[10] Such is not the case with Visual Basic because the Error List panel is synchronised with
the background compiler.

Background Compilation is less demanding on system resources and results in faster build
cycles.[10] This is a particular advantage with large projects and can significantly reduce the time
required to start debugging in the IDE.[10]
Language features
The bulk of the differences between C# and VB.NET from a technical perspective are syntactic
sugar. That is, most of the features are in both languages, but some things are easier to do in one
language than another. Many of the differences between the two languages are actually centered
around the IDE.

Features of Visual Basic .NET not found in C#

 Variables can be declared using the WithEvents construct. This construct is available so
that a programmer may select an object from the Class Name drop down list and then
select a method from the Declarations drop down list to have the Method signature
automatically inserted
 Auto-wireup of events, VB.NET has the Handles syntax for events
 Marshalling an object for multiple actions using an unqualified dot reference. This is
done using the With ... End With structure
 IsNumeric evaluates whether a string can be cast into a numeric value (the equivalent for
C# requires using int.TryParse)
 XML Literals[11]
 Inline date declarations by using #1/1/2000# syntax (M/dd/yyyy).
 Module (although C#'s sealed static classes with additional semantics, but each field has
to individually be declared as static)
 Members of Modules imported to the current file, can be access with no preceding
container accessor (See Now for example)
 The My namespace
 COM components and interoperability was more powerful in VB.NET as the Object type
is bound at runtime,[12] however C#4.0 added the dynamic type which functions as a late
bound form of Object.
 Namespaces can be imported in project level, so they don't have to be imported to each
individual file, like C#
 In-line exceptions filtering by a Boolean expression, using "When expression" blocks.[13]
It can be achieved in C# using a catch block followed by if block.
 With instruction Executes a series of instructions repeatedly refer to a single object or
structure.

Features of C# not found in Visual Basic .NET

 Allows blocks of unsafe code (like C++/CLI) via the unsafe keyword
 Partial Interfaces
 Multi-line comments (note that the Visual Studio IDE supports multi-line commenting
for Visual Basic .NET)
 Static classes (Classes which cannot contain any non-static members, although VB's
Modules are essentially sealed static classes with additional semantics)
 Can use checked and unchecked contexts for fine-grained control of overflow/underflow
checking
Other characteristics of Visual Basic .NET not applicable to C#

 Conversion of Boolean value True to Integer may yield -1 or 1 depending on the

conversion used
 Assigning and comparing variables uses the same token, =. Whereas C# has separate
tokens, == for comparison and = to assign a value
 VB.NET is not case-sensitive.
 Type checking is less strict by default. If the default is left in place, It will auto convert
type without notifying programmer, for example:

Dim i As Integer = "1" 'Compiler automatically converts String to Integer

Dim j As String = 1 'Compiler automatically converts Integer to String
If i = j Then 'Compiler does cast and compare between i and j
MessageBox.Show("Avoid using, but this message will appear!")
End If

It should be noted that although the default is for 'Option Strict' is off, it is recommended by
Microsoft[14] and widely considered to be a good to turn 'Option Strict' "on", due to the fact it
increases application performance, and eliminates the chance of naming errors and other
programming mistakes.[15]

 Val() function which also parses a null value while converting into double (In c#
Convert.ToDouble() is used to convert any object into double type value, but which
throws exception in case of a null value)
 CInt, CStr, CByte, CDbl, CBool, CByte, CDate, CLng, CCur, CObj and a wide variety of
converting functions built in the language

Other characteristics of C# not applicable to Visual Basic .NET

 By default, numeric operations are not checked. This results in slightly faster code, at the
risk that numeric overflows will not be detected. However, the programmer can place
arithmetic operations into a checked context to activate overflow checking. (It can be
done in Visual Basic by checking an option)
 Addition and string concatenation use the same token, +. Visual Basic .NET, however,
has separate tokens, + for addition and & for concatenation, although + can be used for
concatenation as well.
 In Visual Basic .NET property methods may take parameters
 C# is case-sensitive.

Syntax comparisons
Visual Basic .NET terminates a block of code with End BlockName statements (or Next
statements, for a for loop) which are more familiar for programmers with experience using T-
SQL. In C#, the braces, {}, are use to delimit blocks, which is more familiar to programmers
with experience in other widely-deployed languages such as C++ and Java. Additionally, in C# if
a block consists of only a single statement, the braces may be omitted.
C# is case sensitive while Visual Basic .NET is not. Thus in C# it is possible to have two
variables with the same name, for example variable1 and Variable1. Visual Studio will
correct the case of variables as they are typed in VB.NET. In many cases however, case
sensitivity can be useful. C# programmers typically capitalize type names and leave member and
variable names lowercase. This allows, for example, fairly natural naming of method arguments:
public int CalculateOrders(Customer customer). Of course, this can cause problems for
those converting C# code to a case-insensitive language, such as Visual Basic, or to those
unaccustomed to reading a case sensitive language.

Keywords

Visual Basic is not case sensitive, which means any combinations of upper and lower cases in
keywords are acceptable. However Visual Studio automatically converts all Visual Basic
keywords to the default capitalised forms, e.g. "Public", "If".

C# is case sensitive and all C# keywords are in lower cases.

Visual Basic and C# share most keywords, with the difference being the default (Remember
Visual Basic is not case sensitive) Visual Basic keywords are the capitalised versions of the C#
keywords, e.g. "Public" vs "public", "If" vs "if".

A few keywords have very different versions in Visual Basic and C#:

 Friend vs internal - access modifiers allowing inter-class but intra-assembly reference

 Me vs this - a self-reference to the current object instance
 MustInherit vs abstract - prevents a class from being directly instantiated, and forces
consumers to create object references to only derived classes
 MustOverride vs abstract - for forcing derived classes to override this method
 MyBase vs base - for referring to the base class from which the current class is derived
 NotInheritable vs sealed - for declaring classes that may not be inherited
 NotOverridable vs sealed - for declaring methods that may not be overridden by
derived classes
 Overridable vs virtual - declares a method as being able to be overridden in derived
classes
 Shared vs static - for declaring methods that do not require an explicit instance of an
object

Some C# keywords such as sealed represent different things when applied to methods as
opposed to when they are applied to class definitions. VB.NET, on the other hand, uses different
keywords for different contexts.
Comments

C# Visual Basic .NET

//Single line comment
'Single line comment
/*Multi-line comment
line 2
line 3*/ Multi-line comment not available

///XML single line comment '''XML single line comment

/**XML multi-line comment XML multi-line comment not available

line 2
line 3*/

Conditionals

C# Visual Basic .NET

if (condition)
If condition Then
{
' condition is true
// condition is true
End If
}
if (condition)
{
If condition Then
// condition is true
' condition is true
}
Else
else
' condition is false
{
End If
// condition is false
}
if (condition)
{
If condition Then
// condition is true
' condition is true
}
ElseIf othercondition Then
else if (othercondition)
' condition is false and
{
othercondition is true
// condition is false and
End If
othercondition is true
}
if (condition)
{
// condition is true
If condition Then
}
' condition is true
else if (othercondition)
ElseIf othercondition Then
{
' condition is false and
// condition is false and
othercondition is true
othercondition is true
Else
}
' condition and othercondition
else
false
{
End If
// condition and othercondition are
false
}

Loops
C# Visual Basic .NET
for (int i = 0; i <= number - 1; i++)
For i as integer = 0 To number - 1
{
' loop from zero up to one less
// loop from zero up to one less
than number
than number
Next
}
for (int i = number; i >= 0; i--)
For i as integer = number To 0 Step -1
{
' loops from number down to zero
// loops from number down to zero
Next
}
Exit For 'breaks out of a for loop
break; //breaks out of a loop Exit While 'breaks out of a while loop
Exit Do 'breaks out of a do loop

Comparers

Primitive types

C# Visual Basic .NET

if (a == b)
If a = b Then
{
' equal
// equal
End If
}
if (a != b)
{
If a <> b Then
// not equal
' not equal
}
End If

Or: Or:
if (!(a == b)) //can also be written as
If Not a = b Then
(a != b)
' not equal
{
End If
// not equal
}
if (a == b & c == d | e == f)
If a = b And c = d Or e = f Then
{
' multiple comparisons
// multiple comparisons
End If
}
if (a == b && c == d || e == f) If a = b AndAlso c = d OrElse (e =
{ f) Then
// short-circuiting comparisons ' short-circuiting comparisons
} End If

Object types
C# Visual Basic .NET
if (Object.ReferenceEquals(a, b))
If a Is b Then 'Can also be written as If
{
Object.ReferenceEquals(a, b) Then
// variables refer to the same
' variables refer to the same instance
instance
End If
}
if (!Object.ReferenceEquals(a, b))
If a IsNot b Then
{
' variables do not refer to the same
// variables do not refer to
instance
the same instance
End If
}
if (a.Equals(b))
If a = b Then 'Or a.Equals(b)
{
' instances are equivalent
// instances are equivalent
End If
}
if (! a.Equals(b))
If a <> b Then
{
' not equivalent
// not equivalent
End If
}
var type = typeof(int); Dim type = GetType(Integer)
if (a is b)
{ If TypeOf a Is b Then
// types of a and b are ' types of a and b are compatible
compatible End If
}
if (!(a is b))
{ If Not TypeOf a Is b Then
// types of a and b are not ' types of a and b are not compatible
compatible End If
}

Note: these examples for equivalence tests assume neither the variable "a" nor the variable "b" is
a Null reference (Nothing in Visual Basic.NET). If "a" were null, the C# evaluation of the .equals
method would throw a NullReferenceException, whereas the VB.NET = operator would return
true if both were null, or false if only one was null (and evaluate the equals method if neither
were null). They also assume that the .equals method and the = operator are implemented for the
class type in question. Omitted for clarity, the exact transliteration would be:

C#

if(object.equals(a,b))

VB.NET

If a = b Then
============================Wiki Ends=====================================

VB.NET and C# Comparison

This is a quick reference guide to highlight some key syntactical differences between VB.NET and C#.
Hope you find this useful!
Thank you to Tom Shelton, Fergus Cooney, Steven Swafford, Gjuro Kladaric, and others for your
VB.NET Program Structure C#
Imports System using System;

Namespace Hello namespace Hello {

   Class HelloWorld    public class HelloWorld {
      Overloads Shared Sub Main(ByVal args() As       public static void Main(string[] args) {
String)          string name = "C#";
         Dim name As String = "VB.NET"
         // See if an argument was passed from the
         'See if an argument was passed  from the command line
command line          if (args.Length == 1)
          If args.Length = 1 Then name = args(0)             name = args[0];

          Console.WriteLine("Hello, " & name & "!")          Console.WriteLine("Hello, " + name + "!");
      }
      End Sub    }
   End Class }
End Namespace

VB.NET Comments C#

// Single line
/* Multiple
' Single line only      line  */
REM  Single line only /// <summary>XML comments on single
''' <summary>XML comments</summary> line</summary>
/** <summary>XML comments on multiple
lines</summary> */

VB.NET Data Types C#

Value Types Value Types

Boolean bool
Byte, SByte byte, sbyte
Char char
Short, UShort, Integer, UInteger, Long, ULong short, ushort, int, uint, long, ulong
Single, Double float, double
Decimal decimal
Date   (alias of System.DateTime) DateTime   (not a built-in C#  type)

Reference Types Reference Types

Object object
String string

Initializing Initializing
Dim correct As Boolean = True bool correct = true;
Dim b As Byte = &H2A   'hex or &O52 for octal byte b = 0x2A;   // hex
Dim person As Object = Nothing object person = null;
Dim name As String = "Dwight" string name = "Dwight";
Dim grade As Char = "B"c char grade = 'B';
Dim today As Date = #12/31/2010 12:15:00 DateTime today = DateTime.Parse("12/31/2010
PM# 12:15:00 PM");
Dim amount As Decimal = 35.99@ decimal amount = 35.99m;
Dim gpa As Single = 2.9! float gpa = 2.9f;
Dim pi As Double = 3.14159265 double pi = 3.14159265;
Dim lTotal As Long = 123456L long lTotal = 123456L;
Dim sTotal As Short = 123S short sTotal = 123;
Dim usTotal As UShort = 123US ushort usTotal = 123;
Dim uiTotal As UInteger = 123UI uint uiTotal = 123;
Dim ulTotal As ULong = 123UL ulong ulTotal = 123;

Implicitly Typed Local Variables Implicitly Typed Local Variables

Dim s = "Hello!" var s = "Hello!";
Dim nums = New Integer() {1, 2, 3} var nums = new int[] { 1, 2, 3 };
Dim hero = New SuperHero With {.Name = var hero = new SuperHero() { Name = "Batman" };
"Batman"}
Type Information
Type Information int x;
Dim x As Integer Console.WriteLine(x.GetType());              // Prints
Console.WriteLine(x.GetType())          '  Prints System.Int32
System.Int32 Console.WriteLine(typeof(int));               // Prints
Console.WriteLine(GetType(Integer))   ' Prints System.Int32
System.Int32 Console.WriteLine(x.GetType().Name);   // prints
Console.WriteLine(TypeName(x))        ' Prints Int32
Integer
Circle c = new Circle();
Dim c as New Circle if (c is Shape)
If TypeOf c Is Shape Then _     Console.WriteLine("c is a Shape");
    Console.WriteLine("c is a Shape")
Type Conversion / Casting
Type Conversion / Casting float d = 3.5f;
Dim d As Single = 3.5 i = Convert.ToInt32(d);     // Set to 4 (rounds)
Dim i As Integer = CType(d, Integer)   ' set to 4 int i = (int)d;     // set to 3 (truncates decimal)
(Banker's rounding)
i = CInt(d)  ' same result as CType
i = Int(d)    ' set to 3 (Int function truncates the object o = 2;
decimal) int i = (int)o;   // Throws InvalidCastException if type
cast fails
Dim o As Object = 2
i = DirectCast(o, Integer)   ' Throws Shape s = new Shape();
InvalidCastException if type cast fails Circle c = s as Circle;   // Returns null if type cast fails

Dim s As New Shape

Dim c As Circle = TryCast(s, Circle)   ' Returns
Nothing if type cast fails

VB.NET Constants C#

Const MAX_STUDENTS As Integer = 25 const int MAX_STUDENTS = 25;

' Can set to a const or  var; may be initialized in // Can set to a const or var; may be initialized in a
a constructor constructor
ReadOnly MIN_DIAMETER As Single = 4.93 readonly float MIN_DIAMETER = 4.93f;

VB.NET Enumerations C#
Enum Action enum Action {Start, Stop, Rewind, Forward};
  Start  enum Status {Flunk = 50, Pass = 70, Excel = 90};
  [Stop]   ' Stop  is a reserved word
  Rewind Action a = Action.Stop;
  Forward if (a != Action.Start)
End Enum   Console.WriteLine(a + " is " + (int) a);    // Prints
"Stop is 1"
Enum Status
  Flunk = 50 Console.WriteLine((int) Status.Pass);    // Prints 70
  Pass = 70 Console.WriteLine(Status.Pass);      // Prints Pass
  Excel = 90
End Enum

Dim a As Action = Action.Stop

If a <> Action.Start Then _
   Console.WriteLine(a.ToString & " is " & a)     '
Prints "Stop is 1"

Console.WriteLine(Status.Pass)     ' Prints 70

Console.WriteLine(Status.Pass.ToString())     '
Prints Pass

VB.NET Operators C#

Comparison
Comparison
==  <  >  <=  >=  !=
=  <  >  <=  >=  <>

Arithmetic
Arithmetic
+  -  *  /
+  -  *  /
%  (mod)
Mod
/  (integer division if both operands are ints)
\  (integer division)
Math.Pow(x, y)
^  (raise to a power)

Assignment
Assignment
=  +=  -=  *=  /=   %=  &=  |=  ^=  <<=  >>=  ++ 
=  +=  -=  *=  /=  \=  ^=  <<=  >>=  &=
--

Bitwise
Bitwise
And   Or   Xor   Not   <<   >>
&   |   ^   ~   <<   >>

Logical
Logical
AndAlso   OrElse   And   Or   Xor   Not
&&   ||   &   |   ^   !

Note: AndAlso and OrElse perform short-circuit

Note: && and || perform short-circuit logical
logical evaluations
evaluations

String Concatenation
String Concatenation
&
+

VB.NET Choices C#
' Ternary/Conditional operator (IIf evaluates 2nd // Ternary/Conditional operator
and 3rd expressions) greeting = age < 20 ? "What's up?" : "Hello";
greeting = If(age < 20, "What's up?", "Hello")
if (age < 20)
' One line doesn't require "End If"   greeting = "What's up?";
If age < 20 Then greeting = "What's up?" else
If age < 20 Then greeting = "What's up?" Else   greeting = "Hello";
greeting = "Hello"
// Multiple statements must be enclosed in {}
' Use : to put two commands on same line if (x != 100 && y < 5) {   
If x <> 100 AndAlso y < 5 Then x *= 5 : y *=   x *= 5;
2     y *= 2;
}
' Preferred
If x <> 100 AndAlso y < 5 Then
  x *= 5
  y *= 2 No need for _ or : since ; is used to terminate each
End If statement.

' Use _ to break up long single line or use

implicit line break
If whenYouHaveAReally < longLine And
  itNeedsToBeBrokenInto2 > Lines Then _
  UseTheUnderscore(charToBreakItUp) if (x > 5)
  x *= y;
'If x > 5 Then else if (x == 5 || y % 2 == 0)
  x *= y   x += y;
ElseIf x = 5 OrElse y Mod 2 = 0 Then else if (x < 10)
  x += y   x -= y;
ElseIf x < 10 Then else
  x -= y   x /= y;
Else
  x /= y
End If
// Every case must end with break or goto case
Select Case color   ' Must be a primitive data switch (color) {                          // Must be integer
type or string
  Case "pink", "red"   case "pink":
    r += 1   case "red":    r++;    break;
  Case "blue"   case "blue":   b++;   break;
    b += 1   case "green": g++;   break;
  Case "green"   default:    other++;   break;       // break necessary
    g += 1 on default
  Case Else }
    other += 1
End Select

VB.NET Loops C#

Pre-test Loops: Pre-test Loops:  

While c < 10 Do Until c = 10  // no "until" keyword

  c += 1   c += 1
End While Loop while (c < 10)
  c++;
For c = 2 To 10 Step 2
Do While c < 10
  c += 1
  Console.WriteLine(c) for (c = 2; c <= 10; c += 2)
Loop
Next   Console.WriteLine(c);

Post-test Loops:
Post-test Loop:
Do  Do 
do
  c += 1   c += 1
  c++;
Loop While c < 10 Loop Until c = 10
while (c < 10);
'  Array or collection looping
Dim names As String() = {"Fred", "Sue",
"Barney"} // Array or collection looping
For Each s As String In names string[] names = {"Fred", "Sue", "Barney"};
  Console.WriteLine(s) foreach (string s in names)
Next   Console.WriteLine(s);

' Breaking out of loops

Dim i As Integer = 0 // Breaking out of loops
While (True) int i = 0;
  If (i = 5) Then Exit While while (true) {
  i += 1   if (i == 5)
End While     break;
  i++;
}
' Continue to next iteration
For i = 0 To 4 // Continue to next iteration
  If i < 4 Then Continue For for (i = 0; i <= 4; i++) {
  Console.WriteLine(i)   ' Only prints 4   if (i < 4)
Next     continue;
  Console.WriteLine(i);   // Only prints 4
}

VB.NET Arrays C#

Dim nums() As Integer = {1, 2, 3}  int[] nums = {1, 2, 3};

For i As Integer = 0 To nums.Length - 1 for (int i = 0; i < nums.Length; i++)
  Console.WriteLine(nums(i))   Console.WriteLine(nums[i]);
Next

' 4 is the index of the last element, so it holds 5 // 5 is the size of the array
elements string[] names = new string[5];
Dim names(4) As String names[0] = "David";
names(0) = "David" names[5] = "Bobby";   // Throws
names(5) = "Bobby"  ' Throws System.IndexOutOfRangeException
System.IndexOutOfRangeException

' Resize the array, keeping the existing values // C# can't dynamically resize an array.  Just copy into
(Preserve is optional) new array.
ReDim Preserve names(6) string[] names2 = new string[7];
Array.Copy(names, names2, names.Length);   // or
names.CopyTo(names2, 0); 

Dim twoD(rows-1, cols-1) As Single float[,] twoD = new float[rows, cols];

twoD(2, 0) = 4.5 twoD[2,0] = 4.5f; 

Dim jagged()() As Integer = { _ int[][] jagged = new int[3][] {

  New Integer(4) {}, New Integer(1) {}, New   new int[5], new int[2], new int[3] };
Integer(2) {} } jagged[0][4] = 5;
jagged(0)(4) = 5

VB.NET Functions C#

' Pass by value (in, default), reference (in/out), // Pass by value (in, default), reference (in/out),
and  reference (out)  and reference (out)
Sub TestFunc(ByVal x As Integer, ByRef y As void TestFunc(int x, ref int y, out int z) {
Integer, ByRef z As Integer)   x++;  
  x += 1   y++;
  y += 1   z = 5;
 z=5 }
End Sub
int a = 1, b = 1, c;  // c doesn't need initializing
Dim a = 1, b = 1, c As Integer   ' c set to zero TestFunc(a, ref b, out c);
by default  Console.WriteLine("{0} {1} {2}", a, b, c);  // 1 2 5
TestFunc(a, b, c)
Console.WriteLine("{0} {1} {2}", a, b, c)   ' 1  2 // Accept variable number of arguments
5 int Sum(params int[] nums) {
  int sum = 0;
' Accept variable number of arguments   foreach (int i in nums)
Function Sum(ByVal ParamArray nums As     sum += i;
Integer()) As Integer   return sum;
  Sum = 0  }
  For Each i As Integer In nums
    Sum += i int total = Sum(4, 3, 2, 1);   // returns 10
  Next
End Function   ' Or use Return statement like /* C# 4.0 supports optional parameters. Previous
C# versions required function overloading. */ 
void SayHello(string name, string prefix = "") {
Dim total As Integer = Sum(4, 3, 2, 1)   ' returns   Console.WriteLine("Greetings, " + prefix + " " +
10 name);
} 
' Optional parameters must be listed last and
must have a default value SayHello("Strangelove", "Dr.");
Sub SayHello(ByVal name As String, Optional SayHello("Mom");
ByVal prefix As String = "")
  Console.WriteLine("Greetings, " & prefix & " " &
name)
End Sub

SayHello("Strangelove", "Dr.")
SayHello("Mom")

VB.NET Strings C#

Special character constants (all also accessible Escape sequences

from ControlChars class) \r    // carriage-return
vbCrLf, vbCr, vbLf, vbNewLine \n    // line-feed
vbNullString \t    // tab
vbTab \\    // backslash
vbBack \"    // quote
vbFormFeed
vbVerticalTab
"" // String concatenation
string school = "Harding\t";
' String concatenation (use & or +) school = school + "University";   // school is "Harding
Dim school As String = "Harding" & vbTab (tab) University"
school = school & "University" ' school is
"Harding (tab) University" // Chars
char letter = school[0];            // letter is H
' Chars letter = 'Z';                               // letter is Z
Dim letter As Char = school.Chars(0)   ' letter is letter = Convert.ToChar(65);     // letter is A
H letter = (char)65;                    // same thing
letter = "Z"c                                         ' letter char[] word = school.ToCharArray();   // word holds
is Z Harding
letter = Convert.ToChar(65)                ' letter is
A // String literal
letter = Chr(65)                                 ' same string msg = @"File is c:\temp\x.dat";
thing // same as
Dim word() As Char = school.ToCharArray() ' string msg = "File is c:\\temp\\x.dat";
word holds Harding
// String comparison
' No string literal operator string mascot = "Bisons";
Dim msg As String = "File is c:\temp\x.dat" if (mascot == "Bisons")    // true
if (mascot.Equals("Bisons"))   // true
if (mascot.ToUpper().Equals("BISONS"))   // true
' String comparison if (mascot.CompareTo("Bisons") == 0)    // true
Dim mascot As String = "Bisons"
If (mascot = "Bisons") Then   ' true // String matching - No Like equivalent, use Regex
If (mascot.Equals("Bisons")) Then   ' true
If (mascot.ToUpper().Equals("BISONS")) Then
' true // Substring
If (mascot.CompareTo("Bisons") = 0) Then   ' s = mascot.Substring(2, 3))     // s is "son"
true
// Replacement
' String matching with Like - Regex is more s = mascot.Replace("sons", "nomial"))     // s is
powerful "Binomial"
If ("John 3:16" Like "Jo[Hh]? #:*") Then   'true
// Split
' Substring string names = "Michael,Dwight,Jim,Pam";
s = mascot.Substring(2, 3)) ' s is "son" string[] parts = names.Split(",".ToCharArray());   //
One name in each slot
' Replacement
s = mascot.Replace("sons", "nomial")) ' s is // Date to string
"Binomial" DateTime dt = new DateTime(1973, 10, 12);
string s = dt.ToString("MMM dd, yyyy");     // Oct 12,
' Split 1973
Dim names As String =
"Michael,Dwight,Jim,Pam" // int to string
Dim parts() As String = int x = 2;
names.Split(",".ToCharArray())   ' One name in string y = x.ToString();     // y is "2"
each slot
// string to int
' Date to string int x = Convert.ToInt32("-5");     // x is -5
Dim dt As New DateTime(1973, 10, 12)
Dim s As String = "My birthday: " & // Mutable string
dt.ToString("MMM dd, yyyy")   ' Oct 12, 1973 System.Text.StringBuilder buffer = new
System.Text.StringBuilder("two ");
' Integer to String buffer.Append("three ");
Dim x As Integer = 2 buffer.Insert(0, "one ");
Dim y As String = x.ToString()     ' y is "2" buffer.Replace("two", "TWO");
Console.WriteLine(buffer);     // Prints "one TWO
' String to Integer three"
Dim x As Integer = Convert.ToInt32("-5")     ' x
is -5

' Mutable string

Dim buffer As New
System.Text.StringBuilder("two ")
buffer.Append("three ")
buffer.Insert(0, "one ")
buffer.Replace("two", "TWO")
Console.WriteLine(buffer)         ' Prints "one
TWO three"

VB.NET Regular Expressions C#

Imports System.Text.RegularExpressions using System.Text.RegularExpressions;

' Match a string pattern // Match a string pattern

Dim r As New Regex("j[aeiou]h?. \d:*", Regex r = new Regex(@"j[aeiou]h?. \d:*",
RegexOptions.IgnoreCase Or _ RegexOptions.IgnoreCase |
        RegexOptions.Compiled)         RegexOptions.Compiled);
If (r.Match("John 3:16").Success) Then   'true if (r.Match("John 3:16").Success)   // true
    Console.WriteLine("Match")     Console.WriteLine("Match");
End If

' Find and remember all matching patterns // Find and remember all matching patterns
Dim s As String = "My number is 305-1881, not string s = "My number is 305-1881, not 305-1818.";
305-1818." Regex r = new Regex("(\\d+-\\d+)");
Dim r As New Regex("(\d+-\d+)") // Matches 305-1881 and 305-1818
Dim m As Match = r.Match(s)     ' Matches 305- for (Match m = r.Match(s); m.Success; m =
1881 and 305-1818 m.NextMatch())
While m.Success     Console.WriteLine("Found number: " + m.Groups[1]
    Console.WriteLine("Found number: " & + " at position " +
m.Groups(1).Value & " at position " _         m.Groups[1].Index);
            & m.Groups(1).Index.ToString)
    m = m.NextMatch()
End While
// Remeber multiple parts of matched pattern
' Remeber multiple parts of matched pattern Regex r = new Regex("@(\d\d):(\d\d) (am|pm)");
Dim r As New Regex("(\d\d):(\d\d) (am|pm)") Match m = r.Match("We left at 03:15 pm.");
Dim m As Match = r.Match("We left at 03:15 if (m.Success) {
pm.")     Console.WriteLine("Hour: " + m.Groups[1]);       //
If m.Success Then 03
    Console.WriteLine("Hour: " &     Console.WriteLine("Min: " + m.Groups[2]);         //
m.Groups(1).ToString)       ' 03 15
    Console.WriteLine("Min: " &     Console.WriteLine("Ending: " + m.Groups[3]);   //
m.Groups(2).ToString)         ' 15 pm
    Console.WriteLine("Ending: " & }
m.Groups(3).ToString)   ' pm
End If // Replace all occurrances of a pattern
Regex r = new Regex("h\\w+?d",
' Replace all occurrances of a pattern RegexOptions.IgnoreCase);
Dim r As New Regex("h\w+?d", string s = r.Replace("I heard this was HARD!",
RegexOptions.IgnoreCase) "easy"));   // I easy this was easy!
Dim s As String = r.Replace("I heard this was
HARD!", "easy")   ' I easy this was easy! // Replace matched patterns
string s = Regex.Replace("123 < 456", @"(\d+) .
' Replace matched patterns (\d+)", "$2 > $1");   // 456 > 123
Dim s As String = Regex.Replace("123 < 456",
"(\d+) . (\d+)", "$2 > $1")   ' 456 > 123 // Split a string based on a pattern
string names = "Michael, Dwight, Jim, Pam";
' Split a string based on a pattern Regex r = new Regex(@",\s*");
Dim names As String = "Michael, Dwight, Jim, string[] parts = r.Split(names);   // One name in each
Pam" slot
Dim r As New Regex(",\s*")
Dim parts() As String = r.Split(names)   ' One
name in each slot

VB.NET Exception Handling C#

' Throw an exception // Throw an exception

Dim ex As New Exception("Something is really Exception up = new Exception("Something is really
wrong.") wrong.");
Throw  ex  throw up;  // ha ha

' Catch an exception // Catch an exception

Try  try { 
 y=0   y = 0;
  x = 10 / y   x = 10 / y;
Catch ex As Exception When y = 0 ' Argument }
and When is optional catch (Exception ex) {   // Argument is optional, no
  Console.WriteLine(ex.Message) "When" keyword 
Finally   Console.WriteLine(ex.Message);
  Beep() }
End Try finally {
  Microsoft.VisualBasic.Interaction.Beep();
' Deprecated unstructured error handling }
On Error GoTo MyErrorHandler
...
MyErrorHandler:
Console.WriteLine(Err.Description)

VB.NET Namespaces C#

Namespace Harding.Compsci.Graphics  namespace Harding.Compsci.Graphics {

  ...   ...
End Namespace }

' or // or

Namespace Harding namespace Harding {

  Namespace Compsci   namespace Compsci {
    Namespace Graphics      namespace Graphics {
      ...       ...
    End Namespace     }
  End Namespace  }
End Namespace }

Imports Harding.Compsci.Graphics using Harding.Compsci.Graphics;

VB.NET Classes / Interfaces C#

Access Modifiers Access Modifiers

Public public
Private private
Friend internal
Protected protected
Protected Friend protected internal

Class Modifiers Class Modifiers

MustInherit abstract
NotInheritable sealed
Method Modifiers static
MustOverride
NotInheritable Method Modifiers
Shared abstract
Overridable sealed
static
' All members are Shared virtual
Module
No Module equivalent - just use static class
' Partial classes
Partial Class Competition // Partial classes
  ... partial class Competition {
End Class    ...
}
' Inheritance
Class FootballGame // Inheritance
  Inherits Competition class FootballGame : Competition {
  ...   ...
End Class  }

' Interface definition

Interface IAlarmClock // Interface definition
  Sub Ring() interface IAlarmClock {
  Property TriggerDateTime() As DateTime   void Ring();
End Interface   DateTime CurrentDateTime { get; set; }
}
' Extending an interface
Interface IAlarmClock // Extending an interface 
  Inherits IClock interface IAlarmClock : IClock {
  ...   ...
End Interface }

' Interface implementation

Class WristWatch  // Interface implementation
  Implements IAlarmClock, ITimer class WristWatch : IAlarmClock, ITimer {

  Public Sub Ring() Implements   public void Ring() {

IAlarmClock.Ring     Console.WriteLine("Wake up!");
    Console.WriteLine("Wake up!")  }
  End Sub
  public DateTime TriggerDateTime { get; set; }
  Public Property TriggerDateTime As DateTime   ...
Implements IAlarmClock.TriggerDateTime }
  ...
End Class 

VB.NET Constructors / Destructors C#

Class SuperHero class SuperHero {

  Private powerLevel As Integer   private int powerLevel;
  Public Sub New()   public SuperHero() {
    powerLevel = 0      powerLevel = 0;
  End Sub  }

  Public Sub New(ByVal powerLevel As Integer)   public SuperHero(int powerLevel) {

    Me.powerLevel = powerLevel     this.powerLevel = powerLevel; 
  End Sub  }

  Shared Sub New()   static SuperHero() {

    ' Shared constructor invoked before 1st     // Static constructor invoked before 1st instance is
instance is created created
  End Sub  }

  Protected Overrides Sub Finalize()    ~SuperHero() {

   ' Destructor to free unmanaged resources     // Destructor implicitly creates a Finalize method
    MyBase.Finalize()  }
  End Sub }
End Class

VB.NET Using Objects C#

Dim hero As SuperHero = New SuperHero SuperHero hero = new SuperHero();

' or
Dim hero As New SuperHero

With hero // No "With" construct

  .Name = "SpamMan" hero.Name = "SpamMan";
  .PowerLevel = 3 hero.PowerLevel = 3;
End With

hero.Defend("Laura Jones") hero.Defend("Laura Jones");

hero.Rest()     ' Calling Shared method SuperHero.Rest();   // Calling static method
' or
SuperHero.Rest()

Dim hero2 As SuperHero = hero  ' Both SuperHero hero2 = hero;   // Both reference the same
reference the same object object
hero2.Name = "WormWoman" hero2.Name = "WormWoman";
Console.WriteLine(hero.Name)   ' Prints Console.WriteLine(hero.Name);   // Prints
WormWoman WormWoman

hero = Nothing    ' Free the object hero = null ;   // Free the object

If hero Is Nothing Then _ if (hero == null)

  hero = New SuperHero   hero = new SuperHero();

Dim obj As Object = New SuperHero Object obj = new SuperHero(); 

If TypeOf obj Is SuperHero Then _ if (obj is SuperHero)
  Console.WriteLine("Is a SuperHero object.")   Console.WriteLine("Is a SuperHero object.");

' Mark object for quick disposal // Mark object for quick disposal
Using reader As StreamReader = using (StreamReader reader =
 File.OpenText("test.txt")) {
File.OpenText("test.txt")   string line;
  Dim line As String = reader.ReadLine()   while ((line = reader.ReadLine()) != null)
  While Not line Is Nothing     Console.WriteLine(line);
    Console.WriteLine(line) }
    line = reader.ReadLine()
  End While
End Using

VB.NET Structs C#

Structure StudentRecord struct StudentRecord {

  Public name As String   public string name;
  Public gpa As Single   public float gpa;

  Public Sub New(ByVal name As String, ByVal   public StudentRecord(string name, float gpa) {
gpa As Single)     this.name = name;
    Me.name = name     this.gpa = gpa;
    Me.gpa = gpa  }
  End Sub }
End Structure
StudentRecord stu = new StudentRecord("Bob", 3.5f);
Dim stu As StudentRecord = New StudentRecord stu2 = stu;  
StudentRecord("Bob", 3.5)
Dim stu2 As StudentRecord = stu   stu2.name = "Sue";
Console.WriteLine(stu.name);    // Prints Bob
stu2.name = "Sue" Console.WriteLine(stu2.name);   // Prints Sue
Console.WriteLine(stu.name)    ' Prints Bob
Console.WriteLine(stu2.name)  ' Prints Sue

VB.NET Properties C#

' Auto-implemented properties are new to VB10 // Auto-implemented properties

Public Property Name As String public string Name { get; set; }
Public Property Size As Integer = -1     ' public int Size { get; protected set; }     // Set default
Default value, Get and Set both Public value in constructor

' Traditional property implementation // Traditional property implementation

Private mName As String private string name;
Public Property Name() As String public string Name {
    Get   get {
        Return mName     return name;
    End Get  }
    Set(ByVal value As String)   set {
        mName = value     name = value;
    End Set  }
End Property }

' Read-only property // Read-only property

Private mPowerLevel As Integer private int powerLevel;
Public ReadOnly Property PowerLevel() As public int PowerLevel {
Integer   get {
    Get     return powerLevel;
        Return mPowerLevel  }
    End Get }
End Property
// Write-only property
' Write-only property private double height;
Private mHeight As Double public double Height {
Public WriteOnly Property Height() As Double   set {
    Set(ByVal value As Double)     height = value < 0 ? 0 : value;
        mHeight = If(value < 0, mHeight = 0,  }
mHeight = value) }
    End Set
End Property

VB.NET Delegates / Events C#

Delegate Sub MsgArrivedEventHandler(ByVal delegate void MsgArrivedEventHandler(string

message As String) message);

Event MsgArrivedEvent As event MsgArrivedEventHandler MsgArrivedEvent;

MsgArrivedEventHandler
// Delegates must be used with events in C#
' or to define an event which declares a delegate
implicitly
Event MsgArrivedEvent(ByVal message As MsgArrivedEvent += new
String) MsgArrivedEventHandler(My_MsgArrivedEventCallback);
MsgArrivedEvent("Test message");    // Throws
AddHandler MsgArrivedEvent, AddressOf exception if obj is null
My_MsgArrivedCallback MsgArrivedEvent -= new
' Won't throw an exception if obj is Nothing MsgArrivedEventHandler(My_MsgArrivedEventCallback);
RaiseEvent MsgArrivedEvent("Test message")
RemoveHandler MsgArrivedEvent, AddressOf
My_MsgArrivedCallback
using System.Windows.Forms;
Imports System.Windows.Forms
Button MyButton = new Button(); 
Dim WithEvents MyButton As Button   ' MyButton.Click += new
WithEvents can't be used on local variable System.EventHandler(MyButton_Click);
MyButton = New Button
private void MyButton_Click(object sender,
Private Sub MyButton_Click(ByVal sender As System.EventArgs e) {
System.Object, _   MessageBox.Show(this, "Button was clicked", "Info",
  ByVal e As System.EventArgs) Handles     MessageBoxButtons.OK,
MyButton.Click MessageBoxIcon.Information);
  MessageBox.Show(Me, "Button was clicked", }
"Info", _
    MessageBoxButtons.OK,
MessageBoxIcon.Information)
End Sub

VB.NET Generics C#

' Enforce accepted data type at compile-time // Enforce accepted data type at compile-time
Dim numbers As New List(Of Integer) List<int> numbers = new List<int>();
numbers.Add(2) numbers.Add(2);
numbers.Add(4) numbers.Add(4);
DisplayList(Of Integer)(numbers) DisplayList<int>(numbers);

' Subroutine can display any type of List // Function can display any type of List
Sub DisplayList(Of T)(ByVal list As List(Of T)) void DisplayList<T>(List<T> list) {
    For Each item As T In list     foreach (T item in list)
        Console.WriteLine(item)         Console.WriteLine(item);
    Next }
End Sub
// Class works on any data type
' Class works on any data type class SillyList<T> {
Class SillyList(Of T)     private T[] list = new T[10];
    Private list(10) As T     private Random rand = new Random();
    Private rand As New Random
    public void Add(T item) {
    Public Sub Add(ByVal item As T)         list[rand.Next(10)] = item;
        list(rand.Next(10)) = item   }
    End Sub
    public T GetItem() {
    Public Function GetItem() As T         return list[rand.Next(10)];
        Return list(rand.Next(10))   }
    End Function }
End Class
// Limit T to only types that implement IComparable
' Limit T to only types that implement T Maximum<T>(params T[] items) where T :
IComparable IComparable<T> {
Function Maximum(Of T As IComparable)     T max = items[0];
(ByVal ParamArray items As T()) As T     foreach (T item in items)
    Dim max As T = items(0)         if (item.CompareTo(max) > 0)
    For Each item As T In items             max = item;
        If item.CompareTo(max) > 0 Then max =     return max;
item }
    Next
    Return max
End Function

VB.NET LINQ C#

Dim nums() As Integer = {5, 8, 2, 1, 6} int[] nums = { 5, 8, 2, 1, 6 };

' Get all numbers in the array above 4 // Get all numbers in the array above 4
Dim results = From value In nums var results = from value in nums
                  Where value > 4                 where value > 4
                  Select value                 select value;

Console.WriteLine(results.Count())     ' 3 Console.WriteLine(results.Count());     // 3

Console.WriteLine(results.First())     ' 5 Console.WriteLine(results.First());     // 5
Console.WriteLine(results.Last())     ' 6 Console.WriteLine(results.Last());     // 6
Console.WriteLine(results.Average())     ' Console.WriteLine(results.Average());     // 6.33333
6.33333
// Displays 5 8 6
' Displays 5 8 6 foreach (int n in results)
For Each n As Integer In results     Console.Write(n + " ");
    Console.Write(n & " ")
Next
results = results.Intersect(new[] {5, 6, 7});     // 5 6
results = results.Intersect({5, 6, 7})     ' 5 6 results = results.Concat(new[] {5, 1, 5});     // 5 6 5 1
results = results.Concat({5, 1, 5})     ' 5 6 5 1 5 5
results = results.Distinct();     // 5 6 1
results = results.Distinct()     ' 5 6 1
Student[] Students = {
Dim Students() As Student = {     new Student{ Name = "Bob", GPA = 3.5 },
    New Student With {.Name = "Bob", .GPA =     new Student{ Name = "Sue", GPA = 4.0 },
3.5},     new Student{ Name = "Joe", GPA = 1.9 }
    New Student With {.Name = "Sue", .GPA = };
4.0},
    New Student With {.Name = "Joe", .GPA = // Get an ordered list of all students by GPA with GPA
1.9} >= 3.0
} var goodStudents = from s in Students
            where s.GPA >= 3.0
' Get an ordered list of all students by GPA with             orderby s.GPA descending
GPA >= 3.0             select s;
Dim goodStudents = From s In Students
            Where s.GPA >= 3.0 Console.WriteLine(goodStudents.First().Name);     //
            Order By s.GPA Descending Sue
            Select s

Console.WriteLine(goodStudents.First.Name)    
' Sue

VB.NET Console I/O C#

Console.Write("What's your name? ") Console.Write("What's your name? ");

Dim name As String = Console.ReadLine() string name = Console.ReadLine();
Console.Write("How old are you? ") Console.Write("How old are you? ");
Dim age As Integer = Val(Console.ReadLine()) int age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("{0} is {1} years old.", name, Console.WriteLine("{0} is {1} years old.", name, age);
age)  // or
' or Console.WriteLine(name + " is " + age + " years old.");
Console.WriteLine(name & " is " & age & " years
old.")
int c = Console.Read();  // Read single char
Dim c As Integer Console.WriteLine(c);    // Prints 65 if user enters "A"
c = Console.Read()    ' Read single char
Console.WriteLine(c)   ' Prints 65 if user enters
"A"

VB.NET File I/O C#

Imports System.IO using System.IO;

' Write out to text file // Write out to text file

Dim writer As StreamWriter = StreamWriter writer =
File.CreateText("c:\myfile.txt") File.CreateText("c:\\myfile.txt");
writer.WriteLine("Out to file.") writer.WriteLine("Out to file.");
writer.Close() writer.Close();

' Read all lines from text file // Read all lines from text file
Dim reader As StreamReader = StreamReader reader =
File.OpenText("c:\myfile.txt") File.OpenText("c:\\myfile.txt");
Dim line As String = reader.ReadLine() string line = reader.ReadLine();
While Not line Is Nothing while (line != null) {
  Console.WriteLine(line)   Console.WriteLine(line);
  line = reader.ReadLine()   line = reader.ReadLine();
End While }
reader.Close() reader.Close();

' Write out to binary file // Write out to binary file

Dim str As String = "Text data" string str = "Text data";
Dim num As Integer = 123 int num = 123;
Dim binWriter As New BinaryWriter binWriter = new
BinaryWriter(File.OpenWrite("c:\myfile.dat"))  BinaryWriter(File.OpenWrite("c:\\myfile.dat"));
binWriter.Write(str)  binWriter.Write(str);
binWriter.Write(num)  binWriter.Write(num);
binWriter.Close() binWriter.Close();

' Read from binary file // Read from binary file

Dim binReader As New BinaryReader binReader = new
BinaryReader(File.OpenRead("c:\myfile.dat")) BinaryReader(File.OpenRead("c:\\myfile.dat"));
str = binReader.ReadString() str = binReader.ReadString();
num = binReader.ReadInt32() num = binReader.ReadInt32();
binReader.Close() binReader.Close();