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:
Console.WriteLine(oPerson.Name)
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 con.WriteLine(oPerson2.Gender.ToString)
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 ClassA 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()
Application.Run(thrdForm)
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
Me.Controls.Add(btnStart)
lblOutput = New Label()
lblOutput.Top = 125
lblOutput.Left = 100
lblOutput.Width = 200
lblOutput.Height = 75
Me.Controls.Add(lblOutput)
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)
Else
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
Next
End Sub
End ClassGet 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.
