MSDN Documentation

Visual Basic Modules

Modules in Visual Basic are a way to group related procedures, properties, and variables. They are similar to classes but with some key differences:

  • Modules cannot be instantiated; you cannot create objects from them.
  • All members of a module are implicitly Public.
  • Modules are typically used for utility functions and constants that don't need to be associated with a specific object instance.

On this page

What Are Modules?

Modules serve as containers for code that is not tied to any specific object. Think of them as namespaces with shared functionality. They provide a convenient way to organize code and make it accessible from anywhere in your application without needing to create an instance.

Module vs. Class

While both modules and classes are used for code organization, they have distinct characteristics:

  • Instantiation: Classes can be instantiated to create objects, while modules cannot.
  • Inheritance: Classes support inheritance, allowing you to create derived classes. Modules do not support inheritance.
  • Access Modifiers: Class members can have various access modifiers (Public, Private, Protected, etc.). Module members are implicitly Public.
  • Purpose: Classes are typically used to model real-world entities or concepts that have state and behavior. Modules are used for utility functions, constants, and shared resources.

Declaring Modules

You declare a module using the Module keyword. The syntax is straightforward:

' Example module declaration
Module Utilities
    ' Module members go here
End Module

Module Members

Modules can contain various types of members, including:

  • Subroutines (Sub): Procedures that perform an action.
  • Functions: Procedures that return a value.
  • Properties: Define attributes or characteristics.
  • Variables: Store data.
  • Constants: Define fixed values.
  • Enums: Define a set of named constants.

All members declared directly within a module are public by default and shared.

Example: A Utility Module

Here's an example of a module that provides some common mathematical operations:

Module MathHelper

    ' A constant value
    Public Const PI As Double = 3.14159

    ' A function to calculate the area of a circle
    Public Function CalculateCircleArea(radius As Double) As Double
        If radius < 0 Then
            Throw New ArgumentException("Radius cannot be negative.")
        End If
        Return PI * radius * radius
    End Function

    ' A subroutine to display a message
    Public Sub DisplayMessage(message As String)
        Console.WriteLine(message)
    End Sub

End Module

Using Modules

To access members of a module, you simply use the module name followed by the member name. You do not need to create an instance of the module.

Example: Accessing Module Members

Using the MathHelper module defined above:

Sub Main()
    ' Accessing the constant PI
    Dim circleRadius As Double = 5.0
    Dim area As Double = MathHelper.CalculateCircleArea(circleRadius)
    Console.WriteLine($"The area of a circle with radius {circleRadius} is {area}.")

    ' Accessing the DisplayMessage subroutine
    MathHelper.DisplayMessage("Hello from the MathHelper module!")

    ' You cannot do this:
    ' Dim helper As New MathHelper() ' Error: Modules cannot be instantiated.
End Sub

Advantages of Using Modules

  • Code Organization: Keeps related code together.
  • Global Accessibility: Members can be accessed from any part of the application.
  • No Instantiation Overhead: Avoids the creation of objects, which can be more efficient for utility functions.
  • Simplifies Shared Resources: Ideal for defining shared constants or static methods.

Modules are a powerful tool for structuring your Visual Basic applications, especially for creating libraries of common functions and constants.