Features of Visual Basic .NET not
found in C#
- Variables can be declared using the With
Events 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)
-
- 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
- The My namespace
- COM
components and interoperability was more powerful in VB.NET as the Object
type is bound at runtime
- 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.C# emulates this functionality,using a
catch block followed by an if block. It is not just syntax sugar.
- With
instruction Executes a series of instructions repeatedly refer to a single
object or structure. (similar to the third bullet point above)
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.
- When
assigning a value to a variable with a different data type, VB.NET will coerec 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
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[15] and widely considered to be a
good practice to turn 'Option Strict' "on", due to the fact
it increases application performance, and eliminates the chance 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 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)
- String
concatenation can be performed using the numeric
addition token, +, in addition to the string concatenation token
&. Although these tokens are syntactically interchangeable, use
of the addition token should be confined to
mathematical operations.
- In Visual
Basic .NET property methods may take parameters.
- C# is
case-sensitive.
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 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.
