C#.CodeCompared.To/Kotlin

C# top-level statements dropped the Main ceremony; Kotlin kept a fun main() but it is one line, with no class wrapper. println replaces Console.WriteLine, and semicolons are gone.

Kotlin functions live at the top level of a file — no class, no static. The expression body = number * number is C#’s =>, with the return type inferred. Note the convention flip: functions and properties are camelCase, not PascalCase.

val is a genuine read-only local — assignable once, from any runtime expression — which C# has no equivalent for (const handles only compile-time constants). Kotlin style is val everywhere, var only where mutation is the point.

The headline difference: C#’s nullable reference types are advisory — warnings a build can ignore, annotations the runtime never sees. Kotlin’s String? is a different type from String, and dereferencing it without a check refuses to compile. The Elvis operator ?: is C#’s ??.

?. transfers directly. The fallback operator changes shape: C#’s ?? becomes Kotlin’s ?: — same precedence position, same short-circuit behavior.

C#’s null-forgiving ! is erased — a wrong one lets null glide on to fail somewhere else. Kotlin’s !! performs a real check and throws at that line, so the failure is immediate and localized. Both are code smells; Kotlin’s at least fails honestly.

Kotlin’s as? is C#’s as — null on failure. The bare as in Kotlin is the throwing cast, C#’s (string)value. And Any is object: the root of every Kotlin type.

?.let { } runs the block only when the value is non-null, with the unwrapped value as the parameter — the expression-shaped version of the is not null guard. Plain if (entered != null) also works and smart-casts (see the Sealed Types section).

Every Kotlin string literal interpolates — there is no opt-in $"…" prefix. A bare identifier needs only $name; any real expression takes braces, ${expr}.

Both languages triple-quote raw strings. C# 11’s version strips indentation implicitly, keyed off the closing quotes; Kotlin keeps every space unless you call trimIndent() (or trimMargin()). Kotlin raw strings still interpolate $.

ToUpper is uppercase(), membership reads naturally as "time" in phrase, and joining is an extension on the collection itself (joinToString) rather than a static string.Join.

Kotlin has no ternary operator because it does not need one: if/else is already an expression. With block bodies, the last expression of each branch is the value.

when is the closest cousin of C# 8’s switch expression: comma-separated alternatives replace or patterns, ranges are the literal in 400..499, and else plays _. There is no fallthrough anywhere in the language.

A C# type pattern must bind a fresh name (int number); Kotlin’s is Int -> smart-casts item itself inside the branch — item.length compiles because the compiler already knows it is a String there.

Because try yields a value, the result lands in a val with no mutable placeholder declared outside the block. (For this particular job, input.toIntOrNull() ?: 0 is more idiomatic still — the stdlib prefers null returns over exceptions for parsing.)

The polarity flips: listOf returns a List interface with no mutating members at all — not a wrapper view over something mutable, a different type. mutableListOf is the explicit choice, the mirror image of C# reaching for IReadOnlyList.

The whole LINQ vocabulary exists under functional names: Where → filter, Select → map, First → first, GroupBy → groupBy. The lambda moves outside the parentheses (trailing-lambda syntax), and empty parentheses disappear entirely.

The performance instinct to recalibrate: LINQ is lazy by default, but Kotlin collection operators are eager — each step materializes a new list. asSequence() opts back into LINQ-style deferred, element-at-a-time evaluation, worth it for long chains or early-exit operations like take.

The infix to builds a Pair, indexers work both ways, and destructuring in the loop matches C#’s tuple deconstruction. One guarantee C# never gives: mutableMapOf is backed by LinkedHashMap, so iteration order is insertion order, always.

Ranges are language syntax: 1..5 is inclusive of both ends (note the off-by-one trap against Enumerable.Range(start, count)), ..< excludes the end, and downTo/step replace the C-style descending loop.

A near-perfect rhyme — both languages have named and default arguments. The only visible difference is the separator: C# names with width:, Kotlin with width =. Because defaults exist, Kotlin has almost no method overloading in practice.

No static class, no this parameter — fun ReceiverType.name() declares an extension anywhere a function can live. Kotlin also has extension properties (val String.wordCount get() = …), which C# extension methods cannot express.

Braces are the lambda literal, and a single parameter needs no declaration at all — it is the implicit name. For anything beyond a short expression, naming the parameter (number ->) is better style.

Function types are structural syntax, not a delegate family: (Int) -> Int replaces Func<int, int>. Because Unit is a real type (void-as-a-value), the separate Action family is unnecessary — a returning-nothing function is just (String) -> Unit.

C# 12 primary constructor parameters are still just parameters — the properties are written separately. Kotlin’s val/var in the constructor header declares real properties in one stroke. Two more surprises: no new keyword, and no implicit Int→Double conversion — Rectangle(3, 4) would not compile.

Properties transfer almost verbatim — accessors nest under the declaration, and a custom accessor can name its backing field via the field identifier. What is missing is C#’s object-initializer syntax { Celsius = 25 }; Kotlin’s answer is apply { } (see Scope Functions).

C# methods are sealed-unless-virtual; Kotlin extends that stance to the class itself — nothing can be subclassed or overridden without an explicit open. The parentheses in : Animal() are the superclass constructor call, made visible in the supertype list.

data class is the record: generated value equality, toString, and destructuring. C#’s with { Age = 37 } expression becomes the generated copy(age = 37) method with named arguments — same non-destructive mutation, method call instead of syntax.

A deep instinct inverts: Kotlin’s == is always structural (it compiles to equals()), on every type, with no operator overloading required. Reference identity gets its own operator, ===. In C#, == on classes defaults to reference comparison unless someone overloaded it.

Kotlin has no static keyword. The companion object is a singleton attached to the class that holds the would-be statics — call sites still read Temperature.fromFahrenheit(…). Note where the private constructor lands: inline in the class header.

An object declaration is a language-level singleton — the hand-written Instance pattern compressed into one keyword, initialized lazily and thread-safely. private set under the property mirrors { get; private set; }.

Kotlin’s sealed means the compiler knows every subtype, so the when needs no else — and adding a third shape breaks this expression at compile time until it is handled. A C# switch over a hierarchy cannot prove exhaustiveness, hence the defensive _ arm. Note the smart cast: shape.radius, no binding variable.

C# type patterns introduce a second name for the narrowed value; Kotlin flows the narrowed type through the same variable. The compiler tracks it through &&, when branches, and null checks alike — with the caveat that only stable values (vals, not open properties) smart-cast.

The syntax is identical. The mechanism differs in name only: records generate Deconstruct, data classes generate component1()/component2() — which is also what powers destructuring in for ((key, value) in map) loops.

apply { } is Kotlin’s object initializer: the block runs with the new instance as this (so bare property names assign), and the expression returns the configured object. Unlike C#’s initializer syntax, it works on any expression, not just constructions.

The scope functions are a signature Kotlin idiom with no C# counterpart: let (transform it), run (transform this), apply (configure, return the object), also (side effect, return the object), with. They turn temporary-variable sequences into pipelines — used sparingly, they read beautifully; nested, they become soup.

by lazy makes the laziness invisible at every use site — the property’s type is plain String, no .Value unwrapping. It is one instance of property delegation, a general mechanism (Delegates.observable, map-backed properties, custom delegates) with no C# analog.

Logger by delegate generates every forwarding member automatically — composition over inheritance without hand-writing the pass-through methods C# requires. Override only the members you want to change; the rest keep forwarding.

A rare inversion where C# has the stronger runtime: .NET reifies generics natively, while the JVM erases them. Kotlin’s inline fun <reified T> recovers T only because inlining copies the body — with a concrete type — into every call site. Outside an inline function, T::class does not compile.

Kotlin borrowed C#’s exact keywords: out for covariance, in for contravariance, declared at the type definition. Kotlin extends the idea past interfaces and delegates to classes, and adds use-site projections (Array<out Number>) for types that declare no variance.

The model matches C# exactly: all exceptions are unchecked (Kotlin deliberately dropped Java’s checked exceptions), finally works the same, and the catch clause reads (name: Type). Message becomes the property message, and the JVM names differ (IllegalStateException ≈ InvalidOperationException).

TODO() throws NotImplementedError, but its return type is Nothing — the type of "never returns" — so it type-checks in any position, exactly like a throw expression in a C# switch arm. Also shown: a subject-less when is Kotlin’s if/else-if chain.

suspend replaces async, and — the striking part — calls need no await: a suspend call looks like a plain call, with suspension implicit. The return type stays honest too: String, not Task<string>. runBlocking bridges from the non-suspending world at the entry point.

async { } starts a Deferred (≈ Task<T>) — but inside a scope that owns it: if one child fails, the scope cancels its siblings, and runBlocking cannot exit leaving orphans behind. That structure is what C# approximates with Task.WhenAll discipline. await() is a method here, not a keyword.

launch is the fire-and-forget side (it returns a Job, no value) to async’s Deferred. Unlike Task.Run, launching does not imply a thread pool — coroutines are cheap enough to start thousands, and they stay on the current dispatcher unless one is specified.