XML Documentation

Until now, direct source code documentation was reserved for C# developers. With the assistance of tools like VB.DOC, it was possible to integrate comments in Visual Basic .NET, too; however, this was sort of challenging, especially because no compiler or IntelliSense support was available. This will change with the eighth version of Visual Basic. From now on, code comment functionality is supported directly. This results in a simplified way to write comments and also ensures that references within the documentation are being validated.

The comments have to start with the familiar comment character (') followed by an @ symbol to make sure that the compiler will recognize them (see Listing 1-17 and Figure 1-12). After that, you can use the same XML tags as in C#. The compiler provides the new /doc option and generates the XML data, which is necessary for tools like NDoc.

Figure 1-12: VB .NET now supports XML documentation.

Listing 1-17: Using XML Documentation in VB .NET

Imports Microsoft.VisualBasic

'@ <summary>That's my little foo class</summary>
Public Class Foo

   '@ <summary>These methods return the text passed as parameter</summary>
   '@ <param name="Text">Text to be returned</param>
   '@ <returns>Returns the string passed as
      <paramref name="Text"/> parameter</returns>
    Public Function ReturnSomeString(ByVal Text As String) As String
       Return Text
    End Function

End Class

At present, additional changes to the syntax are being considered. Possibly three apostrophe signs will be used in the final version of VB .NET 2.0 to mark comments. This would be similar to the approach of C#.

Generics

The new version of Visual Basic .NET supports generic data types in the same way as C#, but—surprise!—with a slightly different syntax. In VB .NET, this involves the new Of keyword, which has to be specified at the definition of generic classes. You also need the keyword whenever you use the generic type. Constraints are defined through the As keyword, which you already know from another context. Listing 1-18 demonstrates the realization of the Listings 1-1 and 1-2 shown earlier in the world of VB .NET.

Listing 1-18: Making VB .NET "Generics Enabled"

Imports System

Public Class MyList(Of ItemType As IComparable)

   Public Sub Add(ByVal Obj As ItemType)
   End Sub

   Default Public ReadOnly Property Items(ByVal Index As Integer) As ItemType
      Get
        Return Nothing
      End Get
   End Property

End Class

Public Class Foo
   Implements IComparable

   Public Function CompareTo(ByVal obj As Object) As Integer _
                      Implements System.IComparable.CompareTo
      Return 0
   End Function
End Class

Public Class MainClass

   Public Shared Sub Main()
      Dim List As MyList(Of Foo) = New MyList(Of Foo)
      List.Add(New Foo)
      Dim AnotherFoo As Foo = List(0)

      Console.Read()
   End Sub

End Class

Operator Overloading

Like C#, VB .NET now supports operator overloading. Although this feature is rarely used with custom classes in the real world, it's nevertheless fun to work with it. A small example appears in Listing 1-19. Several overloaded operators are defined to compare, add, and subtract two instances of points in the structure.

Listing 1-19: Point Structure Allows Arithmetic and Comparison Operations

Imports System

Public Structure Point

   Public X As Integer
   Public Y As Integer

   Public Shared Operator +(ByVal p1 As Point, ByVal p2 As Point) As Point
      Dim p As Point = New Point
      p.X = p1.X + p2.X
      p.Y = p1.Y + p2.Y
      Return p
   End Operator

   Public Shared Operator -(ByVal p1 As Point, ByVal p2 As Point) As Point
      Dim p As Point = New Point
      p.X = p1.X - p2.X
      p.Y = p1.Y - p2.Y
      Return p
   End Operator

   Public Shared Operator =(ByVal p1 As Point, ByVal p2 As Point) As Boolean
      Return ((p1.X = p2.X) AndAlso (p1.Y = p2.Y))
   End Operator

   Public Shared Operator <>(ByVal p1 As Point, ByVal p2 As Point) As Boolean
      Return ((p1.X <> p2.X) OrElse (p1.Y <> p2.Y))
   End Operator

End Structure

Any operators are implemented as methods and are static by definition. Furthermore, they have to exist in pairs. Possible pairs are

• = and <>

• < and >

• >= and <=

• IsTrue and IsFalse

The operators And, Or, Not, and Xor are supported as well. Also, type conversions can be executed by such custom operators. Two new keywords are available to separate implicit (and therefore free of loss) conversion from explicit conversion: Widening and Narrowing. In Listing 1-20, you find two structures, Point2D and Point3D. Both classes allow conversion among each other, implicitly in one direction and explicitly in the other. Custom type conversions are implemented using the CType operator.

Listing 1-20: Widening and Narrowing Conversion Operations

Imports System

Public Structure Point2D

   Public X As Integer
   Public Y As Integer

End Structure

Public Structure Point3D

   Public X As Integer
   Public Y As Integer
   Public Z As Integer

   Public Shared Widening Operator CType(ByVal p1 As Point2D) As Point3D
      Dim p2 As New Point3D
      p2.X = p1.X
      p2.Y = p1.Y
      Return p2
   End Operator
   Public Shared Narrowing Operator CType(ByVal p1 As Point3D) As Point2D
      Dim p2 As New Point2D
      p2.X = p1.X
      p2.Y = p1.Y
      Return p2
   End Operator

End Structure

Partial Classes

Partial classes are available not only in C#, but also in the new VB .NET version. The required new keyword is Expands (see Listing 1-21). Unlike in C#, a main class exists in VB .NET, which has to be defined as usual. Only the additional classes have to be marked with the keyword, and they don't need any modifiers. The separation in several files is supported for classes and structures, too.

Listing 1-21: Separating Code Using the New Expands Keyword

' foo1.vb
Public Class Foo

   Public Sub SomeMethod()
   End Sub

End Class

' foo2.vb
Expands Class Foo

   Public Sub AnotherMethod()
   End Sub

End Class

New Data Types

The new version of VB .NET comes with an extended pool of included data types that are now identical to the ones in C#. Please note that the following new data types aren't CLS compliant, so other languages may not be able to access them:

• SByte

• UInteger

• ULong

• UShort

New Keywords

There are more new keywords besides the ones already introduced. With one exception, they are all familiar to users of C#.

Continue allows you to close the current loop and jump into the next circle. The keyword can be used with For, Do, and While loops. In nested loops of different types, the desired loop could be specified by a suffix—for example, Continue For.

The very helpful using keyword (you may already know it from C#) is now available in VB .NET, too. Here, of course, it generally starts with a capital U. Using offers the definition of a dispose block. The variable defined in the header will be always disposed on leaving the scope, even in case of an unhandled exception. A frequent task that is performed is database connection, which should be returned back to the pool in any case. Another possible scenario is the use of the Font class as shown in the following listing. To enable a class to be disposed in this way, it has to implement the IDisposable interface.

Public Sub setbigbold(ByVal c As Control)
   Using nf As New System.Drawing.Font("Arial", 12.0F, FontStyle.Bold)
      c.Font = nf
      c.Text = "This is 12-point Arial bold"
   End Using
End Sub

Last but not least, another new keyword is Global. This one specifies the root namespace if naming conflicts exist with the local one—for example, Global.System.Int32.