Ruby.CodeCompared.To/C#

var in C# tells the compiler to infer the type — it is still statically typed. Once assigned, the variable's type is fixed. This is very different from Ruby, where any variable can hold any value at any time.

C# primitive types map directly to .NET types: int is System.Int32, bool is System.Boolean, char holds a single UTF-16 character (use double quotes for string). Every type has GetType() just like Ruby's .class.

const in C# is a compile-time constant — the value is embedded directly into the compiled code wherever it is used. Unlike Ruby constants, reassigning a const is a compile error, not just a warning. For values known only at runtime, use readonly on a field instead.

C# offers two patterns for parsing: int.Parse() throws FormatException on invalid input (like Ruby's Integer()), while int.TryParse() returns false and outputs the default (like Ruby's to_i returning 0). The out keyword passes a variable by reference to receive the parsed result.

object is the C# equivalent of Ruby's Object — it can hold any value. Using object defeats static typing and often requires boxing (wrapping value types in a heap allocation), so it should be avoided in favor of generics. In practice, you encounter object in older APIs and in switch pattern matching.

C# interpolated strings use $"..." with {expression} — essentially the same idea as Ruby's #{ }. Any valid C# expression can appear inside the braces, including method calls and arithmetic. The $ prefix must immediately precede the opening quote.

C# string methods are PascalCase (ToUpper, Contains, Replace) rather than snake_case. Strings are immutable in both languages — all methods return a new string. Note that Length is a property, not a method call, so it has no parentheses.

Split is an instance method; Join is a static method on the string class (written string.Join). This is the opposite of Ruby where both split and join are instance methods. The separator is the first argument to string.Join.

The @"..." verbatim string treats every backslash as a literal character — useful for Windows paths and regular expressions. C# 11 added raw string literals ("""...""") that also support embedded double quotes and interpolation when prefixed with $"""...""".

In C#, strings are immutable and + in a loop allocates a new string on every iteration — O(n²) behavior. StringBuilder maintains a mutable buffer and is the idiomatic solution for building strings incrementally, much like Ruby's StringIO or an array of parts joined at the end.

List<T> is the closest C# equivalent to Ruby's Array — it grows dynamically and provides Add, Remove, Insert, and indexing. The <T> is a type parameter that enforces that every element is the same type. Count is the property name (not Length — that is for fixed arrays).

Dictionary<K,V> is C#'s equivalent of Ruby's Hash. Accessing a missing key throws KeyNotFoundException (unlike Ruby, which returns nil); use TryGetValue or GetValueOrDefault for safe access. Iteration yields KeyValuePair<K,V> structs with .Key and .Value properties.

HashSet<T> is the direct equivalent of Ruby's Set. It guarantees uniqueness and provides O(1) Contains checks. It also supports set operations: UnionWith, IntersectWith, ExceptWith, and IsSubsetOf — mirroring Ruby's |, &, -, and subset?.

C# arrays are fixed in size after creation — to add or remove elements you need a List<T>. The Length property works on arrays (not Count). C# also supports multi-dimensional arrays (int[,]) and jagged arrays (int[][]), which Ruby handles with nested arrays.

C# tuples (introduced in C# 7) are value types with named fields — no separate Struct definition needed. They are ideal for returning multiple values from a method without creating a class. Tuple elements can be destructured with var (a, b) = tuple, similar to Ruby's multiple assignment.

C# uses else if (two words) and curly-brace blocks; Ruby uses elsif (no space, no e on else) and end. The condition must be wrapped in parentheses in C#. Unlike Ruby, if in C# is a statement, not an expression — it cannot appear on the right side of an assignment (use the ternary ? : instead).

The ternary operator works identically in both languages: condition ? value_if_true : value_if_false. In C#, this is the primary way to do inline conditional assignment since if is a statement. For multi-branch inline logic, prefer the switch expression (see the Pattern Matching section).

foreach in C# is the equivalent of Ruby's each — it iterates over any IEnumerable<T>. Unlike Ruby, there is no built-in each_with_index; you maintain a counter manually, or use LINQ's Select((item, i) => ...) to project index alongside the element.

C# has a classic C-style for loop with init, condition, and increment — a construct that Ruby deliberately omitted in favor of block-based iteration. The while loop is syntactically very similar to Ruby's. C# also has do { } while (condition); which always executes the body at least once.

The is pattern in C# combines a type check with a variable binding — if the match succeeds, number is declared and assigned in one step. This is more concise than Ruby's is_a? + local assignment. C# 9 added is not for negated patterns, replacing the verbose !(x is T).

The switch expression (C# 8+) is an expression — it produces a value directly, just like Ruby's case/when. Arms use => (fat arrow) and are separated by commas. The discard pattern _ plays the role of Ruby's else. The compiler warns if the arms are not exhaustive.

Property patterns match against the values of object properties or tuple fields — very similar to Ruby 3's hash pattern matching with in { key: pattern }. Patterns can nest: you can write { Address: { City: "Paris" } } to match a nested property. Combined with relational patterns (>= 18), they express complex conditions concisely.

C# switch expressions can dispatch on type, replicating Ruby's case/when with class arguments. Each arm binds the value to a named variable (intValue, text) for use in the expression. This is far more powerful than a traditional is chain because it is exhaustive and composable with property patterns.

C# methods require a return type declaration (or void). Expression-bodied methods using => are the C# equivalent of Ruby 3's one-liner method syntax, and are idiomatic for short, single-expression methods. Top-level functions (used in these examples) are syntactic sugar for a Main method in a hidden Program class.

C# optional parameters are declared with a default value in the method signature — syntactically similar to Ruby keyword arguments with defaults. Unlike Ruby, optional parameters cannot be sprinkled between required ones arbitrarily; all optional parameters must come after all required ones. The caller can omit trailing optional arguments from right to left.

C# named arguments let callers pass arguments by name in any order, similar to Ruby keyword arguments. However, unlike Ruby, named arguments are opt-in at the call site — the method signature uses normal positional parameters. This is a useful self-documenting technique when a method has several parameters of the same type (e.g., multiple bool flags).

The params keyword is C#'s equivalent of Ruby's splat operator (*args). It must be the last parameter and produces an array inside the method. The caller can pass individual arguments or an existing array — either works. Unlike Ruby's splat, params is typed: params int[] only accepts integers.

Func<T, TResult> is a generic delegate type for lambdas that return a value — the last type parameter is always the return type. Func<int> takes no arguments; Func<int, int, bool> takes two ints and returns bool. C# lambdas are called directly with (), not with .call().

Action<T> is used when the lambda produces no return value. Action (no type parameter) takes no arguments. Choosing between Func and Action is purely about whether the delegate returns a value — there is no ambiguity because the type system enforces it.

C# closures capture variables by reference, just like Ruby lambdas. If the captured variable changes after the lambda is created, the lambda sees the new value. This is a common source of bugs in loops — each iteration of a for loop shares the same loop variable, so all closures created in the loop see the final value.

Local functions (C# 7+) are named functions defined inside another method. Unlike lambdas (Func/Action), local functions support recursion naturally, can have static to prevent accidental closure capture, and incur no delegate allocation. They are the preferred way to define a helper that is only used within one method.

Select is Ruby's map — it projects each element through a function and returns a new sequence. LINQ methods return lazy IEnumerable<T> sequences; call ToList() or ToArray() to materialize the results into a concrete collection. Skipping ToList() is fine when you will immediately iterate or chain more LINQ operators.

Where is Ruby's select/filter — it retains only elements for which the predicate returns true. The naming difference (Where vs select) is intentional: LINQ borrows SQL vocabulary (SELECT, WHERE, GROUP BY) since one goal was to make database queries and in-memory queries look the same.

These three LINQ methods mirror Ruby's any?, all?, and count with a block almost exactly. Any() with no predicate checks whether the sequence is non-empty. Count() with no predicate returns the total element count — but prefer .Count (property) over .Count() (LINQ method) on lists, since the property is O(1) while the method is O(n).

OrderBy sorts ascending (like Ruby's sort_by); OrderByDescending reverses the order. ThenBy adds a secondary sort key — equivalent to Ruby's multi-key sort using an array: sort_by { |w| [w.length, w] }. LINQ's sort is stable: elements that compare equal retain their original relative order.

GroupBy is Ruby's group_by — it groups elements by a key function and returns a sequence of IGrouping<TKey, TElement>. Each grouping has a Key property and is itself an enumerable of the matching elements. You can chain LINQ after GroupBy to compute aggregates per group.

Aggregate is Ruby's reduce / inject. The first argument is the seed (initial accumulator value). For common operations, LINQ provides optimized shortcuts: Sum, Min, Max, Average — prefer these over Aggregate when they apply.

C# properties ({ get; set; }) replace Ruby's attr_reader/attr_accessor. The init accessor (C# 9+) allows setting a property only in the constructor or an object initializer — it is immutable after construction, like attr_reader with a private setter. Expression-bodied properties (=>) replace simple getter methods.

C# uses : for inheritance (not <). Overridable methods must be declared virtual in the base class, and override in the subclass — unlike Ruby where all methods are implicitly overridable. The base(name) call invokes the parent constructor, equivalent to Ruby's super.

C# access modifiers (public, private, protected, internal) are declared per member and enforced at compile time — unlike Ruby where private applies to everything below it and is only enforced at runtime. The internal modifier means "visible within the same assembly (project)" — a concept with no Ruby equivalent.

C# static members belong to the class itself, not to any instance — the same as Ruby's class variables (@@name) and class methods (def self.name). Static members are accessed via the class name (Counter.Total), never via an instance. A class with only static members can be declared static class to prevent instantiation.

C# interfaces define a contract — a set of methods and properties that implementors must provide. Ruby achieves the same goal through duck typing and modules. The key difference: in C#, the contract is verified at compile time; in Ruby, a missing method only fails at runtime. A C# class can implement multiple interfaces (unlike single inheritance for classes).

A C# class can implement multiple interfaces by listing them with commas after the colon. This gives C# a form of multiple "type membership" similar to Ruby's multiple mixins, but without inheriting any implementation. C# 8 added default interface methods — interface members with a body — which allows some code sharing similar to Ruby module methods.

An abstract class can have both abstract methods (no body — subclasses must implement) and concrete methods (with body — shared implementation). Unlike an interface, an abstract class can have state (fields) and constructors. The rule of thumb: use an interface when you have a pure contract; use an abstract class when you also want to share implementation.

Records (C# 9+) are reference types that get value-based equality, a generated ToString(), and Deconstruct for free — similar to Ruby's Data.define. A positional record like record Point(int X, int Y) generates the constructor, properties, and Deconstruct method automatically. Records are immutable by default when using init-only properties.

The with expression creates a copy of a record with some properties changed — the original is untouched. This is the idiomatic way to "update" immutable data in C#, and it mirrors Ruby's Data#with method. The syntax is existingRecord with { Property = newValue }.

A record struct is a value type — assignment copies the entire value rather than sharing a reference. This contrasts with Ruby Struct, which is a reference type (mutations through one alias are visible through another). Value semantics eliminate a whole class of aliasing bugs but require awareness of copying costs for large structs.

The structure is nearly identical to Ruby's begin/rescue/ensure. The key differences: C# uses catch (not rescue), requires the exception type in the catch clause (no bare rescue), and uses finally instead of ensure. Multiple catch blocks handle different exception types, like multiple rescue clauses in Ruby.

Custom exceptions inherit from Exception (or a more specific base class). The convention is to end the class name with Exception. Pass a descriptive message to the base constructor via : base(message). C# uses throw new Exception() where Ruby uses raise.

Exception filters (C# 6+) add a when (condition) clause to a catch block. If the condition is false, the exception is not caught and continues to the next handler. Unlike putting a condition inside the catch body and re-throwing, filters do not unwind the stack — debuggers can still see the original call site.

Value types in C# (int, bool, double, structs) cannot hold null by default — this is a key difference from Ruby where every object can be nil. Adding ? creates a nullable wrapper: int? is Nullable<int>. Check with .HasValue and retrieve with .Value (throws if null) or .GetValueOrDefault().

The null-coalescing operator ?? returns the left operand if it is non-null, otherwise the right operand — very similar to Ruby's ||, but importantly, it only triggers on null (not on false). The ??= operator (C# 8+) assigns the right operand only if the left is null, mirroring Ruby's ||= but without the false-value edge case.

The null-conditional operator ?. is C#'s equivalent of Ruby's safe navigation operator &. — it returns null immediately if the left side is null, rather than throwing NullReferenceException. It can be chained: user?.Address?.City. The result type becomes nullable; combine with ?? to provide a default: user?.Name ?? "Unknown".

C#'s async/await is the primary concurrency model for I/O-bound work. An async method returns a Task (void) or Task<T> (with result); await suspends the current method until the task completes without blocking the thread. Top-level statements in C# 9+ support await directly — no outer async Main needed.

Task.WhenAll runs multiple async operations concurrently and waits for all of them to complete, collecting their results in an array. This is the async equivalent of Ruby's thread join. Task.WhenAny instead returns the result of whichever task finishes first — useful for timeouts or racing multiple data sources.

Task.Run is used for CPU-bound work that should not block the calling thread — it submits the work to the .NET thread pool. For I/O-bound work (network, file), use await with genuinely async APIs instead (e.g., File.ReadAllTextAsync) — those do not need Task.Run and are more efficient.

C# string interpolation supports format specifiers after a colon: {value:F2} formats to 2 decimal places, {value:N0} adds thousands separators, {value:X} formats as hex. A width can precede the colon: {value,10} right-aligns in 10 characters; {value,-10} left-aligns. This replaces Ruby's printf style.

The static File class provides simple one-liners for reading and writing files, mirroring Ruby's File.read and File.write. For large files, prefer the streaming APIs (File.OpenRead, StreamReader) to avoid loading the entire file into memory. Async variants (File.ReadAllTextAsync) are available for use with await.

C# format strings use standard and custom format specifiers: "C2" is currency with 2 decimals, "N0" is a number with thousands separators and no decimals, "F3" is fixed-point with 3 decimals. Date formatting uses DateTime.ToString("pattern") where patterns like "yyyy-MM-dd" work similarly to Ruby's strftime.