Comparison of C Sharp and Visual Basic .NET

Language history

C# and VB.NET are syntactically very different languages with very different histories.

As the name suggests, the C# syntax is based on the core C programming language originally developed by Dennis Ritchie at Bell Labs (AT&T) in the 1970s.[1] Java and C++ are two other programming languages whose syntax is also based on the C syntax,[2] so they 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. 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. 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.[3] It competed directly against other RAD tools of the 1990s such as PowerBuilder.[4] 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. At that time, the current C++ and VB6 languages were used by Microsoft as the basis for two new programming languages in their new "Integrated Development Environment (IDE)". These languages were named C# and VB.NET
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.[5] They compile to the same intermediate language (IL), which runs against the same .NET Framework runtime libraries.[6] 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 task. The only fundamental differences between the languages can be found in the implementation of interfaces and in the declaration, raising and handling of events. Although both languages are high-level programming languages, VB.NET maintains a slightly higher level of abstraction in some respects.
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#.[7] 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.[8] Such is not the case with Visual Basic because the Error List panel is synchronized with the background compiler.

Background compilation is less demanding on system resources and results in faster build cycles.[8] This is a particular advantage with large projects and can significantly reduce the time required to start debugging in the IDE.[8]
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, which connects event handlers to object variables rather than to objects.
    Firing of events is done with the RaiseEvent keyword, giving the IDE the chance to show a list of available events to pick from. RaiseEvents implicitly checks if there are any event handlers wired up. (in C# raising an event is syntactically identical to calling a procedure, and it requires an additional line of code to check for wired event handlers)
    Delegates for events don't need to be declared. They are implicitly declared in the declaration of the events.
    Referring to an object using an unqualified dot reference, using the With ... End With structure
    XML Literals[9]
    Inline date declarations, e.g. #12/31/2000#
    Module (although C#'s static classes with additional semantics, but each field must be individually declared as static)
    Members of Modules imported to the current file, can be accessed with no preceding container accessor[10]
    The My namespace.[11]
    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 at the project level, so that they don't have to be imported into each individual file, as in C#
    In-line exceptions filtering by boolean expression, using When <expression> blocks.[13] C# emulates[14] this functionality, using a catch block followed by an if block. It is not just syntax sugar.
    Definition of conditional compiler constants
    Property methods may take parameters
    Properties can be passed to methods with ByRef parameters (ref parameters in C#). In C# you have to write three additional instructions: Declare a variable, copy the property value into the variable and copy the variable back to the property after the method call.
    Enums can be defined inside interfaces
    Case statements may contain inequality expressions. (in C# this can be mimicked by nested Else and If statements)
    Overloads keyword specifies that a property or procedure redeclares one or more existing properties or procedures with the same name within the same class or the base class. (the lack of this keyword in C# might lead to inadvertent overloading)
    Implements keyword to indicate which interfaces a class member implements. In C# a similar syntax exist, but it is optional and it can only be applied if the member implements a single interface.
    Like operator for pattern comparison of strings in a much simpler way than using regular expressions. (in C# the same is available with the Microsoft.VisualBasic.CompilerServices.LikeOperator.LikeString method, but not as a handy language key word)
    Return statement is not required. Return can also be done by assigning the value to the function
    Visual basic has build in constants like vbCrLf and vbTab
    No out parameter modifier exists, because in VB all variables are automatically initialised.
    The MyClass keyword behaves like an object variable referring to the current instance of a class as originally implemented. MyClass is similar to Me, but all method calls on it are treated as if the method were NotOverridable.
    MyBase.New is used to explicitly call a base class constructor from a derived class constructor.
    The My feature provides easy and intuitive access to a number of .NET Framework classes, enabling the Visual Basic user to interact with the computer, application, settings, resources, and so on.
    Local variables (i.e. variables declared inside of a procedure) are automatically initialized.
    Local variables can be declared with the Static modifier in order to preserve their value between calls to the procedure.
    C# lacks the DirectCast (mapping to a single CLR instruction), strict type conversion can be achieved by the as operator which includes an additional runtime error protection.
    C# miss End keyword which terminate an application.

Features of C# not found in Visual Basic .NET

    Multi-line and intra-line comments (the Visual Studio IDE supports multi-line commenting for Visual Basic .NET)
    Multi-line strings with the @ symbol
    Static classes (classes which cannot contain any non-static members, although VB.NET's Modules are essentially static classes with additional semantics)
    Can use checked and unchecked contexts for fine-grained control of overflow/underflow checking
    Iterative for-loops can contain multiple conditionals, such as for(int i = 0; i < 10 && somethingTrue; i++)
    The getter and setter of a property may implement separate interfaces. In VB you'd have to define two properties instead: a read-only property implementing one interface, and a write-only property implementing the other interface.
    Implicit interface implementation
    Can use the coalesce operator ?? to return the first non-null value (ex. null ?? null ?? 1 returns 1). VB.NET would have to use nested If operators.

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 identifiers are not case-sensitive.
    When assigning a value to a variable with a different data type (and with Option Strict not turned on), VB.NET will coerce the value if possible. This automatic coercion can sometimes lead to unexpected results, 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
    MsgBox("Avoid using, but this message will appear!")
End If

It should be noted that although the default is for Option Strict to be off for backward compatibility reasons, it is recommended by Microsoft[15] and widely considered to be good practice to turn Option Strict on, due to the fact that it increases application performance and reduces the possibility of naming errors and other programming mistakes.[16]

    Val() function which also parses a null value while converting into double (In c# Convert.ToDouble() is used to convert any object into a double type value, but which throws an exception in the case of a null value)
    CInt, CStr, CByte, CDbl, CBool, CDate, CLng, CCur, CObj and a wide variety of conversion functions built into 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)
    C# identifiers are case-sensitive.
    To assign the same value to multiple variables, you can use a=b=c

Syntax comparisons
    This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (June 2013) (Learn how and when to remove this template message)

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 used 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 apparent name, for example variable1 and Variable1. Visual Studio will correct (make uniform) the case of variables as they are typed in VB.NET. In some cases however, case sensitivity can be useful. C# programmers typically capitalize type and member names and leave field and variable names lowercase. This allows, for example, a fairly natural naming of method arguments: public int CalculateOrders(Customer customer). This can, however, 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.

Visual Basic is not case sensitive, which means that any combinations of upper and lower case letters in keywords are acceptable. 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 that the default 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 not 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.
    This article may contain excessive, poor, irrelevant, or self-sourcing examples. Please improve the article by adding more descriptive text and removing less pertinent examples. See Wikipedia's guide to writing better articles for further suggestions. (February 2012)
C#     Visual Basic .NET

// Single line comment

/* Multi-line comment
   line 2
   line 3 */

/// XML single line comment

/** XML multi-line comment
    line 2
    line 3 */

   multi-line comment via pre-processing
   line 2
   line 3


' Single line comment

''' XML 1st line comment
''' XML 2nd line comment
''' XML 3rd line comment

   multi-line comment via pre-processing
   line 2
   line 3
#End If

Intra-line comments not available
C#     Visual Basic .NET

if (condition) {
    // condition is true
} else if (othercondition) {
    // condition is false and othercondition is true
} else {
    // condition and othercondition are false


If condition Then
    ' condition is true
ElseIf othercondition Then
    ' condition is false and othercondition is true
    ' condition and othercondition false
End If

C#     Visual Basic .NET

for (int i = 0; i < number; ++i) {
    // loop from zero up to one less than number


For i As Integer = 0 To number - 1
    ' loop from zero up to one less than number

for (int i = number; i >= 0; --i) {
    // loops from number down to zero


For i As Integer = number To 0 Step -1
    ' loops from number down to zero

for (int i = 0; i <= 20; i += 2) {
    // loops from 0 to 20 by 2's


For i As Integer = 0 To 20 Step 2
    ' loops from 0 to 20 by 2's

break; //breaks out of a loop


Exit For 'breaks out of a for loop

Exit While 'breaks out of a while loop

Exit Do 'breaks out of a do loop

Primitive types
C#     Visual Basic .NET

if (a == b) {
    // equal


If a = b Then
    ' equal
End If

if (a != b) {
    // not equal


if (!(a == b)) {
    // not equal


If a <> b Then
    ' not equal
End If


If Not a = b Then
    ' not equal
End If


if (a == b & c == d | e == f) {
    // non-short-circuiting boolean operators


If a = b And c = d Or e = f Then
    ' non-short-circuiting boolean operators
End If


if (a == b && c == d || e == f) {
    // short-circuiting boolean operators


If a = b AndAlso c = d OrElse e = f Then
    ' short-circuiting boolean operators
End If

Object types
C#     Visual Basic .NET

if (object.ReferenceEquals(a, b)) {
    // variables refer to the same instance


If a Is b Then 'Can also be written as If Object.ReferenceEquals(a, b) Then
    ' variables refer to the same instance
End If

if (!object.ReferenceEquals(a, b)) {
    // variables do not refer to the same instance


If a IsNot b Then
    ' variables do not refer to the same instance
End If

if (a == b) {
    // instances are equivalent


If a = b Then
    ' instances are equivalent
End If

if (a != b) {
    // not equivalent


If a <> b Then
    ' not equivalent
End If

var type = typeof(int);


Dim type = GetType(Integer)

if (a is b) {
    // types of a and b are compatible


If TypeOf a Is b Then
    ' types of a and b are compatible
End If

if (!(a is b)) {
    // types of a and b are not compatible


If Not TypeOf a Is b Then
    ' types of a and b are not compatible
End If

Adoption and community support

Both C# and VB.NET have high adoption rates, and very active developer communities and Microsoft fully supports both communities. .NET Framework developers widely use both VB.NET and C# as primary languages.[17][18] However, C# has more community activity on the Internet and there are more books available for C#. This may indicate either that there is more adoption of C# or that users need more help with it.