Comparison of C sharp and Visual Basic .NET

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

[edit] Language Compatibility

Visual Basic and Visual Basic .NET are completely different languages and are not backwards-compatible. Visual Basic .NET shares only syntax similarities with Visual Basic. However some features of Visual Basic have been ported over to Visual Basic .NET and are not available to other .NET languages.

C# shares syntax similarities with Java. Both C# and Visual Basic .NET share structural similarities with other modern high level languages such as Java and C++. However the differences between Java and .NET are numerous, as can be seen in Comparison of Java and C Sharp.

[edit] 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, and should be able to expose the same level of power and usability.

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.

[edit] 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#^[1]. 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

[edit] Background Compiler

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 is made more difficult by the need to frequently rebuild the solution in order to highlight compilation errors. Such is not the case with Visual Basic because the Error List panel is syncronised with the background compiler.

[edit] 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.

[edit] Features of Visual Basic .NET not found in C#

• Variables can be declared using the WithEvents construct. This constuct 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
• Support for optional variables (this will also be available in C# beginning in version 4.0^[2]). This is typically used to provide easy interoperability with native code
• Marshalling an object for multiple actions using an unqualified dot reference. This is done using the With ... End With structure
• Visual Studio will automatically insert the method signatures for any methods required by an interface
• IsNumeric evaluates whether a string can be cast into a numeric value (the equivalent for C# requires a minimum of 3 lines of code using int.TryParse)

[edit] Features of C# not found in Visual Basic .NET

• Allows blocks of unsafe code (like C++/CLI) via the unsafe keyword
• Anonymous methods
• Partial Interfaces
• Iterators and the yield keyword
• 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
• Auto-Implemented Properties (as of C# 3.0^[3])

[edit] Criticisms 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.

[edit] Criticisms 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.
• Addition and string concatenation use the same token, +. Whereas Visual Basic .NET has separate tokens, + for addition, and & for concatenation.
• In Visual Basic .NET property methods may take parameters

[edit] 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).

[edit] Keywords

Keywords are very different between the two languages.

• Me vs this - a self-reference to the current object instance
• MyBase vs base - for referring to the base class from which the current class is derived
• Shared vs static - for declaring methods that do not require an explicit instance of an object
• 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
• MustInherit vs abstract - prevents a class from being directly instantiated, and forces consumers to create objects references to only derived classes
• MustOverride vs abstract - for forcing derived classes to override this method
• Overridable vs virtual - declares a method as being able to be overridden in derived classes

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.

[edit] Comments

// Single Line Comment

' Single Line Comment

/* Multi-line
comment */

/// Single Line XML Comment

''' Single Line XML Comment

/** Multi-line
XML comment */

[edit] Conditionals

if (condition)
{ 
    // condition is true  
}

If condition Then 
    ' condition is true
End If

if (condition)
{ 
    // condition is true 
}
else
{ 
    // condition is false 
}

If condition Then 
    ' condition is true
Else
    ' condition is false
End If

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

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

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
Else
    ' condition and othercondition false
End If

[edit] Loops

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
Next

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
Next

[edit] Comparers

if (a == b)   
{
    // equal
}

If a = b Then
    ' equal
End If

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

If a <> b Then
    ' not equal
End If

if ((a == b) & (c == d) | (e == f))
{
    // multiple comparisons
}

If a = b And c = d Or e = f Then
    ' multiple comparisons
End If

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

If a = b AndAlso c = d OrElse (e = f) Then
    ' short-circuiting comparisons
End If

if (a is b)
{
    // type compatibility operator
}

If TypeOf a Is b Then
    ' type compatibility operator
End If

[edit] Adoption and community support

Both C# and VB.Net have high adoption rates, and very active developer communities and Microsoft fully supports both communities. However, C# does have an advantage in terms of the level of community activity on the Internet. Also, there are more books available for C# than VB.Net, and publishers report that C# books significantly outsell the VB.Net counterparts.

Examples of the increased community and industry adoption include:

• According to a survey conducted by Visual Studio Magazine (which self-identifies as a VB-centric publication) "41 percent said they used C#, 34 percent programmed in VB.NET, while 25 percent responded with 'other.'"^[4]
• Stephen Wiley, marketing product manager at Apress has reported "C# titles outsell VB.NET title books handily, by somewhere between a 2–1 and 3–1 margin."^[4]
• MSDN Blogs, the blogging site for Microsoft employees, has 27,500 posts that discuss C#, while only 8,880 mention VB.Net (as of November 15, 2007)
• Google Groups, a Usenet search engine, returns 36,900 hits for "VB .Net", and 65,700 for C#
• Amazon.com returns 9,923 hits for C#, and 2,149 hits for "Visual Basic .Net" (as of November 15, 2007).
• Telerik Survey 2008 suggested that C# (63%) had surpassed VB.NET (34%) as the primary programming language.^[5]

Counter-examples:

• Visual Basic Express is the most popular download of all the Visual Studio Express downloads.^[4]

[edit] Other languages

[edit] C++/CLI (formerly Managed C++)

C++/CLI (a replacement for Managed Extensions for C++) does not have the adoption rate of C# or VB.NET, but does have a significant following. C++/CLI syntactically, stylistically, and culturally is closest to C#. However, C++/CLI stays closer to its C++ roots than C# does. C++/CLI directly supports pointers, destructors, and other unsafe program concepts which are not supported or limited in the other languages. It allows the direct use of both .NET code and standard C++ code. C++/CLI is used for porting native/legacy C++ applications into the .NET framework, or cases where the programmer wants to take more control of the code; but this control comes at a significant cost of ease of use and readability. Many of the automated tools that come with Visual Studio have reduced functionality when interacting with C++ code. This is because reflection cannot provide as much information about the code as it can for C# and VB.net

[edit] J#

J# runs a distant fourth in terms of adoption. J# is a language primarily designed to ease the transition of Java applications to the .NET framework; it allows developers to leave much of their Java or J++ code unchanged while still running it in the .NET framework, thus allowing them to migrate small pieces of it into another .NET language, such as C#, individually. J# does not receive the same level of updates as the other languages, and does not have the same level of community support. For example, Visual Studio 2005 Team System supports automatic generation of Unit Tests in C#, VB.Net, and C++, but excludes J#. J# has been discontinued and is not included with Visual Studio 2008.

[edit] Additional .NET languages

Main article: CLI Languages

[edit] CIL

All .NET languages compile down to Common Intermediate Language (CIL), which contains rich metadata and is functionally and logically equivalent to the original .NET language code. For these reasons, while it is possible to code directly in CIL, it is rarely done. The equivalency of CIL to .NET language code permits tools such as .NET Reflector to transform a .NET assembly into source code that is nearly identical to the original source. Code obfuscators are often used to guard against this, and operate by directly modifying the CIL of an assembly in order to make it difficult or impossible to de-compile to a higher level .NET language.

[edit] References

[edit] External links

• Microsoft Visual Studio 2005 Language Equivalents
• Microsoft VSTO Programming with Visual Basic Versus C#
• CodeProject VB vs C#
• Cultural differences between C# and VB.NET
• Syntactical differences between C# and VB.NET
• Free online C# to VB.NET code converter
• Free online VB.NET to C# code converter
• Extension Method Handling - C# vs VB.NET