Errors in Visual Basic .NET

In Visual Basic .NET, error handling is typically done using exceptions rather than explicit error return values. However, we can simulate a similar approach using custom error types and optional return values.

Imports System

' By convention, we'll use a custom class for errors
Public Class CustomError
    Public Property Message As String

    Public Sub New(message As String)
        Me.Message = message
    End Sub
End Class

Module ErrorsExample
    ' We'll use a Tuple to return both a value and an error
    Function F(arg As Integer) As (Integer, CustomError)
        If arg = 42 Then
            ' Return an error
            Return (-1, New CustomError("can't work with 42"))
        End If

        ' Return a successful result
        Return (arg + 3, Nothing)
    End Function

    ' Sentinel errors are predefined error instances
    Private ReadOnly ErrOutOfTea As New CustomError("no more tea available")
    Private ReadOnly ErrPower As New CustomError("can't boil water")

    Function MakeTea(arg As Integer) As CustomError
        If arg = 2 Then
            Return ErrOutOfTea
        ElseIf arg = 4 Then
            ' Simulating error wrapping
            Return New CustomError($"making tea: {ErrPower.Message}")
        End If
        Return Nothing
    End Function

    Sub Main()
        For Each i In New Integer() {7, 42}
            ' It's common to use inline error checking
            Dim result = F(i)
            If result.Item2 IsNot Nothing Then
                Console.WriteLine($"f failed: {result.Item2.Message}")
            Else
                Console.WriteLine($"f worked: {result.Item1}")
            End If
        Next

        For i As Integer = 0 To 4
            Dim err = MakeTea(i)
            If err IsNot Nothing Then
                ' Simulating errors.Is functionality
                If err.Message = ErrOutOfTea.Message Then
                    Console.WriteLine("We should buy new tea!")
                ElseIf err.Message.Contains(ErrPower.Message) Then
                    Console.WriteLine("Now it is dark.")
                Else
                    Console.WriteLine($"unknown error: {err.Message}")
                End If
                Continue For
            End If
            Console.WriteLine("Tea is ready!")
        Next
    End Sub
End Module

In this Visual Basic .NET version:

We define a CustomError class to represent errors, similar to Go’s error interface.
Functions that can fail return a tuple containing the result and a potential error.
We use Nothing (equivalent to Go’s nil) to indicate the absence of an error.
Sentinel errors are implemented as predefined CustomError instances.
Error wrapping is simulated by creating a new error that includes the message of another error.
We use string comparison to check for specific errors, simulating Go’s errors.Is functionality.

To run this program, save it as ErrorsExample.vb and compile it using the Visual Basic compiler:

$ vbc ErrorsExample.vb
$ mono ErrorsExample.exe
f worked: 10
f failed: can't work with 42
Tea is ready!
Tea is ready!
We should buy new tea!
Tea is ready!
Now it is dark.

This example demonstrates how to handle errors in Visual Basic .NET in a way that’s similar to Go’s approach, even though the underlying mechanisms are different. Visual Basic .NET typically uses exceptions for error handling, but this example shows how to implement a return-value-based error handling system when needed.

Range Over Iterators in Visual Basic .NET

Custom Errors in Visual Basic .NET

Learn X By Example

Title here

Errors in Visual Basic .NET