Ruby.CodeCompared.To/Visual Basic .NET

Every VB.NET executable begins with a Module containing a Sub Main() entry point. Console.WriteLine() is the equivalent of Ruby's puts. Option Strict On is the recommended mode — it enforces explicit type declarations and prevents implicit narrowing conversions.

VB.NET uses an apostrophe (') for comments — there is no block comment syntax. The old BASIC keyword Rem (short for "remark") also works but is rarely seen in modern VB.NET code. Unlike Ruby's =begin...=end, each line of a multi-line comment needs its own apostrophe.

Option Strict On is the strongly-typed mode: implicit narrowing conversions (like assigning a Double to an Integer) are compile errors. Option Explicit On (the default) requires every variable to be declared with Dim. Legacy VB code sometimes uses Option Strict Off and Option Explicit Off, which allow dynamically-typed Object variables — avoid this style in new code.

The Imports statement brings a namespace into scope — equivalent to Ruby's require. System is always available, but you must import System.Collections.Generic to use List(Of T) and Dictionary(Of K, V), and System.Linq for LINQ query methods. Unlike Ruby's require, Imports is purely a compile-time alias — no file loading occurs.

Modern VB.NET (since Visual Studio 2010) supports implicit line continuation after operators, commas, open parentheses, and certain keywords — no special character needed. The explicit underscore (_) continuation character from older VB is still valid but discouraged. Ruby and VB.NET are similar here: both allow expression spanning across lines after an operator.

VB.NET's Integer is a 32-bit signed integer (unlike Ruby's arbitrary-precision integers). Use Long for 64-bit integers. Double is the standard 64-bit floating-point type. Nothing is the VB equivalent of Ruby's nil — it represents the absence of a value. Boolean literals are capitalized: True and False.

When Option Infer On is active (the default in modern VB.NET), the compiler infers the type from the initializer — similar to Ruby's duck typing but resolved at compile time. Without an initializer, you must specify the type explicitly. GetType().Name returns the .NET runtime type name, analogous to Ruby's .class.

VB.NET provides fixed-size numeric types: Byte (8-bit), Short (16-bit), Integer (32-bit), Long (64-bit). The L suffix marks a Long literal; D marks a Decimal literal. Unlike Ruby's arbitrary-precision integers, VB.NET integers overflow silently (in release builds) or throw OverflowException (in checked context). Use Decimal for financial calculations to avoid floating-point rounding errors.

Nothing in VB.NET is equivalent to Ruby's nil. Test for it with Is Nothing or IsNot Nothing — the helper function IsNothing() also works but is considered older style. VB.NET does not have Ruby's &. safe navigation operator, so null checks must be written explicitly with If().

Value types like Integer and Double cannot normally be Nothing — they always have a value. Adding ? makes them nullable: Integer? is shorthand for Nullable(Of Integer). The .HasValue property tests whether a value is present, and .GetValueOrDefault(fallback) safely extracts the value or returns a default. Reference types like String are always nullable without the ?.

VB.NET provides a family of C* conversion functions: CInt(), CDbl(), CStr(), CBool(), CLng(), etc. These throw exceptions on invalid input. For safe conversion without exceptions, use Integer.TryParse() which returns False and sets the output variable to the default value on failure — more explicit than Ruby's .to_i which silently returns 0.

TypeOf x Is Type is VB's equivalent of Ruby's x.is_a?(Type). GetType().Name returns the runtime type name as a string. DirectCast() performs a type cast without any conversion — it throws InvalidCastException if the cast fails. For safer casting that returns Nothing on failure, use TryCast().

The Const keyword declares a compile-time constant — the value must be a literal expression computable at compile time. Module-level Const declarations are shared across all methods in the module. Unlike Ruby's convention of UPPERCASE constant names, VB.NET uses PascalCase for constants by convention.

VB.NET uses $"..." for string interpolation, with expressions inside {} — the same syntax as C#. Format specifiers follow a colon inside the braces: {value:F2} for 2 decimal places, {value:C} for currency, {value:D4} for zero-padded integers. This is more powerful than Ruby's basic #{} interpolation.

VB.NET uses & as the dedicated string concatenation operator — it always performs string concatenation regardless of operand types. The + operator also concatenates strings but is ambiguous when one operand might be numeric. String.Join(separator, array) is equivalent to Ruby's Array#join.

VB.NET string methods use PascalCase: Trim(), ToUpper(), ToLower(), Contains(), Replace(), StartsWith(), EndsWith(). The .Length property (not a method call — no parentheses) gives the character count. String comparison in VB.NET is case-sensitive by default — unlike older VB6 which was case-insensitive.

Substring(startIndex, length) is 0-based — unlike Ruby's bracket syntax. IndexOf() returns the 0-based position or -1 if not found, equivalent to Ruby's String#index. Classic VB functions like Left(), Right(), and Mid() are still available via the Microsoft.VisualBasic namespace but are considered legacy — prefer Substring() in modern VB.NET.

Split() takes a Char delimiter — note the c suffix: " "c is a character literal, not a string. The result is a String() array, indexed from 0. String.Join(separator, array) is the inverse. To split on a string (not just a character), pass New String() {delimiter} as the argument.

VB.NET does not have a heredoc or raw multiline string literal — multiline strings are built by concatenating with Environment.NewLine (platform-neutral) or the legacy constants vbCrLf (Windows \r\n), vbLf (Unix \n). C# 11 added raw string literals ("""...""") but VB.NET has not yet adopted this feature. In practice, multiline content is often loaded from a resource file or database.

In VB.NET, Dim arr(n) creates an array with n+1 elements — indices 0 through n. This surprises many developers: Dim numbers(4) has 5 elements. Arrays have a fixed size once created; use List(Of T) for dynamic resizing. Array elements are accessed with parentheses (), not square brackets.

List(Of T) is the VB.NET equivalent of Ruby's Array — dynamically resizable and type-safe. Add() appends an element (like Ruby's push), Remove() removes by value, Contains() tests membership. Note .Count (not .Length) for the element count. The From {...} initializer syntax sets initial values at construction.

Dictionary(Of K, V) is VB's equivalent of Ruby's Hash. Values are accessed and assigned with parentheses: scores("Alice"). ContainsKey() is equivalent to Ruby's key? or has_key?. Iterating yields KeyValuePair(Of K, V) objects with .Key and .Value properties. Accessing a missing key throws KeyNotFoundException — use TryGetValue() for safe access.

LINQ extension methods (System.Linq) provide Ruby-like higher-order operations on any collection: Min(), Max(), Sum(), Where() (filter), Select() (map), OrderBy() (sort). These return lazy sequences — call .ToArray() or .ToList() to materialize. Array.Sort() mutates in place, like Ruby's sort!.

HashSet(Of T) is VB's equivalent of Ruby's Set. Adding a duplicate element is silently ignored. It supports set operations: IntersectWith() (intersection), UnionWith() (union), ExceptWith() (difference) — these mutate in place. IsSubsetOf() and IsSupersetOf() are also available.

VB.NET uses ElseIf (one word, unlike Ruby's elsif) and closes the block with End If. Each branch condition requires the Then keyword. The overall structure is more verbose than Ruby but reads naturally in English. Single-line If condition Then statement is allowed for simple cases.

Select Case is VB's equivalent of Ruby's case/when. It supports comma-separated values (Case "a", "b"), ranges (Case 1 To 10), and comparisons (Case Is > 5). The Case Else is the default branch. Unlike Ruby's case/when, VB's Select Case does not have implicit fall-through — only the matching case executes.

VB.NET uses the If(condition, trueValue, falseValue) function as the ternary operator — not Ruby's ?: syntax. The two-argument form If(value, fallback) is a null-coalescing operator: it returns value if it is not Nothing, otherwise returns fallback. Avoid the older IIf() function — it is not type-safe and always evaluates both branches.

VB.NET has both short-circuit operators (AndAlso, OrElse) and non-short-circuit operators (And, Or). Always prefer AndAlso and OrElse in production code — they skip the right operand when the result is already known, preventing null reference errors when chaining method calls. Not is the logical negation (like Ruby's !).

For index = start To end is VB's counted loop — Next closes it. The Step clause sets the increment (default 1). A negative step counts downward. Unlike Ruby's block-based upto and times, the loop variable is mutable inside the loop body (though modifying it is discouraged).

For Each item As Type In collection iterates over any IEnumerable — arrays, lists, dictionaries, and any sequence. VB.NET has no built-in equivalent of Ruby's each_with_index; use a separate counter or call .Select(Function(item, index) ...) with LINQ. The loop variable is read-only — modifying it does not affect the collection.

VB.NET provides While...End While (test first), Do While...Loop, and Do Until...Loop (inverse). Placing the condition at the end with Do...Loop While or Do...Loop Until guarantees at least one execution — equivalent to Ruby's begin...end while. Unlike Ruby, VB has no until statement, but Do Until fills the same role.

Continue For skips the rest of the current iteration — equivalent to Ruby's next. Exit For exits the loop entirely — equivalent to Ruby's break. The keyword always names the loop type: Exit While, Exit Do, Continue Do. VB.NET does not support labeled loops for breaking out of nested loops — use a Boolean flag instead.

A Sub is a procedure that does not return a value — equivalent to a Ruby method that only produces side effects. The name uses PascalCase by convention. Subroutines declared in the same Module are called without a qualifier. Unlike Ruby's methods which always return the last expression, a Sub truly returns nothing (Void in .NET terms).

ByVal (the default) passes a copy — changes inside the sub do not affect the caller's variable. ByRef passes the actual variable — the sub can modify the caller's value directly. This is different from Ruby's semantics: Ruby always passes object references by value (you can mutate the object but can't rebind the caller's variable). ByRef is equivalent to a true C-style pointer parameter.

VB.NET uses the Optional keyword with a default value specified via = value. Named arguments use := syntax and can be passed in any order — useful when skipping optional parameters in the middle of a parameter list. This is identical in concept to Ruby's default arguments and keyword arguments.

ParamArray is VB's equivalent of Ruby's splat (*args) — it collects all remaining arguments into an array. It must be the last parameter, and the type must be a one-dimensional array. Unlike Ruby's splat, you cannot have additional required parameters after a ParamArray parameter.

A Function differs from a Sub by declaring a return type after As and using Return. The legacy style assigns to the function's own name instead of using Return — avoid this in modern VB.NET as it is confusing. Unlike Ruby, the return type is declared explicitly, and the Return statement is required.

VB.NET supports recursion without any special keyword — a Function can call itself directly. Using Long as the return type avoids integer overflow for larger factorial values. Unlike Ruby, VB.NET does not optimize tail calls in most contexts, so very deep recursion will throw a StackOverflowException — convert to an iterative approach for large inputs.

VB.NET lambdas use Function(params) expression for value-returning lambdas and Sub(params) expression for void lambdas. Multi-statement lambdas use the Function(params) ... End Function form. The type is expressed as Func(Of T1, T2, TReturn) or Action(Of T) — .NET delegate types from the System namespace.

LINQ provides Select() (Ruby's map), Where() (Ruby's select), and Aggregate() (Ruby's reduce). These accept lambdas and return lazy sequences. ToArray() or ToList() materializes the result. The naming difference — Select for map — is a common source of confusion for Rubyists.

VB.NET classes use Sub New() as the constructor — equivalent to Ruby's initialize. Me is VB's equivalent of Ruby's self and is used to disambiguate when a parameter name shadows an instance field. Instances are created with New ClassName(args). Fields declared with Private are not accessible outside the class.

VB.NET properties provide controlled access to fields. A Property with only a Get block and the ReadOnly modifier is equivalent to Ruby's attr_reader. An auto-implemented property (Public Property Age As Integer) generates a backing field automatically — equivalent to Ruby's attr_accessor. The WriteOnly modifier creates a write-only property.

Inherits declares the base class (equivalent to Ruby's <). Methods must be explicitly marked Overridable to allow overriding — unlike Ruby where all methods are overridable by default. The subclass marks its override with Overrides. MyBase.New() calls the parent constructor, equivalent to Ruby's super. Protected makes a member accessible to subclasses.

VB.NET interfaces are similar to Ruby modules used as mixins, but enforced at compile time. Interface declares the contract; Implements declares adherence. Each implemented member must explicitly name the interface method it satisfies (Implements ISpeakable.Speak). A class can implement multiple interfaces, allowing polymorphism without multiple inheritance.

Shared in VB.NET is equivalent to Ruby's self. methods and class variables — the member belongs to the class itself, not to instances. A Shared method is called on the class name directly. Shared fields are global state shared across all instances, analogous to Ruby's @@class_variables.

VB.NET uses Try...Catch...Finally...End Try — parallel to Ruby's begin...rescue...ensure...end. Multiple Catch blocks handle different exception types (most specific first). The Finally block always runs, even if an exception is thrown and not caught. The catch variable name (here ex) is a local alias for the caught exception — equivalent to Ruby's rescue SomeError => ex.

Custom exceptions inherit from Exception (or a more specific subclass) — equivalent to Ruby's pattern of inheriting from StandardError. The Throw statement raises an exception (Ruby's raise). MyBase.New(message) passes the message to the base class constructor. By convention, custom exception class names end in Exception.

A bare Throw inside a Catch block re-raises the current exception while preserving its original stack trace — equivalent to Ruby's bare raise. Using Throw error (with the exception variable) re-throws but resets the stack trace to the current line — avoid this pattern when you want to preserve the original call stack for debugging.

LINQ's query syntax reads like SQL: From...Where...Select. It compiles to the same method calls as the fluent syntax (.Where().Select()) — choose whichever reads more clearly. The query is lazy: it executes when iterated with For Each or materialized with .ToList(). This is more declarative than Ruby's chained block methods.

LINQ method syntax chains extension methods — Where(), OrderBy(), Take(), Skip(), GroupBy(), Distinct(). Each returns an IEnumerable for further chaining. Take(n) is Ruby's first(n); Skip(n) is Ruby's drop(n). GroupBy() returns groups of IGrouping objects with a .Key property.

LINQ aggregates provide Count(), Sum(), Min(), Max(), and Average() — these work like Ruby's equivalently named Enumerable methods. Distinct() removes duplicates (Ruby's uniq). Any(predicate) is Ruby's any? and All(predicate) is Ruby's all?.

A VB.NET Module is a sealed class whose members are implicitly Shared — you cannot create instances of it. This is similar to a Ruby module used only for module_function methods. Unlike Ruby modules, VB.NET modules cannot be mixed into classes. They are best used for utility functions and the program entry point.

Namespace organizes types hierarchically — equivalent to Ruby's nested modules. Dots in the namespace name (Geometry.Shapes) are shorthand for nested namespaces. The Imports statement at the top of a file brings a namespace into scope so you can write Circle instead of Geometry.Shapes.Circle.

This is one of the most common VB.NET mistakes for newcomers: Dim arr(n) creates an array with n+1 elements (indices 0 to n), because the argument is the upper bound index, not the count. To create an array with exactly 10 elements, write Dim arr(9). This legacy comes from original BASIC, where DIM A(10) created 11 elements (0 through 10).

VB.NET is entirely case-insensitive — message, Message, and MESSAGE all refer to the same identifier. This is the opposite of Ruby, where case is meaningful: name is a local variable and Name is a constant. The VB.NET convention uses PascalCase for public members and camelCase (or an underscore prefix) for private fields, but these are just conventions — the compiler treats them identically.

VB.NET's / operator returns Double even when dividing two integers — this is the opposite of Ruby, where 7 / 2 returns 3. For integer division, use the backslash \ operator. This surprises Rubyists expecting 7 / 2 to give 3. The Mod keyword (not %) computes the remainder.

Despite VB.NET being a case-insensitive language (for identifiers), string comparisons with = are case-sensitive by default (Ordinal binary comparison). This catches many Rubyists who assume VB's case-insensitivity extends to string data. Use String.Equals(a, b, StringComparison.OrdinalIgnoreCase) for case-insensitive string comparison. Adding Option Compare Text at the top of a file makes all string comparisons in that file case-insensitive.

Nothing is not the same as Ruby's nil: assigned to a value type (Integer, Double), it becomes the type's default (0, 0.0, False) — not a null. It only truly means "absent" for reference types and nullable value types (Integer?). Calling a method on a Nothing reference type throws NullReferenceException — unlike Ruby where calling methods on nil raises NoMethodError (descriptively).

Using And instead of AndAlso is a common VB.NET bug — And always evaluates both sides, causing NullReferenceException when the right side references an object that is Nothing. Ruby's && always short-circuits, so Rubyists switching to VB.NET must actively remember to use AndAlso and OrElse instead of And and Or.