Visual Basic.CodeCompared.To/Ruby

No module, no entry point, no imports, no type declarations, and no parentheses. A Ruby file is a program and its statements run top to bottom. puts is the counterpart of Console.WriteLine — the name is short for "put string", and like almost everything in Ruby it is a method call whose parentheses you may leave off.

$"...{name}..." becomes "...#{name}...", with no prefix on the string — every double-quoted Ruby string interpolates, and single-quoted ones do not. Format specifiers do not carry over: {score:D5} becomes format("%05d", score), using the same printf vocabulary C uses. Anything inside #{} is evaluated and has to_s called on it, so #{score * 2} works.

puts adds a newline and calls to_s — given an array it prints one element per line, which surprises people. print is Console.Write: no newline. p prints inspect instead, which shows the structure — [1, 2, 3] with its brackets and quotes intact — and returns its argument, making it the debugging tool you reach for. Every object has both to_s (for people) and inspect (for programmers), a distinction .NET collapses into ToString.

Ruby closes blocks with end — not End If, End Sub or End Module, just end, one word for every construct. There are no braces and no Then, the condition needs no parentheses, and ElseIf becomes elsif (one e, no e in the middle). Indentation is two spaces by convention and carries no meaning, unlike Python. If the End keyword is the thing you would miss, you do not have to.

' becomes #. There is a block form, =begin/=end, but it must start at column zero and is so rarely used that many Ruby programmers have never written one. Documentation is written as ordinary # comments above the method: the RDoc and YARD tools read them, so there is no XML and no <summary> tag. A magic comment on the very first line — # frozen_string_literal: true — is a directive rather than a comment, and the strings section explains it.

Identifiers are case-sensitive, so customerName and CustomerName differ. More than that, a name beginning with a capital letter is a constant — that is how Ruby knows MAXIMUM_RETRIES and every class name are constants, without a Const keyword. Reassigning one is allowed but warns, which is Ruby's style throughout: it tells you and trusts you. Conventions are snake_case for variables and methods, CamelCase for classes, SCREAMING_SNAKE_CASE for constants, @name for instance fields.

Any statement may carry a trailing if, unless, while or until. unless is If Not with the negation built into the keyword, and it reads far better than if !ready. These statement modifiers are idiomatic for short guard clauses — return if list.empty? — and considered poor style when the statement grows long enough that the reader meets the condition too late.

Assignment creates the variable; there is no Dim, no As, and no Option Explicit to forget. The type belongs to the value, not the name, so a variable can hold an integer and then a string. Note that true and false are lower case, and that a name you only read without assigning is a method call as far as Ruby is concerned — which is why a typo produces NameError: undefined local variable or method rather than nil.

In .NET an Integer is a value type that must be boxed to be treated as an Object. In Ruby there is no such split: 42 is an instance of Integer, nil is the single instance of NilClass, and both answer .class. That is why -5.abs and 3.times read the way they do — the operation belongs to the number. It also means Math.Abs(x)-style static helpers are rare; the method is on the object instead.

Nothing becomes nil, and the test is value.nil? — a method, because nil is an object. The mismatch worth noting is on the Visual Basic side: Dim n As Integer = Nothing stores zero, since Nothing means "the default value for this type". Ruby has no such notion. nil answers a surprising number of methods usefully (to_s is "", to_a is []), and || supplies a fallback the way the two-argument If() does.

Short, Integer and Long all become Integer, which grows to whatever size is needed — 2**200 is exact, and there is no overflow. Double becomes Float and misbehaves identically, which is why 0.1 + 0.2 is untidy in both columns. Decimal becomes BigDecimal from the standard library, constructed from a string so the precision is not already lost. Ruby also has exact Rational numbers, which .NET has no counterpart for at all.

The to_ methods — to_i, to_f, to_s, to_a — never fail: "12x".to_i is 12 and "oops".to_i is 0, which is convenient and dangerous in equal measure. The capitalized functions — Integer(), Float() — are strict and raise on anything malformed, which is CInt under Option Strict On. Integer(text, exception: false) returns nil instead of raising, and is the closest thing to TryParse.

= for comparison becomes ==, and <> becomes !=. Visual Basic's Is — reference identity — becomes equal?, a method rather than an operator. Ruby has a third form, eql?, which compares value and type: 1 == 1.0 is true, 1.eql?(1.0) is false, and it is eql? that hashes use for keys. There is no loose-equality trap as in JavaScript — == never converts between unrelated types.

AndAlso becomes &&, OrElse becomes ||, Not becomes !. Ruby also has and, or and not, which do the same thing at much lower precedence — low enough that x = a or b assigns a and then evaluates b, which is almost never what was meant. Use the symbols for conditions and reserve the words for control flow (do_thing or raise "failed"). As in JavaScript, || returns its first truthy operand rather than a boolean, which is what makes it a fallback operator.

Ruby has no \ operator, and / between two integers truncates — so 17 / 5 is 3, not 3.4. A Visual Basic / copied straight across silently starts doing integer division, exactly the trap C# sets. Make an operand a float (17 / 5.0) or call fdiv. Mod becomes %, ^ becomes ** (^ is bitwise exclusive-or). Ruby floors rather than truncating, so -17 / 5 is -4 where Visual Basic gives -3.

Two-argument If(value, fallback) becomes || — note this falls back on false as well as nil, since those are the only falsy values. Three-argument If(condition, a, b) becomes condition ? a : b. The new one is safe navigation, &.: if the receiver is nil the call yields nil instead of raising, which collapses a whole nested null check into one expression.

CompareTo becomes <=>, the "spaceship" operator, returning -1, 0 or 1. Defining it on your own class and including the Comparable module gives you <, >, between? and sorting for free. sort_by is what you almost always want over sort: it takes the key rather than a comparison, so OrderBy(Function(x) x.Length) becomes sort_by(&:length). That &:length is a symbol turned into a block, covered in the blocks section.

Trim→strip, ToUpper→upcase, Contains→include?, StartsWith→start_with?, Replace→sub/gsub/tr. The question mark is part of the name: a method ending in ? returns a boolean, by convention throughout Ruby. A method ending in ! is the dangerous or mutating variant — strip returns a new string, strip! changes it in place and returns nil if nothing changed. Neither punctuation mark has any meaning to the parser; they are conventions the whole ecosystem keeps.

text[start, length] is Substring exactly. text[range] takes a range, and negative positions count from the end, so text[-5..] is Right(text, 5). text[0] gives a one-character string — Ruby has no character type. Passing a regular expression returns the match, which is a genuinely different capability: text[/B\w+/] pulls out the first word starting with B. InStr becomes index, and it is zero-based rather than one-based.

A .NET String is immutable, so StringBuilder exists. A Ruby String is mutable, so << appends in place and no builder is needed. But Ruby is moving toward frozen literals: today mutating one works and warns, and the magic comment # frozen_string_literal: true on line one makes it a FrozenError now. The forward-compatible way to get a mutable string is the unary plus, +"", or String.new — both used above so this example neither warns today nor breaks when the default flips. .freeze makes any object immutable, not just strings.

A symbol is written :name and is an immutable, interned name — the same symbol written twice is the same object, which two identical strings are not. That makes symbols the natural choice for hash keys, method names and any fixed label, and { width: 100 } is shorthand for { :width => 100 }. Think of them as the role a Visual Basic Enum member plays, without needing to declare the enum first. Convert with to_s and to_sym.

A double-quoted string interpolates and honors escapes; a single-quoted string does neither, so 'C:\reports' needs no doubling — the closest thing to @"..." in C#. A heredoc, <<~TEXT ... TEXT, runs until its terminator; the squiggle strips the common leading indentation, so the text can be indented with the code around it. Heredocs interpolate by default, and <<~'TEXT' turns that off.

Add becomes << (or push), Insert(0, x) becomes unshift, Count becomes length or size. Indexing uses square brackets, and negative indices count from the end — fruits[-1] is the last item, so UBound has no counterpart and needs none. There is also first and last, which say what they mean. An array holds anything, mixed, with no element type to declare.

Dictionary(Of K, V) becomes a Hash, written { key => value } — or { key: value } when the keys are symbols. Iterating yields the key and value as two block parameters, so there is no KeyValuePair to unpack. ContainsKey becomes key?, and TryGetValue becomes fetch(key, default) — fetch with no default raises rather than returning nil, which is what you want when a missing key is a bug. Hash.new(0) gives every unseen key a default of zero, which turns a tally loop into one line.

1..5 includes 5; 1...5 (three dots) stops at 4. A range is an object with methods, so it answers cover? for a containment test, to_a for a list, and every Enumerable method directly. It works on anything comparable, including strings. And because case uses ===, a range can be a when clause — which is exactly Visual Basic's Case 4 To 6, reached from a completely different direction.

A method returns its last expression, so [values.min, values.max] is the return. On the left, low, high = ... takes the array apart, and *rest collects whatever remains. The same mechanism swaps two variables in one line with no temporary. Ruby has no named tuple as Visual Basic does; when the parts need names, the answer is a Struct, a Data object or a hash.

HashSet(Of T) becomes Set, which needs require "set". Duplicates collapse on construction in both. Where .NET spells the operations as mutating methods, Ruby offers &, | and - as non-mutating operators returning a new set — the same reading as the mathematics. Contains becomes include?, matching arrays and strings, which is the sort of consistency Ruby is built on.

Only nil and false are falsy. Zero is truthy, an empty string is truthy, an empty array is truthy. That is different from Python (where all three are falsy) and from JavaScript (where zero and empty string are falsy but an empty array is not), and it is the easiest of the three to remember. The practical effect is that if value means exactly "is there a value", so emptiness is asked for explicitly: empty?, zero?, any?.

Select Case→case, Case→when, Case Else→else, End Select→end. Case 2, 3 and Case 4 To 6 translate almost letter for letter. No branch falls through, as in Visual Basic. Two things are better: the whole case is an expression whose value is the chosen branch, so the returns disappear; and each when is tested with ===, so a class, a regular expression, a range or a lambda can be a branch — which is what replaces Case Is > 100.

An if evaluates to whatever its chosen branch evaluated to, so it can sit on the right of an assignment — no repeated grade =, no variable declared empty and filled in later. The same is true of case, begin/rescue, and a method body, which returns its last expression. Visual Basic has only the three-argument If() function for this, limited to one expression per branch; Ruby has no such limit.

Written with in, a case becomes pattern matching: { name: String => name } matches a hash with a name key whose value is a String, and binds it to a local called name. Arrays, objects, ranges and guards all work the same way. This is what replaces the chain of ContainsKey tests in the anchor column, and Visual Basic has nothing like it — the nearest equivalent anywhere in .NET is C#'s property patterns.

For Each ... Next becomes each with a block: the code between do and end (or between braces, for one-liners), with its parameters between vertical bars. The collection controls the loop and hands each item to your block. That is why each_with_index, 3.times and (1..3).each all read the same way — they are ordinary methods, not syntax, and you can write your own. Braces bind more tightly than do/end; convention is braces for one line, do/end for more.

Where→select, Select→map, Any→any?, All→all?, FirstOrDefault→find, OrderBy→sort_by, Aggregate→reduce, GroupBy→group_by, Sum/Min/Max/Count keep their names in lower case. Note the false friend: Ruby's select is LINQ's Where, not its Select. All of it comes from one module, Enumerable, which any class gets by defining each and including it — so your own types become fully queryable for the price of one method.

When a block does nothing but call one method on its argument, { |word| word.upcase } can be written &:upcase. The & converts its operand into a block, and a symbol knows how to become one — so &:upcase means "call upcase on each item". Visual Basic's AddressOf is the nearest thing in spirit, but it names a method in scope rather than one to be called on the argument. The same & in a parameter list captures a block as an object, which the next row uses.

There is no Func(Of T) parameter and no delegate type. Every method may be passed a block, yield calls it, and block_given? asks whether one arrived. This is the mechanism behind each, map, File.open and essentially every Ruby API that wraps something — the method controls setup and cleanup while your code supplies the middle. That is also what makes Using unnecessary, as the errors section shows. To keep the block as an object instead, name it with &work in the parameter list and call it with work.call.

->(value) { ... } creates a lambda, Ruby's equivalent of a Func or Action — one object type covers both, since a lambda always returns its last expression. Call it with call, or the shorthands .() and []. There is a looser cousin, Proc.new / proc, which does not check its argument count and whose return returns from the enclosing method; lambdas behave the way a .NET delegate does, so prefer them.

Sub and Function both become def. A method returns its last expression, so Return is only written for an early exit — anyone who remembers VB6's Function Add ... Add = 5 will find this familiar in spirit. Parentheses are optional at the call site, which is why announce "starting" and puts add(2, 3) both read as they do. The one-line form def twice(value) = value * 2 is Ruby 3.0 and later, and is the direct counterpart of Function Twice(value) As Integer written on one line.

A parameter written greeting: "Hello" is a keyword argument: it must be passed by name, in any order, which removes the "what is the third argument again" problem entirely. Writing greeting: with no default makes it required. name:= becomes name:. ParamArray becomes *values, and **options collects any extra keyword arguments into a hash — the half Visual Basic has no counterpart for.

There is no ByRef. Assigning to a parameter rebinds the local name and the caller sees nothing, which is why twice has to return its result. Calling a mutating method on a passed object changes the object the caller holds. The rule is "rebinding versus mutating", not "value versus reference" — and Ruby gives you a way to opt out: freeze the object and the mutation raises instead.

Ruby dispatches on the method name alone, so there is no overload resolution and no way to have Area(side) and Area(width, height) at once — defining the second silently discards the first. The two replacements are default arguments (one method that notices what it was given) and a case on the argument's class. Constructors have the same limitation: one initialize per class, so multiple Sub New overloads become class-level factory methods such as Point.from_polar(...).

Public Sub New becomes initialize, and New Person(...) becomes Person.new(...) — new is an ordinary class method, not a keyword. A name beginning with @ is an instance variable: it needs no declaration, springs into existence on first assignment, and is always private. Me becomes self, and is rarely written because a bare method call already goes to self. Everything in a class body executes when the class is defined, which is what makes the next row possible.

Public Property Label becomes attr_accessor :label, which defines a reader and a writer; attr_reader alone is ReadOnly Property. A setter with logic is just a method whose name ends in = — def celsius=(value) — and Ruby lets you call it as reading.celsius = 100. Fahrenheit with only a getter is simply a method. Because there is no syntactic difference between a field read and a method call, you can start with attr_accessor and replace it with a real method later without any caller changing.

Inherits Animal becomes < Animal on the class header. Overridable and Overrides have no equivalent — redefining a method in a subclass is all it takes, which also means a misspelled name quietly adds a method rather than replacing one. MyBase becomes super, and bare super passes the same arguments through, which is why Dog needs no initialize at all. MustInherit has no keyword: a base class that should not be used directly raises NotImplementedError from the method instead.

An Interface becomes a module, and Implements becomes include. The difference is that a module may contain real method bodies — so greet_twice is shared code, not a declaration, and any class that supplies greet gets it. This is a mixin, and it is how Comparable and Enumerable give you dozens of methods for defining one. A class may include any number of modules, which is multiple inheritance of behavior without the diamond problem, and is_a? still answers correctly.

Data.define (Ruby 3.2 and later) builds an immutable value object: readers for each field, a keyword constructor, == comparing by value, a useful inspect, and with for a copy with changes. That is what a Visual Basic Structure gives you plus what it does not. Its older sibling Struct.new is mutable and allows positional construction. Note the class is assigned to a constant — Point — which is exactly why class names begin with a capital letter.

Imports both loads an assembly reference and shortens names. Ruby separates them: require loads a file and runs it, once; shortening a name is include for a module's methods or a plain constant assignment (Serializer = JSON). Names are not scoped by file — once a class is defined it is visible everywhere — so require is about making sure the definition has happened, not about visibility. Nesting is written with ::, as in Net::HTTP.

A gem is a NuGet package; RubyGems is nuget.org; the Gemfile is the PackageReference list in your project file, and Gemfile.lock is packages.lock.json. bundle install is dotnet restore, and bundle exec runs a command against exactly the locked versions — the step with no .NET counterpart, because .NET binds versions at build time. The version constraint ~> 8.0 means "at least 8.0, less than 9.0".

The whole tally loop is tally. That is representative — Enumerable alone has tally, partition, chunk_while, each_cons, each_slice, zip, flat_map, sum and minmax, most of which LINQ has no counterpart for. Beyond it the standard library ships json, csv, date, set, net/http, digest and logger. Anything more comes from a gem, and the ecosystem is unusually deep for web work.

Try→begin, Catch x As T→rescue T => x, Finally→ensure, End Try→end. The extra clause is else, which runs only when nothing was raised. The important difference: a bare rescue catches StandardError, not every exception — SignalException, NoMemoryError and SystemExit descend from Exception and are deliberately left alone. Writing rescue Exception to be thorough is a well-known mistake, because it swallows Ctrl-C.

Throw New becomes raise, and Inherits Exception becomes < StandardError — inherit from StandardError, not Exception, so a bare rescue catches it. MyBase.New(message) becomes super(message). Note the statement modifier doing the guard on one line, and that raise Class, argument is shorthand for raise Class.new(argument). Convention ends the class name in Error, not Exception. A bare raise inside a rescue re-raises with the backtrace intact.

Ruby has no Using and no IDisposable. Instead, the method that opens the resource takes a block, does its own ensure, and hands you the open thing — File.open, StringIO.open, Net::HTTP.start all work this way. The caller cannot forget the cleanup, because the caller never owns it, which is a stronger guarantee than Using gives. Writing your own takes four lines, as with_resource shows; note that a method body can carry ensure directly with no begin.

A class body can be reopened at any time and gains whatever you put in it — so String really does get a shout method, on every string in the program. That is far more powerful than an extension method, and far more dangerous: two libraries defining the same method on String silently overwrite each other, which is why this is called monkey patching and treated with caution. Refinements are the disciplined version: refine plus using scopes the change to one file. Prefer them, and prefer your own class over either.

The each loop above runs at class-definition time and define_method creates a real method for each name. This is how attr_accessor itself is implemented, and how Rails generates a method per database column without anyone writing them. .NET can do this only by emitting IL or generating source at build time; here it is three lines of ordinary Ruby. respond_to? asks whether an object has a method, which is the duck-typed replacement for an interface check.

When no method matches, Ruby calls method_missing with the name and arguments, and whatever that returns is the result. So record.title works without a title method existing. The nearest .NET equivalents are DynamicObject and Default Property, both far more constrained. Always define respond_to_missing? alongside it, or respond_to? will lie about the object. This is powerful and easy to overuse: it makes typos into silent successes, which is exactly the trade the anchor column's explicit indexer avoids.

Visual Basic reserves \ for integer division and makes / always floating-point. Ruby has no \, and / between two Integers truncates — so an average calculation that was correct becomes wrong with no error, no warning and a plausible-looking result. Make one operand a Float (2.0) or call fdiv. Worth grepping every / for when porting.

Only nil and false are falsy. 0 is truthy, "" is truthy, [] and {} are truthy. If you have written any Python this is backwards from what you expect, and if you have written JavaScript it is half backwards. In practice it is the least surprising of the three rules once learned, because if value then means precisely "is there a value here" — but a ported If count = 0 written as if !count is simply wrong, and prints nothing rather than raising.

alias_list = original gives the same array a second name; dup makes a shallow copy, matching New List(Of Integer)(original). The version worth memorizing is the second half: Array.new(3, row) stores the same object three times, so mutating one row mutates all three. Passing a block instead — Array.new(3) { ["-"] } — runs it once per element and gives three separate arrays. The same trap applies to Hash.new([]).

Ruby checks syntax before running and nothing else. A misspelled name, a call with the wrong arity, a method that does not exist — all surface when the line executes, and a branch that never runs is never checked. There is no Option Strict and no Option Explicit. What replaces them is discipline the language does not enforce: a test suite that exercises every branch (RSpec or Minitest), a linter (RuboCop), and optionally type signatures in RBS checked by Steep or Sorbet. Set those up first, not after the first production surprise.

Ruby dispatches on the method name alone, so the second area replaces the first with no error and no warning — and the only sign is an ArgumentError at the call site later. The same applies across files, which is what makes monkey patching risky. The replacements are default arguments, keyword arguments, or a case on the argument's class. When you genuinely need two constructors, write class-level factory methods instead of two initialize definitions.

My.Computer.Name is Socket.gethostname, My.Computer.FileSystem is File, Dir and FileUtils, IsNumeric is Integer(x, exception: false), Now is Time.now or Date.today. MsgBox and InputBox have no counterpart: Ruby has essentially no desktop-GUI story, so a WinForms application does not port — it becomes a command-line tool or, far more commonly, a web application in Rails or Sinatra. That is the honest shape of this move, and it is a bigger decision than any syntax on this page.