VB.NET Interview Questions

Analogy categoryAnalogies

What Interviewers Look For in VB.NET Roles

VB.NET interviews for mid-level and senior roles rarely test rote syntax memorization; they test whether a candidate understands why the language behaves the way it does. Expect questions probing Option Strict and Option Explicit, and why a hiring team would mandate both, the distinction between value types and reference types, how exceptions propagate through nested Try blocks, and whether a candidate can reason about a legacy codebase that uses now-discouraged patterns like On Error Goto. Strong candidates connect language mechanics to real consequences, for instance, explaining that Option Strict Off allows a silent narrowing conversion from Double to Integer that could quietly truncate financial data.

🏏

Cricket analogy: It's like a national selector evaluating a batter not just on technique in the nets but on how they read the game situation, a VB.NET interview similarly probes whether a candidate understands why Option Strict matters, not just whether they can recite the Dim keyword.

Core Language Fundamentals

A frequent fundamentals question is the difference between passing a parameter ByVal, the default in VB.NET, versus ByRef. ByVal passes a copy of a value type or a copy of the reference for a reference type, so reassigning the parameter inside the method doesn't affect the caller's variable, though mutating the object a reference type points to, like calling .Add on a passed-in List(Of T), still affects the caller's object because both copies point to the same underlying instance. ByRef passes the actual storage location, so reassigning the parameter inside the method changes the caller's variable directly. A related fundamentals question covers Shared members: a Shared field or method belongs to the type itself rather than any instance, so Employee.TotalCount would be accessed without creating an Employee object, and Shared state is visible to every instance.

🏏

Cricket analogy: It's like handing a teammate a photocopy of the team's batting order, ByVal, versus handing them the actual official team sheet, ByRef, scribbling on the photocopy doesn't change the real order, but scribbling on the original sheet does.

Object-Oriented Programming Questions

Interviewers frequently probe the difference between Overloads, Overrides, and Shadows. Overloads defines multiple methods with the same name but different parameter signatures within the same class. Overrides replaces a base class's Overridable method with new behavior in a derived class while preserving polymorphism, calling the method through a base-class reference still invokes the derived class's version. Shadows, unique to VB.NET's terminology, roughly equivalent to C#'s 'new' modifier, hides a base member entirely with a same-named member in the derived class, breaking polymorphism, calling the method through a base-class-typed reference invokes the base version, not the derived one, which is a common source of confusing bugs. MustInherit marks a class as abstract, it cannot be instantiated directly, and MustOverride marks a method that every concrete derived class must implement, mirroring C#'s abstract keyword.

🏏

Cricket analogy: It's like a bowler having several deliveries all called a 'yorker' but distinguished by pace and angle, Overloads, versus a specific league formally superseding the parent board's rule while still being recognized under the same name, Overrides, versus a local club quietly using its own different rulebook under the same name, Shadows, which confuses anyone assuming the official rule applies.

Practical and Scenario Questions

Beyond definitions, interviewers often present a scenario: 'This WinForms app leaks memory after opening and closing a child form repeatedly, where would you look?' A strong answer walks through event-handler subscriptions, if the child form subscribes to an event on a long-lived object, like a Shared logger or the main form, using AddHandler without a matching RemoveHandler in the form's Dispose logic, the child form can never be garbage collected because the long-lived object still holds a reference to it. Another common scenario asks a candidate to reason through a small piece of buggy code live, such as a loop using Shadows unexpectedly or a comparison against Nothing that behaves differently for value types versus nullable types, the goal isn't a perfect answer instantly, but a candidate who narrates their debugging process methodically.

🏏

Cricket analogy: It's like a bowling coach diagnosing a recurring no-ball problem by checking the bowler's run-up rhythm step by step rather than guessing, a memory-leak scenario question rewards a candidate who methodically checks event subscriptions rather than guessing at a fix.

vbnet

Public MustInherit Class Shape
    Public MustOverride Function Area() As Double

    Public Overridable Function Describe() As String
        Return $"Shape with area {Area():F2}"
    End Function
End Class

Public Class Circle
    Inherits Shape

    Public Property Radius As Double

    Public Sub New(radius As Double)
        Me.Radius = radius
    End Sub

    Public Overrides Function Area() As Double
        Return Math.PI * Radius * Radius
    End Function

    Public Overloads Function Describe(prefix As String) As String
        Return $"{prefix}: {MyBase.Describe()}"
    End Function
End Class

Module Program
    Sub Main()
        Dim s As Shape = New Circle(4)
        Console.WriteLine(s.Describe())
        Console.WriteLine(CType(s, Circle).Describe("Result"))
    End Sub
End Module

Being able to explain why Option Strict On matters, not just that it exists, is one of the clearest signals of VB.NET seniority in an interview. It shows you've been burned by, or deliberately avoided, a silent narrowing-conversion bug in production.

Don't confuse Shadows with Overrides when answering interview questions. Shadows breaks polymorphism (the base-class reference calls the base version), while Overrides preserves it (the base-class reference calls the derived version), mixing these up in an interview is a common, easily avoidable mistake.

Interviewers assess reasoning about language behavior (Option Strict, exception handling) more than syntax recall.
ByVal passes a copy of the value or reference; ByRef passes the actual storage location, letting the callee reassign the caller's variable.
Shared members belong to the type itself, not to any single instance, and are visible across all instances.
Overloads means same name, different parameters, same class; Overrides means polymorphic replacement of a base method; Shadows means non-polymorphic hiding of a base member.
MustInherit marks an abstract class; MustOverride marks a method every concrete subclass must implement.
Scenario questions, like memory leaks or buggy loops, reward methodical, narrated debugging over instant answers.
A common real-world bug pattern is AddHandler without a matching RemoveHandler, which prevents garbage collection.