The latest evolution of VB in Visual Studio will bring with it a bundle of C# functionality, nudging the two languages even closer together. To ensure we're ready to make the most of these enhancements, Hima Vejella takes us through each new feature.
Introduction
The constant debate between C# and VB developers over which language might be the best is a tough one to resolve, as both of the languages have their own strengths and, when you get down to it, are equally competent. Thus far, the feature split has been an issue in both directions. For example, C# 3.0’s collection initializers feature, which enable it to define the contents of a collection at the same time as declaring it, is not supported in Visual Basic 9.The same is true of auto-implemented properties, which specify property procedures without needing to specify get or set. As a quick example going the other way, Visual Basic supports optional parameters (which can be omitted based on requirement) in methods, whereas C# 3.0 does not.
However, both sides should be interested to hear that Microsoft is now trying to have all the features and strengths common to both the languages. As a quick example, C# 4.0 now supports optional parameters (as described above) as well as named parameters ( which are declared with default values), but that’s just scratching the surface. The recent merging of the Visual Basic and C# teams will hopefully help to ensure that both languages grow and evolve together, and Visual Basic has already been updated to include a number of C# features that it was sorely missing. In this article, I’ll give you an overview of all the features, which have been added as part of VB 2010 and .NET4 in the Visual Studio 2010 IDE, and give some quick demonstrations of how they’ll save developers time, and allows us to be more productive at the same time as writing more elegant code.
1. Using implicit line continuation
To start with, say goodbye to the underscore which needed to be inserted after each connected line in previous versions of Visual Studio. Now the VB 2010 compiler can recognize the ‘_’ character as being implicit, so we can use it:
- Within XML literals(before or after an embedded <%= or %>expression), LINQ Queries and Query operators;
- After open parentheses, open curly brace attributes, Commas ,binary operators, Is and Is Not operators;
- Before closing parentheses and closing curly brace braces;
- After the assignment operator (“=”), which you can find a more detailed explanation of on MSDN.
This feature has been one of the top requests from VB.NET developers, and thankfully we now don’t need to have underscored characters for the line breaks to integrate:
'get files from current directory
Dim Files =From file In
My.Computer.Filesystem.GetFiles(CurDir)
Order By file
Select file
However, bear in mind that this only works in the circumstances I’ve mentioned above, so the code below is still a compiler error, and is not a recommended convention, anyway:
Figure 1. Implicit line continuation won’t save you from all your compiler errors.
As the underscore has not been removed from every single place in VB, this is a language feature which should actually be considered as an IDE enhancement. In any case, the moment we press enter, the control is now aligned to the end of the parameter, which is much more user-friendly.
2. Auto - Implemented Properties
Auto-implemented properties is a feature which was available in C# 3.0, and, in case you’re not aware of it, offers us a way to specify a property of a class without having to write the code to Get and Set it; it’s basically the ability to declare a property without declaring a separate field to store the value. The automatically-implemented properties work the same as if the developer had declared a private field to hold the data and implement simple “getters” as well as “setters”, and are called in exactly the same way as traditional properties, as well as being a replacement of property procedures. If a more complex logic is required for property access, then traditional properties, which store data in private fields, can be created as well. Here’s an example of auto-implemented properties:
Public Class Employee
Property EmpID As Integer
Property EmpSal As Double
Property EmpName As String
End Class
To clearly illustrate this new language feature, in case you’re not familiar with Visual Basic, I’ll show you the equivalent of the code above, as written in older versions of Visual Studio:
Public Class Employee
Private EmpID As Integer
Private EmpSal As Double
Private EmpName As String
'Implementing property EMPID
Property EmployeeID() As Integer
Get
Return EmpID
End Get
Set(ByVal value As Integer)
EmpID = value
End Set
End Property
'Implementing Property EMPSal
Property EmployeeSal() As Double
Get
Return EmpSal
End Get
Set(ByVal value As Double)
EmpSal = value
End Set
End Property
'Implementing Property EMPName
Property EmployeeName() As String
Get
Return EmpName
End Get
Set(ByVal value As String)
EmpName = value
End Set
End Property
End Class
We can see that not only are three properties implemented in just 3 lines of code, but the code maintainability and overhead of declaring and implementing property procedures has now become significantly easier.
Auto- Implemented properties with default values
As part of this elegant and powerful new functionality, we can declare a property with a default value in a single line; for example:
Public Property EmployeeID As Integer = “1234”
Also based on the feedback from Visual Basic developers, this feature has been made available in Visual Studio 2010 to save time and improve productivity, so the previously laborious property implementations can now be replaced with simple, one-line declarations.
3. Collection Initializers
Collection Initializers enable developers to save significant amounts of time by declaring and then directly initializing list contents, without the need through the long process of instantiating the list, individually “newing up” each item, and then adding the items to the list. Collection initializers were another C# 3.0 feature which has now been brought across to VB10, and here’s an example of how we can use them to create a collection and populate it with an initial set of values:
Dim Fruits = New List(OfString) From
{
"Pine Apples",
"Mangoes",
"Grapes",
"Apples",
"Oranges"
}
Of, if you’d like a slightly more involved example:
Private Function CreateAccountList() As List(Of Employee)
Dim EmployeesList As New List(Of Employee) From {
New Employee With {
.EmpID = 1,
.EmpSal = 400000,
.EmpName = "Sukanya"
},
New Employee With {
.EmpID = 2,
.EmpSal = 900000,
.EmpName = "Vamshi"
},
New Employee With {
.EmpID = 3,
.EmpSal = 100000,
.EmpName = "Sudhakar"
}
}
Return EmployeesList
End Function
As you can see, we can simply create a collection of List (Employee), and each value which is supplied in the collection initializer is passed to the corresponding Add method of the collection. This functionality is not just limited to lists, but could also be used to create something like a dictionary (just as an example). Jason Olson gives some great examples of what this new functionality can achieve in his“10-4” episode on Channel 9.
4. Array Literals
Array literals in Visual Basic 10.0 provide a shortcut mechanism for declaring and filling arrays of types that can be inferred by the compiler. Examples are as below:
Dim IntegerArray = {1, 2, 3, 4, 5} 'compiler infers automatically as Integer
Dim DoubleArray = {1.4, 2.3, 3.5} 'compiler infers automaticallyas Double
Dim StringArray = {"Hima", "Jacob", "Pinal"} 'compiler infers automatically as String
Now the question is, what will the compiler infer if the data types are mixed?
Dim DIArray = {1,2.5,2,4.5} 'compiler infers as double
In the above example, the compiler infers the datatype as double, and does so by examining each array element datatype and using the dominant datatype to make its inference. Consider the below example; what if string and number datatypes are mixed equally?
Dim ArrayLiteralObject = {1, "Hima"} 'infers Object() (warning with Option Strict On)
Unsurprisingly, if we mix these datatypes, the compiler cannot make any specific inferences without the risk of potentially loosing the data due to narrow type conversion of string to integer or vice versa.
Figure 2. The compiler is able to handle arrays containing mixed datatypes by inferring them to be Objects.
Hence the entire array is treated as an Object, although it’s still recommended to use types in isolation with respect to a individual arrays. Also, in the example in figure 2, the compiler will generate a warning if OPTION STRICT is ON, and will only attempt to infer the type of objects if OPTION STRICT is OFF.
In addition to this inference functionality, we can also use nested array literals to create multidimensional arrays as below:
Figure 3. A MultiDimensional array, created using array literals
Figure 4. A Jagged array, created using array literals
To give you a concrete example of how this will slim down your code, for an array declaration of something like Employee Salary, we would previously have used the following code:
Dim EmployeeSal(5) As String
EmployeeSal(0) = 40000
EmployeeSal(1) = 50000
EmployeeSal(2) = 60000
EmployeeSal(3) = 45000
EmployeeSal(4) = 25000
However, with the help of the array literals which we’ve just learnt about, the same code can now be written more simply as:
Dim EmployeeSal = {40000, 50000, 60000, 45000, 25000}
We can also declare auto-implemented properties using array literals:
Property EmployeeID AsInteger() = {687, 546, 771}
5. Multiline Lambdas
We can now pass values from the current scope to a Lambda expression, which is a single or multi line anonymous function inside another function, used wherever a delegate is valid. A multiline lambda function is simply a lambda expression representing a function containing one or more statements. These provide developers with an elegant way of expressing logic locally, rather than splitting it out across several methods.
Creating and Assigning a Multiline Lambda
Below is an example of a multiline lambda function, created and assigned to a variable. As mentioned earlier, it does not require line continuation characters, as these are now implicit in VB 10.0
Sub Main()
'Single line Lambda
'Dim Square = Function(x) x * x
'Multiline Lambda
Dim Cube = Function(x)
Return (x * x * x)
End Function
' Use the lamda as inline and display it's result
Console.WriteLine("The Cube result is" &; Cube(11))
Console.ReadLine()
End Sub
The compiler will infer the parameters and return types where possible, just like in regular lambdas. Moreover, whenever we refer to the declared lambda expression variable, the lambda expression is invoked, and the “Function” keyword is responsible for creating a multiline lambda that returns a value.
Expression Statements
Visual Basic 9.0 required inline lambda expressions to return a value, such that, for example, the following line would throw an error, as it does not support expressions that returned a value:
Greatersalary.ForEach(Sub(EmployeSal)
MessageBox.Show(EmployeSal)
End Sub)
Visual Basic 10.0 now comes with better support for lambdas, and they now can contain expressions that don’t return a value, as the Sub keyword indicates below:
Property Sallimit As Integer
Private Sub btnSubmit_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSubmit.Click
SalLimit = 40000
' Declare an array of integers as emp salary
Dim EmployeeSal = {40000, 50000, 60000, 45000, 25000}
' Use a multiline Sub lambda to iterate the EmpSal array and find the salary >40000
Dim Greatersalary = EmployeeSal.Where(
Function(EmployeSal)
Return (EmployeSal > SalLimit)
End Function).ToList()
'display the Employeesal by iterating the lambda expression.
Greatersalary.ForEach(Sub(EmployeSal)
MessageBox.Show(EmployeSal)
End Sub)
End Sub
If you’re wondering how you might put this new functionality to use, say we have an array of employee salaries and we want to print all salaries greater than 40,000.Multiline lambda expression is used here to pass into the EmployeeSal.
A multiline lambda expression is used in conjunction with an if else condition to get string that starts with ‘H’ or ‘S’ is described in the code below
Dim StringStartWith = Function(s As String)
If s.StartsWith("H") Then
Return "Start with H - " & s
ElseIf s.StartsWith("S") Then
Return "Start with S " & s
Else
Return s
End If
End Function
MsgBox(StringStartWith("Hima"))
Bear in mind that Lambda expressions cannot have modifiers, Overloads, Overrides, generic parameters, optional or paramarray parameters. In addition, the data type of a lambda expression parameter can either be inferred or be specified using the As keyword, but we have to either specify all the parameter data types, or they all need to be inferred.
6. Interoperability with dynamic languages
Visual Studio 2010 ships with a new platform called the Dynamic Language Runtime which, as you might have guessed, makes it easier to establish interoperability with dynamic languages such as Python and Ruby. Visual Basic 2010 fully supports the DLR, allowing developers to use libraries and frameworks written in these dynamic languages. For example, the following code snippet calls a method defined in a Python library “lib.py”:
Dim MathObj As Object = python.UseFile("lib.py")
Dim Number1 = 33
Dim Number2 = 3
Dim Number3 = MathObj.PowerOf(Number1, Number2)
MessageBox.Show(Number3)
7. VB.NET Snippets
There are now additional Code snippets in VB.NET which significantly speed up development when working with ASP.Net MVC2, LINQ, Designer Patterns, Error Handling, Office Dev, WPF etc. Simply right-click in the code behind file, select Insert Snippet, and then select the snippet that is required. Code snippets can be created by developers and then easily re-used across multiple projects. Alessandro English has created an addin for VS2010 to add XAML code snippets into the Visual Studio 2010 code editor for XAML, when working in WPF and Silverlight projects. There is also a snippet editor available on Codeplex, which can be used for creating and managing code snippets in Visual Studio.
Figure 5. A demonstration of the code snippets functionality
8. Parallel Support
Visual Studio 2010 and the .NET Framework 4 now provide a runtime, new class library types and analytic tools which fully support parallel programming. This is an excellent feature, and it allows us to develop applications that utilize multiple CPU Cores, and thus enables multiple threads to be executed simultaneously. This enhancement will allow us to take full advantage of the available modern hardware. This support can be accessed using the Parallel object of the.NET 4.0 Framework, but we need to import the relevant namespace at the start of our code:
Imports System.Threading
In this simple example, the following bit of code (as seen in figure 6.), placed the code inside the Main () routine, will output two strings in parallel on the console.
Sub Main()
Tasks.Parallel.Invoke(
Sub()
Thread.Sleep(5500)
Console.WriteLine("Simple-Talk")
End Sub,
Sub()
Thread.Sleep(2000)
Console.WriteLine("Hima Vejella, The Author at Simple-Talk")
End Sub)
End Sub
As you can see, the Invoke () method is used to execute the tasks in parallel, and when the code is run we can see the two strings on the console output screen as below:
Figure 6. Employing the new parallel development functionality to reverse the writing order.
Parallel programming can be debugged and examined clearly with the help of this new VS2010 feature, using the Parallel Tasks and Parallel Stacks windows. If necessary, we can navigate between instances with CTRL+SHIFT+DOWN ARROW or CTRL+SHIFT+UP ARROW. The ability to do parallel development will undoubtedly help us to write elegant, and scalable code without having to work directly with threads or locks.
9. Compiling without PIAs (or Embed Interop Types)
While working with VSTO, using .NET to code an application against the Microsoft Office, or working with any application that performs COM Interop, Object Model Primary Interop Assemblies (PIAs)need to be deployed to end-user machines to allow data to move between COM and .NET. Unfortunately, these assemblies are an additional deployment concern, can cause versioning problems, and are also very large, and so deploying them is often a similarly large headache.
Thankfully, Visual Basic 10 now allows these applications to be deployed without requiring PIAs to exist on the end user’s machine. This is done by generating local types to be responsible for performing the interop calls to the COM library. Even better, these types are inferred by the compiler, so that the Common Language Runtime (CLR) can identify them across assemblies, and only the PIA types which are absolutely necessary will be copied into the assemblies.
Figure 7. Accessing the properties of the project’s PIA reference
Figure 8. Adjusting the Embed Interop Types of the PIA reference
This can be achieved for existing projects by setting the Embed Interop Types property to true in the project’s Solution Explorer reference, although this property is set to True by default for new references. Simply open Solution Explorer, select the PIA reference in the project, Right-click on the reference and select properties of the reference , and then set Embed Interop Types to True in the window which will appear.
10. Optional Parameters can be Nullable
A limitation in earlier versions of VB was that optional parameters could not be nullable. Visual Basic 2010 now has the ability to define optional parameters of any value type, so now you can create method with optional parameters and also make them Nullable.
Sub GetEmpDetails(ByVal strEmail As String,
Optional ByVal strName As String = "Hima",
Optional ByVal intSalary As Integer? = 0,
Optional ByVal intAge As Integer? = Nothing)
End Sub
In this case, strName is an optional parameter that is passed with a default value, intSalary is of type Nullable(Of Integer) and intAge is a non-intrinsic type, but they can still be used as optional parameters.
Note
All the optional or default parameters need to be declared at the end of the parameter list, and we can, if we desire, have all the parameters of a method as optional, depending on the requirements we have in mind.
11. Generic Variance
Public Class Vegetable
Property Type As String
Property Seeds As Integer
Property Leaves As String
End Class
Public Class Potato
Inherits Vegetable
Public Property Branches As Integer
End Class
Now say we have a generic List(Of Potato) that will pass to a method that accepts an IEnumerable(Of Vegetable):
Sub Main()
Dim vegetables As New List(Of Potato) From
{
New Potato With {.Leaves = "Green", .Seeds = 10, .Type = "Boiled", .Branches = 2},
New Potato With {.Leaves = "Grey", .Seeds = 11, .Type = "Raw", .Branches = 5},
New Potato With {.Leaves = "Brown", .Seeds = 12, .Type = "Curry", .Branches = 6}}
GetAll(vegetables)
End Sub
Sub GetAll(ByVal list As IEnumerable(Of Potato))
For Each p In list
Console.WriteLine(p.Branches)
Console.WriteLine(p.Type)
Console.WriteLine(p.Leaves)
Next
Console.ReadLine()
End Sub
Even though the List implements IEnumerable and a Potato inherits from the Vegetable class, this will not work in Visual Studio 2008, but is now supported in Visual Basic 10 and also in C#4.0. Now we can declare covariant widening and narrowing generic types using the Out and In modifiers. This is because IEnumerable interface in the CLR 4.0 has been changed to designate a covariant generic type, and if you’d like to gain a more elaborate understanding of these concepts, then take a look at this article on Generic Co- and Contravariance.
Conclusion
With features available in C# and VB starting to converge, both languages will now start to evolve in concert, making a wider palette of options available to developers. Thankfully, you don’t have to only be targeting the .NET Framework 4 to be able to employ these latest Visual Basic enhancements, as they can be used in projects that target .NET Framework versions as far back as 2.0. There is, however, one exception to this backwards compatibility: the Embed Interop Types, which unfortunately has a dependency on types which are only available in the .NET Framework 4. That is, I feel, a small price to pay. If you want to enable this multi-targetting, you can do so by navigating to the Advanced Compile Options (double-click on the Project and look under the Compile tab), and selecting your targets from the combinations at the bottom of the window as shown below.
Figure 9. Enabling multi-targetting in VS2010
If you’d like to learn more about any of these new features and enhancements, there’s a detailed write-up of what’s new in Visual Basic 2010, by Jonathan Aneja, available on MSDN.
It’s also good to know that the feature swap is also going in the other direction, such as the support which has been added in C#4.0 for optional and named parameters, two features that are a part of VB 9.0. Now that we’ve seen what’s new in VB 2010, in my next article I will be rounding off the story by discussing the C# 4.0 enhancements added in VS2010.