Professional ASP.NET 1.1 [Electronic resources] نسخه متنی

Visual Basic .NET

The latest version of Visual Basic is a major leap forward in terms of functionality, with several features added to take advantage of the Common Language Specification (CLS) and the CLR.

Each generation of a language brings improvements. To understand why Visual Basic .NET implements the changes it does, consider for a moment some of the problems associated with previous versions of Visual Basic:

• 
  

  The Visual Basic runtime libraries:These are relatively large DLLs incorporating the base functionality, and are required for all Visual Basic programs to run. Common complaints concerned the size of these DLLs, and versioning problems (different libraries for different versions of VB). You might think that these have just been replaced by the CLR, but the CLR is much more than this, and addresses far more than just VB. While size may still be considered an issue, the redistributable CLR is around 18 MB and supports multiple versions.



• 
  

  Poor object-oriented features:Object-oriented programming gurus criticized Visual Basic for its lack of 'proper' functionality – not providing features such as inheritance, overloading, and so on. Although these are valid points, many of the problems really stemmed from the capabilities of COM rather than Visual Basic itself.



• 
  

  Inability to create multi-threaded applications:With the introduction of Microsoft Transaction Server (MTS), n-tier architecture became a reality, and Visual Basic programmers started to get to grips with componentization. However, Visual Basic components were forced into an Apartment Threading model, a limitation that attracted much criticism from programmers who wanted to build multi-threaded components. Personally, I think much of this condemnation is misplaced, as I wonder how many people could actually write a fully threaded component (I'm not sure I could). Think about it – managing the threads, state, and so on, isn't easy.

All of these problems disappear in Visual Basic .NET. The runtime libraries are no longer needed because they're taken care of by the CLR, and the object-oriented features have been massively improved (partly because of CLR and CLS support) and the whole threading issue has gone away. With the CLR, you just don't need to think about threading (unless you want to). Let's look at some of the new features in Visual Basic .NET.

Object-Oriented Features

The OO features were probably one of the enhancements most requested by programmers. I remember being at a Microsoft event when Visual Basic 6 was in beta, and the most frequently asked question was whether inheritance will be supported. Since this is an intrinsic feature of the CLR, it is now supported, and classes are inheritable by default. In fact, since everything in .NET is class based, you have an enormous amount of flexibility, as you can not only extend and overload your own classes, but many system ones too.

Classes

As in previous versions of Visual Basic, classes are created using the Class statement. However, the syntax has changed a little:

[ Public | Private | Protected | Friend | Protected Friend ]
[Shadows]
[MustInherit | NotInheritable] Class className
 
End Class

Let's look at the keywords in more detail:

Within a class, the member definition follows the same rules. Members that are not explicitly declared with a keyword are Public by default.

For example:

Public Class Calculator
 
' implementation goes here
 
End Class

Or:

Protected MustInherit Class Calculator
 
' abstract implementation goes here
 
End Class

Methods

Methods are declared as a Sub or a Function, but there are improvements to fit in with the inheritance rules. The syntax for a Sub is now:

[Overloads | Overrides | Overridable | NotOverridable | MustOverride |
 
Shadows | Shared]
 
[Private | Public | Protected | Friend | Protected Friend]
 
Sub subName [(parameters)]
 
End Sub

The syntax for a Function is:

[Overloads | Overrides | Overridable | NotOverridable | MustOverride |
 
Shadows | Shared]
 
[Private | Public | Protected | Friend | Protected Friend]
 
Function functionName [(parameters)] [As type]
 
End Function

The various keywords are described in the following table:

For example:

Public Class Calculator
Public Function Add(Op1 As Double, Op2 As Double) As Double
Return Op1 + Op2
End Function
End Class

Properties

Properties can be implemented as Public member variables or by using the Property statement. For example:

Public Class Calculator
Public Op1 As Double
Public Op2 As Double
Public Function Add() As Double
Return Op1 + Op2
End Function
End Class

The class could be used in the following way:

Dim calc As New Calculator
calc.Op1 = 123
calc.Op2 = 456
Response.Write(calc.Add())

The preceding example uses public variables. The alternative (and preferred) approach is to use Property, the syntax of which has changed as follows:

[Default | ReadOnly | WriteOnly] Property propertyName ([parameters])
[As type]
Get
' code for getting the property
End Get
 
Set
' code for setting the property
End Set
 
End Property

A property defined as ReadOnly can only have the Get block. Likewise, a property with only a Get block must be marked as ReadOnly. The same applies for WriteOnly and the Set block. There is also no longer a Let option, as Set provides the same functionality.

For example:

Public Class Calculator
Private _op1 As Double
Private _op2 As Double
 
Public Property Operand1() As Double
Get
Operand1 = _op1
End Get
Set
_op1 = value
End Set
End Property
 
Public Property Operand2() As Double
Get
Operand2 = _op2
End Get
Set
_op2 = value
End Set
End Property
 
End Class

Notice the use of the keyword value in the Set block. This is the actual code you should type, as value is an implicit variable that contains the value of the property being set.

Default Properties and Property Parameters

Default properties are another area of change, as they are only supported on properties with a parameter list. Therefore, you could add a property called Result to your Calculator class, to contain the last result of an operation, but you wouldn't be able to make it the Default property. Hence, you can't code it like this:

Default Property Result() As Double

This stops you doing the following:

Label1.Text = MyCalc

To declare a default property, you need to have parameters (and these cannot be declared as ByRef). For more details, consult the Visual Basic .NET documentation supplied with the .NET SDK.

Constructors and Object Creation

The Class_Initialize event has been removed from classes, but has been replaced with a member function called New, which enables you to inherit from constructors.

One of the cool new features of Visual Basic .NET is the use of overloading, which is perfect for providing constructors. The New() method is a special case for overloading, since the Overloads keyword is not required. For example, consider a Person class:

Public Class Person
 
Private _firstName As String
Private _lastName  As String
 
Sub New()
_firstName = ""
_lastName = ""
End Sub
 
Sub New(firstName As String, lastName As String)
_firstName = firstName
_lastName = lastName
End Sub
 
Public Property FirstName() As String
' property code here
End Property
 
Public Property LastName() As String
' property code here
End Property
 
End Class

In this example there are two occurrences of Sub New(): one without parameters, and another with. This means you can write:

Dim coolDude As New Person()
coolDude.FirstName = "Vince"
coolDude.LastName = "Patel"

Or

Dim coolDude As New Person("Vince", "Patel")

This provides a richer way of using classes and simplifies code.

Destructors and Object Destruction

Like the Class_Initialize() method, Class_Terminate() has also been replaced by a Destruct() method. For example:

Sub Destruct()
 
' code to clean up here
 
End Sub

There has been a big change in the way destructors are called from previous versions of Visual Basic, and it revolves around the CLR. One of the good features of the CLR is garbage collection (GC), which runs in the background collecting unused object references, freeing you from having to ensure that you always destroy them. However, the downside is that since it's a background task, you don't know exactly when your destructor is called.

During the time of the beta releases, there was a wide discussion regarding this, resulting in an extensive paper from Microsoft about garbage collection and its effects (search the MSDN Web site for Deterministic Finalization for more details). Some people were concerned that there might be cases where they would need to guarantee something happening (such as resource cleanup) when the object is no longer in use. If this is the case, then the advice is to create a method to house this functionality, and call this method when you have finished with the class instance.

In reality, the time difference between releasing the object instance, and it being garbage collected, is likely to be very small, since the garbage collector is always running.

Inheritance

As mentioned in the previous chapter, everything in .NET is an object, so you can inherit from pretty much anything. Consider the Person class as a base class; you could create a new class from it in the following way:

Public Class Programmer
Inherits Person
 
Private _avgHoursSleepPerNight As Integer
 
Public Sub New()
MyBase.New()
End Sub
Public Sub New(firstName As String, lastName As String)
MyBase.New(firstName, lastName)
End Sub
 
Public Sub New(firstName As String, lastName As String, _
hoursSleep As Integer)
MyBase.New(firstName, lastName)
_avgHoursSleepPerNight = hoursSleep
End Sub
 
Public Property AvgHoursSleepPerNight() As Integer
Get
AvgHoursSleepPerNight = _avgHoursSleepPerNight
End Get
Set
_avgHoursSleepPerNight = value
End Set
End Property
 
End Class

This class extends the existing Person class and adds a new property. Let's look at the way it does this.

First, after the class declarations comes the Inherits statement, where the base class we are inheriting from is specified:

Public Class Programmer
Inherits Person

Next, come the definitions for the existing constructors. Our class provides an extra one, so we need to overload the base class constructors. Notice how the definitions of these match the definitions in the base class, and how we call the constructor of the base class using MyBase. We are not changing the existing constructors, just adding our own, so we just want to map functionality to the base class:

Public Sub New()
MyBase.New()
End Sub
Public Sub New(firstName As String, lastName As String)
MyBase.New(firstName, lastName)
End Sub

Now we can add our extra constructor, which calls one of the previous constructors and then sets the additional property:

Public Sub New(firstName As String, lastName As String, _
hoursSleep As Integer)
MyBase.New(firstName, lastName)
_avgHoursSleepPerNight = hoursSleep
End Sub

Finally, we add the definition of the new property:

Public Property AvgHoursSleepPerNight() As Integer
Get
AvgHoursSleepPerNight = _avgHoursSleepPerNight
End Get
Set
_avgHoursSleepPerNight = value
End Set
End Property

In object-oriented terms, this is standard stuff, but it's new for Visual Basic and provides a great way to promote code reuse.

Classes and Interfaces

An interface is the description of the methods and properties a class will expose – it's an immutable contract with the outside world. The interface doesn't define any implementation – just the methods and properties. Derived classes then have to provide the actual implementation.

In Visual Basic .NET you automatically get a default interface that matches the class methods and properties, but there may be times when we want to explicitly define the interface. One good example of this is that when creating .NET-serviced components, the interface can be used to provide versioning features. See Chapter 23 for more details on this.

To create an interface, the Interface construct is used as follows:

Public Interface IPerson
Property FirstName() As String
Property LastName() As String
Function FullName() As String
End Interface

As you can see, there is no implementation specified here. By convention, the interface name is the class name preceded by I, although this isn't enforced. To derive a class from an interface, the Implements keyword is used on the class:

Public Class Person
Implements IPerson
 
Private _firstName As String
Private _lastName As String
 
Public Property FirstName() As String Implements IPerson.FirstName
' implementation goes here
End Property
 
Public Property LastName() As String Implements IPerson.LastName
' implementation goes here
End Property
 
Public Function FullName() As String Implements IPerson.FullName
Return _firstName & " " & _lastName
End Function
 
End Class

Multiple inheritance is allowed only in an interface. For example:

Public Interface Person
Inherits IPerson
Inherits ICleverPerson
End Interface

Language Changes

Along with the object-oriented features, there have been many changes to the language. We won't go into exhaustive detail here (it's well covered in the documentation), but here are some things to watch out for:

• 
  

  Array bounds:The lower bound of an array is always 0, and cannot be changed. The Option Base statement is not supported.



• 
  

  Array declaration:ReDim can only be used if the array has already been declared.



• 
  

  Array sizes:Arrays do not have a fixed size (although the number of dimensions is fixed). For example.

  
  Dim ConnectionTimes(10) As Date
  

  
  

  This defines an array with an initial size of 11 elements. Arrays can also be populated on declaration:

  
  Dim ConnectionTimes() As Date = {"10:30", "11:30", "12:00", "06:00"}
  

  
  



• 
  

  String length:The fixed-width string is not supported unless the VBFixedString attribute is used.



• 
  

  Variants:The Variant data type is no longer supported, being replaced by a more generic Object. The corresponding VarType function is also not supported, as the Object has a GetType method.



• 
  

  Data types:The Currency data type is replaced by Decimal. The Integer type is now 32 bits, with Short being 16 bits and Long being 64 bits.



• 
  

  Short cut operators:A new short form of addition and assignment has been added. For example.

  
  counter += 1
  name &= " Sussman"
  

  
  


• 
  

  Default properties:As mentioned earlier, default properties are not supported, unless they take parameters.



• 
  

  Variable declaration:When declaring multiple variables on the same line, a variable with no data type takes the type of the next declared type (and not Variant as was the case in VB6). For example, in the following declarations Age is an Integer.

  
  Dim Age, Hours As Integer
  Dim Name As String, Age, Hours As Integer
  

  
  


• 
  

  Variable scope:Block scope is now supported, so variables declared within blocks (such as If blocks) are only visible within the If block. In Visual Basic 6, variables could be declared anywhere, but their scope was the entire method.



• 
  

  Object creation:The As New keywords can be used freely on the variable declaration line. There is no implicit object creation, so objects that are Nothing remain set to Nothing unless an explicit instance is created.



• 
  

  Procedure parameters:The rules for parameter passing and optional parameters have changed. See the section on Parameters later for more information on this.



• 
  

  Procedure calls:Parentheses are now required on all procedure calls, not just functions.



• 
  

  Function return values:The return value from a function is now supplied with the Return statement, rather than by setting the function name to the desired value.



• 
  

  While loops:The Wend statement has been replaced with End While.



• 
  

  String and Variant functions:The string manipulation functions that had two types of call (Trim returned a Variant and Trim$ returned a string) are replaced with overloaded method calls.



• 
  

  Empty and Null:The Empty and Null keywords have their functionality replaced by Nothing.

There are many other changes, some of which don't really affect ASP.NET programmers. For a full list, consult the Visual Basic .NET documentation, or see Wrox's Professional VB.NET, 2nd Edition, ISBN: 0-7645-4400-4.

References

Since you're freed from using a set design tool, some of the features you are used to now require a bit more typing. One example of this is referencing other components. In Visual Basic 6, to access COM components you select References from the Project menu. There's something similar in Visual Studio .NET to reference assemblies (or even COM components), but if you're using Notepad, you have to provide the reference yourself. This is done using the Imports keyword. For example:

Imports System
Imports MyComponent

It's also possible to alias references using the following syntax:

Imports aliasName = Namespace

If an alias is used, the alias must be included in references to classes that the namespace contains. For example, if you have a namespace called MyComponent containing a class called MyClass, and import the namespace like this:

Imports foo = MyComponent

You can't then access the class like this:

Dim comp As MyClass

You have to use the following syntax:

Dim comp As foo.MyClass

Structured Exception Handling

One of the best new features of .NET is a unified structured exception-handling framework, which extends to Visual Basic .NET. Although On Error is still supported, a far better way of handling errors is to use the new Try…Catch…Finally structure. The way it works is simple, with each of the statements defining a block of code to be run.

The syntax is:

Try
 
' code block to run
 
[
 
   Catch [exception [As type]] [When exception]
 
' code to run if the exception generated matches
' the exception and expression defined above
 
[Exit Try]
]
Catch [exception [As.type]] [When expression]
' code to run if the exception generated matches
' the exception and expression defined above
 
[Exit Try]
 
[Finally
' code that always runs, whether or not an exception
' was caught, unless Exit Try is called
]
 
End Try

This allows you to bracket a section of code and then handle generic or specific errors. For example:

Try
' connect to a database and
' retrieve some data
' ... code left out for clarity ...
 
Catch exSQL As SQLException
ErrorLabel.Text = "SQL Error: " & exSQL.ToString()
 
Catch ex As Exception
ErrorLabel.Text = "Other error: " & ex.ToString()
 
Finally
FinishedLabel.Text = "Finished"
 
End Try

You can have multiple Catch blocks, to make our error handling specific to a particular error. Always put the most specific Catch blocks first and the more generic ones last, as the Catch blocks are tried in the order they are declared.

The Throw statement can be used to throw your own errors, or even re-raise errors.

Errors and exceptions are covered in detail in Chapter 22.

Data Types and Structures

There are three new data types:

• 
  

  Char: for unsigned 16-bit values.



• 
  

  Short: for signed 16-bit integers. This is the equivalent to the current Visual Basic Integer (in Visual Basic .NET the Integer is now 32-bits and the Long 64-bits).



• 
  

  Decimal: for signed integers.

Custom types are now provided by the Structure statement, rather than the Type statement. The syntax is:

[Public | Private | Friend] Structure structureName
End Structure

For example:

Public Structure Person
Public FirstName As String
Public LastName As String
Private Age As Integer
End Structure

The use of structures is unified with classes, enabling structures to not only contain member variables, but also methods:

Public Structure Narcissist
Public FirstName As String
Public LastName As String
Private RealAge As Integer
 
Public Function Age() As Integer
Return RealAge – 5
End Function
End Structure

Whether you use classes or structures is purely a coding and design decision, but the close linking of the two types provides added flexibility.

Parameters

Several things have changed regarding passing parameters to procedures. The most important is that parameters now default to ByVal. To achieve reference parameters, you must explicitly put ByRef in front of the parameter name.

Secondly, as mentioned earlier, all method calls with parameters must be surrounded by parentheses. The previous versions of Visual Basic had the inconsistency that parentheses were required for functions but not subroutines. For example, the following is no longer valid:

MyMethod 1, 2, "foo"

Instead, you must use:

MyMethod(1, 2, "foo")

For optional parameters, you now have to specify a default, and the IsMissing() method is removed. For example, you cannot write:

Sub MyMethod(Name As String, Optional Age As Integer)
 
If IsMissing(Age) Then
...

You have to supply a default:

Sub MyMethod(Name As String, Optional Age As Integer = -1)

Debugging and Message Boxes

Although not relevant to ASP.NET pages, there are two things that might hit you if you are using Visual Studio .NET:

• 
  

  The Print method of the Debug object has been replaced by four methods – Write(), WriteIf(), WriteLine(), and WriteLineIf().



• 
  

  The MsgBox statement has been replaced with the Show method of the MessageBox object.

Debugging is covered in detail in Chapter 22.

Backward Compatibility

To ease the transition from Visual Basic 6 to Visual Basic .NET, you can reference the Microsoft.VisualBasic.Compatibility.VB6 namespace, which provides access to much of the removed or changed functionality. It's probably best not to overuse these compatibility features, though. The changes to the language have been made not only to improve it, but also to bring it in line with the CLS and the other .NET languages.