.NET Languages

This chapter is from the book

Understanding .NET: A Tutorial and Analysis

Learn More Buy

This chapter is from the book

This chapter is from the book 

Understanding .NET: A Tutorial and Analysis

Learn More Buy

Visual Basic.NET

Visual Basic is by a large margin the most popular programming language in the Windows world. Visual Basic.NET (VB.NET) brings enormous changes to this widely used tool. Like C#, VB.NET is built on the Common Language Runtime, and so large parts of the language are effectively defined by the CLR. In fact, except for their syntax, C# and VB.NET are largely the same language. Because both owe so much to the CLR and the .NET Framework class library, the functionality of the two is very similar.

VB.NET can be compiled using Visual Studio.NET or vbc.exe, a command-line compiler supplied with the .NET Framework. Unlike C#, however, Microsoft has not submitted VB.NET to a standards body. Accordingly, while the open source world or some other third party could still create a clone, the Microsoft tools are likely to be the only viable choices for working in this language, at least for now.

A VB.NET Example

The quickest way to get a feeling for VB.NET is to see a simple example. The example below implements the same functionality as did the C# example shown earlier in this chapter. As you'll see, the differences from that example are largely cosmetic.

' A VB.NET example 
Module DisplayValues 
Interface IMath 
   Function Factorial(ByVal F As Integer) As 
      Integer 
   Function SquareRoot(ByVal S As Double) As 
      Double 
End Interface 
Class Compute 
    Implements IMath 
    Function Factorial(ByVal F As Integer) As 
      Integer Implements IMath.Factorial 
      Dim I As Integer 
      Dim Result As Integer = 1 

      For I = 2 To F 
         Result = Result * I 
      Next 
      Return Result 
    End Function 
    Function SquareRoot(ByVal S As Double) As 
         Double Implements IMath.SquareRoot 
         Return System.Math.Sqrt(S) 
    End Function 
End Class 
Sub Main() 
    Dim C As Compute = New Compute() 
    Dim V As Integer 

    V = 5 
    System.Console.WriteLine("{0} factorial:
        {1}", V, C.Factorial(V)) 
    System.Console.WriteLine("Square root of 
        {0}: {1:f4}", V, C.SquareRoot(V)) 
  End Sub 
End Module 

The example begins with a simple comment, indicated by the single quote that begins the line. Following the comment is an instance of the Module type that contains all of the code in this example. Module is a reference type, but it's not legal to create an instance of this type. Instead, its primary purpose is to provide a container for a group of VB.NET classes, interfaces, and

other types. In this case, the module contains an interface, a class, and a Sub Main procedure. It's also legal for a module to directly contain method definitions, variable declarations, and more that can be used throughout the module.

The module's interface is named IMath, and as in the earlier C# example, it defines the methods (or in the argot of Visual Basic, the functions) Factorial and SquareRoot. Each takes a single parameter, and each is defined to be passed by value, which means a copy of the parameter is made within the function. Passing by value is the default, so the example would work just the same without the ByVal indications. It's worth pointing out that passing by reference, in which changes to a parameter are visible to its caller when the method returns, is the default in Visual Basic 6. This difference is one example of how this language was changed to match the underlying semantics of the CLR.

The class Compute, which is the VB.NET expression of a CTS class, implements the IMath interface. Each of the functions in this class must explicitly identity the interface method it implements. Apart from this, the functions are just as in the earlier C# example except that a Visual Basic–style syntax is used. Note particularly that the call to System.Math.Sqrt is identical to its form in the C# example. C#, VB.NET, and any other language built on the CLR can access services in the .NET Framework class library in much the same way.

This simple example ends with a Sub Main procedure, which is analogous to C#'s Main method. The application begins executing here. In this example, Sub Main creates an instance of the Compute class using the VB.NET New operator (which will eventually be translated into the MSIL instruction newobj), then declares an Integer variable and sets its value to 5.

As in the C# example, this simple program's results are written out using the WriteLine method of the Console class. Because this method is part of the .NET Framework class library rather than any particular language, it looks exactly the same here as it did in the C# example. Not too surprisingly, then, the output of this simple program is

5 factorial: 120 
Square root of 5: 2.2361 

just as before.

To someone who knows Visual Basic 6, VB.NET will look familiar. To someone who knows C#, VB.NET will act in a broadly familiar way, since it's built on the same foundation. But VB.NET is not the same as either Visual Basic 6 or C#. The similarities can be very helpful in learning this new language, but they can also be misleading. Be careful.

VB.NET Types

Like C#, the types defined by VB.NET are built on the CTS types provided by the CLR. Table 4-2 shows most of these types and their VB.NET equivalents.

Notice that some types, such as unsigned integers, are missing from VB.NET. Unsigned integers are a familiar concept to C++ developers, but not to typical Visual Basic 6 developers. The core CTS types defined in the System namespace are available in VB.NET just as in C#, however, so a VB.NET developer is free to declare an unsigned integer using

Dim J As System.UInt32 

Unlike C#, VB.NET is not case sensitive. There are some fairly strong conventions, however, which are illustrated in the example shown earlier. For people coming to .NET from Visual Basic 6, this case insensitivity will seem entirely normal. It's one example of why both VB.NET and C# exist, since the more a new

Table 4-2 Some CTS Types and Their VB.NET Equivalents

environment has in common with the old one, the more likely people will be to adopt it.

Classes

VB.NET classes expose the behaviors of a CTS class using a VB-style syntax. Accordingly, VB.NET classes can implement one or more interfaces, but can inherit from at most one other class. In VB.NET, a class Calculator that implements the interfaces IAlgebra and ITrig and inherits from the class MathBasics looks like this:

Class Calculator 
    Inherits MathBasics 
    Implements IAlgebra 
    Implements Itrig
 . . . 
End Class 

Note that, as in C#, the base class must precede the interfaces. Note also that any class this one inherits from might be written in VB.NET or in C# or perhaps in some other CLR-based language. As long as the language follows the rules laid down in the CLR's Common Language Specification, cross-language inheritance is straightforward. Also, if the class inherits from another class, it can potentially override one or more of the type members, such as a method, in its parent. This is only allowed if the member being overridden is declared with the keyword Overridable, analogous to C#'s keyword virtual.

VB.NET classes can be labeled as NotInheritable or MustInherit, which mean the same thing as sealed and abstract, respectively, the terms used by the CTS and C#. VB.NET classes can also be assigned various accessibilities, such as Public and Friend, which largely map to visibilities defined by the CTS. A VB.NET class can contain variables, methods, properties, events, and more, just as defined by the CTS. Each of these can have an access modifier specified, such as Public, Private, or Friend. A class can also contain one or more constructors that get called whenever an instance of this class is created. Unlike C#, however, VB.NET does not support operator overloading. A class can't redefine what various standard operators mean when used with an instance of this class.

Interfaces

Interfaces as defined by the CTS are a fairly simple concept. VB.NET essentially just provides a VB-derived syntax for expressing what the CTS specifies. Along with the interface behavior shown earlier, CTS interfaces can inherit from one or more other interfaces. In VB.NET, for example, defining an interface ITrig that inherits from the three interfaces ISine, ICosine, and ITangent, would look like this:

Interface ITrig 
   Inherits ISine 
   Inherits ICosine 
   Inherits ITangent
 ... 
End Interface 

Structures

Because both are based on the structure type defined by the CTS, structures in VB.NET are very much like structures in C#. Like a class, a structure can contain fields, members, and properties, implement interfaces, and more. VB.NET structures are value types, of course, which means that they can neither inherit from nor be inherited by another class. A simple employee structure might be defined in VB.NET as follows:

Structure Employee 
    Public Name As String 
    Public Age As Integer 
End Structure 

To keep the example simple, this structure contains only data members. As described earlier, however, CTS structures—and thus VB.NET structures—are in fact nearly as powerful as classes.

Delegates

The idea of passing an explicit reference to a procedure or function, then calling that procedure or function, is not something that the typical Visual Basic programmer is accustomed to. Yet the CLR provides support for delegates, which allow exactly this. Why not make this support visible in VB.NET?

VB.NET's creators chose to do this, allowing VB.NET programmers to easily create callbacks and other event-oriented code. Here's an example, the same one shown earlier in C#, of creating and using a delegate in VB.NET:

Module Module1 
    Delegate Sub SDelegate(ByVal S As String) 
    Sub CallDelegate(ByVal Write As SDelegate) 
       System.Console.WriteLine("In CallDelegate") 
       Write("A delegated hello") 
    End Sub 
    Sub WriteString(ByVal S As String) 
       System.Console.WriteLine("In WriteString: 
           {0}", S) 
    End Sub 
    Sub Main() 
       Dim Del As New SDelegate(AddressOf 
           WriteString) 
    CallDelegate(Del) 
    End Sub 
End Module 

Although it's written in VB.NET, this code functions exactly like the C# example shown earlier in this chapter. Like that example, this one begins by defining SDelegate as a delegate type. As before, SDelegate objects can only contain references to methods that take a single String parameter. In the example's Sub Main method, a variable Del of type SDelegate is declared, then initialized to contain a reference to the WriteString subroutine. (A VB.NET subroutine is a method that, unlike a function, returns no result.) Doing this requires using VB.NET's AddressOf keyword before the subroutine's name. Sub Main then invokes CallDelegate, passing in Del as a parameter.

CallDelegate has an SDelegate parameter named Write. When Write is called, the method in the delegate that was passed into CallDelegate is actually invoked. In this example, that method is WriteString, and so the code inside the WriteString procedure executes next. The output of this simple example is exactly the same as for the C# version shown earlier in this chapter:

In CallDelegate 
In WriteString: A delegated hello 

Delegates are another example of the additional features Visual Basic has acquired from being rebuilt on the CLR. While this rethinking of the language certainly requires lots of learning from developers using it, the reward is a substantial set of features.

Arrays

Like arrays in C# and other CLR-based languages, arrays in VB.NET are reference types that inherit from the standard System.Array class. Accordingly, all of the methods and properties that class makes available are also usable with any VB.NET array. Arrays in VB.NET look much like arrays in earlier versions of Visual Basic. Perhaps the biggest difference is that the first member of a VB.NET array is referenced as element zero, while in previous versions of this language, the first member was element one. An array can be declared by specifying both its size and the type of its members. For example, the following statement declares an array of ten integers:

Dim Ages(10) As Integer 

Unlike C#, there's no need to explicitly create an instance of the array using New. It's also possible to declare an array with no explicit size, then later use the ReDim statement to specify how big it will be. For example, this code

Dim Ages() as Integer
ReDim Ages(10) 

results in an array of ten integers just as in the previous example. Note that the index for both of these arrays goes from 0 to 9, not 1 to 10.

VB.NET also allows multidimensional arrays. For example, the statement

Dim Points(10,20) As Integer 

creates a two-dimensional array of integers with 10 and 20 elements, respectively. Once again, both dimensions are zero-based, which means that the indexes go from 0 to 9 in the array's first dimension and 0 to 19 in the second dimension.

VB.NET Control Structures

While the CLR says a lot about what a .NET Framework–based language's types should look like, it says essentially nothing about how that language's control structures should look. Accordingly, adapting Visual Basic to the CLR required making changes to its types, but the language's control structures are fairly standard. An If statement, for example, looks like this:

If (X > Y) Then 
   P = True 
Else 
   P = False 
End If 

while a Select Case statement analogous to the C# switch shown earlier looks like this:

Select Case X 
   Case 1 
      Y = 100 
   Case 2 
      Y = 200 
   Case Else 
      Y = 300 
End Select 

As in the C# example, different values of x will cause y to be set to 100, 200, or 300. Although it's not shown here, the Case clauses can also specify a range rather than a single value.

The loop statements available in VB.NET include a While loop, which ends when a specified Boolean condition is no longer true, a Do loop, which allows looping until a condition is no longer true or until some condition becomes true, and a For...Next loop, which was shown in the example earlier in this section. And like C#, VB.NET includes a For Each statement, which allows iterating through all the elements in a value of a collection type.

VB.NET also includes a goto statement, which jumps to a labeled point in the program, and a few more choices. The innovation in the .NET Framework doesn't focus on language control structures (in fact, it's not easy to think of the last innovation in language control structures), and so VB.NET doesn't offer much that's new in this area.

Other VB.NET Features

The CLR provides many other features, as seen in the description of C# earlier in this chapter. With very few exceptions, the creators of VB.NET chose to provide these features to developers working in this newest incarnation of Visual Basic. This section looks at how VB.NET provides some more advanced features.

Working with Namespaces

As mentioned in Chapter 3, namespaces aren't directly visible to the CLR. Just as in C#, however, they are an important part of writing applications in VB.NET. As shown earlier in the VB.NET example, access to classes in .NET Framework class library namespaces looks just the same in VB.NET as in C#. Because the Common Type System is used throughout, methods, parameters, return values, and more are all defined in a common way. Yet how a VB.NET program indicates which namespaces it will use is somewhat different from how it's done in C#. Commonly used namespaces can be identified for a module with the Imports statement. For example, preceding a module with

Imports System

would allow invoking the System.Console.WriteLine method with just

Console.WriteLine( . . .) 

VB.NET's Imports statement is analogous to C#'s using statement. Both allow developers to do less typing. And as in C#, VB.NET also allows defining and using custom namespaces.

Handling Exceptions

One of the greatest benefits of the CLR is that it provides a common way to handle exceptions across all .NET Framework languages. This common approach allows errors to be found in, say, a C# routine, then handled in code written in VB.NET. The syntax for how these two languages work with exceptions is different, but the underlying behavior, specified by the CLR, is the same.

Like C#, VB.NET uses Try and Catch to provide exception handling. Here's a VB.NET example of handling the exception raised when a division by zero is attempted:

Try 
   X = Y/Z 
Catch 
   System.Console.WriteLine("Exception caught") 
End Try 

Any code between the Try and Catch is monitored for exceptions. If no exception occurs, execution skips the Catch clause and continues with whatever follows End Try. If an exception occurs, the code in the Catch clause is executed, and execution continues with what follows End Try.

As in C#, different Catch clauses can be created to handle different exceptions. A Catch clause can also contain a When clause with a Boolean condition. In this case, the exception will be caught only if that condition is true. Also like C#, VB.NET allows defining your own exceptions, then raising them with the Throw statement. VB.NET also has a Finally statement. As in C#, the code in a Finally block is executed whether or not an exception occurs.

Using Attributes

Code written in VB.NET is compiled into MSIL, so it must have metadata. Since it has metadata, it also has attributes. The designers of the language provided a VB-style syntax for specifying attributes, but the end result is the same as for any CLR-based language: Extra information is placed in the meta-data of some assembly. To once again repeat an example from earlier in this chapter, suppose the Factorial method shown earlier in the complete VB.NET example had been declared with the WebMethod attribute applied to it. This attribute instructs the .NET Framework to expose this method as a SOAP-callable Web service, as is described in more detail in Chapter 7. Assuming the appropriate Imports statements were in place to identity the correct namespace for this attribute, the declaration would look like this in VB.NET:

Public Function <WebMethod()> Factorial(ByVal F As Integer) As 
Integer Implements IMath.Factorial 

This attribute is used by ASP.NET to indicate that a method contained in an .asmx page should be exposed as a SOAP-callable Web service. Similarly, including the attribute

<assembly:AssemblyCompanyAttribute("QwickBank")> 

in a VB.NET file will set the value of an attribute stored in this assembly's manifest that identifies QwickBank as the company that created this assembly. VB.NET developers can also create their own attributes by defining classes that inherit from System.Attribute, then have whatever information is defined for those attributes automatically copied into metadata. As in C# or any CLR-based language, custom attributes can be read using the GetCustomAttributes method defined by the System.Reflection namespace's Attribute class.

Attributes are just one more example of the tremendous semantic similarity of VB.NET and C#. While they look quite different, the capabilities of the two languages are very similar. Which one a developer prefers will be largely an aesthetic decision.