The Types of a .NET Namespace

Once you’ve made a namespace accessible to your code, you can access any of the types it contains. In this section, we’ll survey the types that a .NET namespace can contain.


In VB.NET, classes are reference types; that is, when you create an instance of a class in code, you work with a pointer (or reference) to the object rather than with the object itself. This is similar to previous versions of Visual Basic.

When a .NET class is instantiated, its constructor (or its New subroutine) executes. Each .NET class can have one or more constructors (that is, constructors can be overloaded), and the constructor can either be parameterless or parameterized. Visual Basic .NET provides three ways to initialize a variable and invoke its constructor. These are illustrated in the following three sets of statements, each of which instantiates a System.IO.FileInfo object:

' Single statement
Dim oFile As New FileInfo("c:\documents\notes.txt") 
' Single Statement with separate call to constructor
Dim oFile As FileInfo = New FileInfo("c:\documents\notes.txt")
' Separate declaration and initialization
Dim oFile As FileInfo
oFile = New FileInfo("c:\documents\notes.txt")

Once we create an instance of a class, we can invoke its properties and methods. In addition, we can handle its events (assuming that it exposes events) if we instantiate the object using the WithEvents keyword. For example:

Dim WithEvents cn As New SqlConnection()

Visual Basic .NET, unlike previous versions of Visual Basic, supports both instance and shared members. Instance members exist for each instance of a class; in previous versions of Visual Basic, all members of a class were instance members. Shared members are members that are not associated with a specific instance of a class or a structure, but rather are common to all instances of a class. Accessing a shared member of a class does not require that the class be instantiated; it can be accessed using the class name only. In addition, if the shared member is a property, it has a single value for all instances of the class.

In Example 1-8, we accessed the shared WriteLine method of the Console class, as follows:


Note that, to do this, we didn’t have to instantiate an instance of the Console class; we simply called the Console class directly. A peculiarity of Visual Basic is that you can invoke shared members using either the class name or the name of an instance variable. The following code fragment, which does create an instance of the Console class, also works:

Dim con As Console


Structures are very similar to classes, except that they are value types rather than reference types. Most of the primitive data types (Boolean, Byte, Char, Int16, Int32, etc.) defined in the FCL are implemented as structures. Because structures don’t support parameterless constructors, you don’t use the New keyword to instantiate them.

You work with structures just as you work with .NET classes, except that the New keyword is not used in declaring a structure:

' Declaration and initialization
Dim num1 As Int16 = 10
' Separate declaration and initialization
Dim num2 As Int16
num2 = 10


An enumeration is a related set of constants. You don’t have to instantiate enumerations to take advantage of their members. When working with enumerations in .NET, however, you must specify the name of the enumeration in order to access one of its constants. For example:

Dim dy As String = WeekdayName(1, False, FirstDayOfWeek.Sunday)


Interfaces are virtual base classes; that is, they consist of members (methods, properties, and events) that have no implementation. Instead, derived classes must provide the implementation. For example, the following code fragment uses interface inheritance to define a new class:

Class CustomCompare
   Implements System.IComparable
   Public Function CompareTo(obj As Object) As Integer _
                   Implements System.IComparable.CompareTo
      ' Implementation of IComparable.ICompareTo
   End Function
End Class


A delegate is a reference type that represents a strongly typed function pointer. All delegates are explicitly or implicitly derived from the System.Delegate class, which includes a number of members that provide information about the delegate, create object instances, or invoke the delegate. Delegates can be used in event procedures, for asynchronous callbacks, and wherever the address of a function is expected. The following example uses a delegate to define the thread procedure to be passed to the ThreadPool class’s QueueUserWorkItem method:

Option Strict On
      Imports Microsoft.VisualBasic
      Imports System
      Imports System.Threading
      Imports System.Windows.Forms
      Public Class ThreadedForm : Inherits Form
         Protected WithEvents btnStart As Button
         Protected lblOutput As Label
         Public Shared Sub Main()
            Dim thrdForm As New ThreadedForm()
         End Sub
         Public Sub New()
            Me.Height = 200
            Me.Width = 400
            btnStart = New Button()
            btnStart.Text = "&Start"
            btnStart.Top = 50
            btnStart.Left = 100
            btnStart.Width = 75
            btnStart.Height = 50
            lblOutput = New Label()
            lblOutput.Top = 125
            lblOutput.Left = 100
            lblOutput.Width = 200
            lblOutput.Height = 75
            Me.Text = "Asynchronous Callback Example"
         End Sub
         Protected Sub btnStart_Click(sender As Object, _
                                      e As EventArgs) _
                       Handles btnStart.Click
            btnStart.Enabled = False
            Dim thrdProc As WaitCallback = AddressOf ThreadProcedure
            ThreadPool.QueueUserWorkItem(thrdProc, 1000000)
         End Sub
         Protected Sub ThreadProcedure(o As Object)
            Dim i As Integer
            If TypeOf o Is Integer Then
               i = DirectCast(o, Integer)
               Exit Sub
            End If
            Dim lCtr As Long
            For lCtr = 0 to 10000000
               If lCtr Mod 1000000 = 0 Then
                  lblOutput.Text = lblOutput.Text & "X"
               End If
         End Sub
      End Class

Get VB.NET Core Classes in a Nutshell now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.