C.CodeCompared.To/C#

Console.WriteLine appends the newline and knows how to render whatever you hand it; printf takes a format string and believes it. The exit status still exists — falling off the end of the statements means zero, and return 3; at the top level sets three — but nothing forces you to write it. C# also has Console.Write for the no-newline case, which is the closer match to printf.

The precision did not disappear, it moved: what was %.2f is now the :F2 format specifier after the expression. The bigger change is that a mismatch is now a compile error rather than a garbage read — printf("%s", 42) compiles under most settings and prints whatever lives at address 42, while there is no way to spell that mistake in an interpolated string.

Console.Out and Console.Error are TextWriter objects, so anything that accepts a TextWriter can be pointed at either one — or at a file, or at an in-memory buffer — which is the piece C makes you build by hand out of FILE * plumbing.

The two columns print different numbers for long on a 64-bit Unix build and identical ones on Windows — which is the whole point. In C#, long is System.Int64 by definition, and the names Int32, UInt64 and friends are the real type names that int and ulong are keywords for. The one width that is not fixed is nint/nuint, which exist precisely to match a C intptr_t.

Unchecked is the default for ordinary arithmetic, so C# behaves like C compiled with -fwrapv — but it is specified to, which means no optimizer is allowed to reason from the assumption that it did not happen. The C column has to launder the addition through unsigned, where wrapping is defined, to have anything safe to print at all.

A C# char holds one UTF-16 code unit, so a character outside the Basic Multilingual Plane takes two of them and string.Length counts code units, not letters. The mental model that survives the move is: C# byte ≈ C unsigned char, C# char ≈ C char16_t, and any time you want real bytes out of text you go through Encoding.

C# also drops the null-pointer-as-false idiom: if (reference) is a type error and you write if (reference is not null). Losing the shorthand costs a few characters per condition and removes an entire family of bugs, because the compiler now knows the difference between "this integer happens to be nonzero" and "this is a truth value."

A Nullable<int> is a struct holding an int and a bool, so it costs a few extra bytes rather than a heap allocation. The ?? operator supplies a fallback, which is how you get back to the sentinel deliberately at the one place that wants one. Note that the C column’s function silently misbehaves if anyone ever wants to store a negative index; the C# one cannot.

Three C failure modes vanish with the free: the leak, the double free, and the use-after-free. What you give up is the timing — you no longer know when the memory comes back, and you cannot ask for it back sooner. Notice too that the C column has to check malloc for NULL; new throws OutOfMemoryException instead of returning nothing, so there is no branch to forget.

Dropping first is not a deallocation, it is one fewer way to reach the object. This is the single largest change in how you design data structures: shared ownership needs no protocol, no reference counts and no "who frees this" comment, because reachability is the ownership rule.

The rule of thumb that transfers cleanly: memory is automatic, handles are not. A using block is the C# spelling of the goto cleanup ladder, and it is exception-safe in a way the ladder never is. The shorter using var writer = new StreamWriter(path); form disposes at the end of the enclosing scope instead, which reads more like an ordinary declaration.

The consequence you feel first is copying. Assigning a struct copies every field, exactly like assigning a C struct; assigning a class reference copies a machine word and leaves one object. The two type declarations at the bottom of the C# column differ by a single keyword and produce completely different runtime behavior — which is why "is it a struct or a class?" is the first question to ask about any C# type.

Change class Counter to struct Counter and the same program prints 1, because the assignment then copies the whole value. That is the entire difference, and it is invisible at the use site — which is why C# style leans on record and immutability to make aliasing stop mattering rather than to make it visible.

The compiler enforces what C only documents: a ref argument must be initialized before the call, an out argument must be assigned before the callee returns, and neither can be null the way a pointer can. The out int quotient inside the if is a declaration — the variable comes into scope right there, which is why the TryParse family reads as well as it does.

The ? on string? is the declaration that this one may be missing; without it the compiler warns at every place you might assign null. text?.Length is the short-circuit — it yields null rather than dereferencing — and ?? supplies the fallback, so the two together are the C null check compressed into punctuation. The trailing ! on null! is how you overrule the compiler when you know better, and it is the one place the safety is yours to lose.

An array does not decay in C#: pass it anywhere and it is still an array, still knows its length, and still bounds-checks. The length lives in the object header next to the type, so Length is a field read rather than a computation. Once you have this, the entire class of "caller and callee disagree about the count" bugs is unreachable.

The check costs a compare and a branch per subscript, and the just-in-time compiler removes most of them — a for loop bounded by Length is proved safe and emits no check at all. The ^1 and 1.. syntax comes with the bounds-checking: the runtime knows the length, so "from the end" and "a slice" can be language features rather than pointer arithmetic you write yourself.

Note the subscript syntax differs: grid[row, column] for the rectangular one, rows[row][column] for the jagged. The rectangular form is the closer match to C’s contiguous layout and is what you want for numeric work; the jagged form is an array of array objects and is the one that permits ragged rows. C loses the row length of a jagged structure entirely, which is why the C column can only print elements it already knows exist.

The zeroing is not free — a large new byte[1_000_000] pays for it — but it removes the whole "did I initialize that?" category, and the compiler’s definite-assignment analysis catches the local case with no runtime cost at all. When you genuinely want the malloc behavior for a hot buffer, GC.AllocateUninitializedArray is the deliberate opt-out.

strlen is O(n) and the C column calls it once per loop iteration, which is the classic accidental O(n²). Length is a field read. The other thing to notice is ToUpperInvariant: uppercasing is a locale-sensitive operation on real text, and the C column’s arithmetic works only for unaccented ASCII — which is most of why C string handling looks simple.

Immutability is what makes it safe to hand a string to another thread, use it as a dictionary key, and let two variables share one object without copying — the aliasing that would be a hazard for a char * is harmless when nothing can write through it. The cost is that naive concatenation in a loop allocates a new string each round, which is exactly the strcat-in-a-loop performance trap in a different costume.

The practical upshot at an interop boundary is that a C# string can hold something a C function will silently truncate. When you marshal one out to native code you are converting to a NUL-terminated representation, and if the string contains an embedded zero the native side sees a shorter string than you sent — which is worth remembering before you pass user input through [DllImport].

The C column’s first line prints 0 and is the bug every C programmer has written once. The C# column builds its first string at run time precisely so the two are different objects — a plain "hello" literal would be interned and share one object, making ReferenceEquals accidentally true. CompareOrdinal is the byte-order comparison strcmp does; plain string.Compare is culture-aware and will not agree with it.

The trade is allocation for safety: Split hands back an array of new strings, where strtok reuses the buffer you gave it. When the allocation matters, C# has the same idea without it — text.AsSpan().Split(...) and MemoryExtensions.IndexOf work over a view into the original characters, which is the closest thing to what strtok was trying to be.

Nothing conceptual changed — shape.Area() passes shape as the hidden first argument exactly as rectangle_area(&shape) does. What you gain is that the name lookup is scoped to the type, so there is no rectangle_ prefix to invent, and the compiler will not let you call circle_area on a rectangle.

The two Bump methods are byte-identical bodies and the two types differ by one keyword, so the different results come from nothing but value-versus-reference semantics. The rule that transfers from C: use a struct when the thing is a value (a point, a length, a colour), keep it small and preferably immutable, and reach for a class when identity matters. A large mutable struct combines C’s copying costs with C#’s invisible syntax and is the worst of both.

The call site unit.Celsius = 500 is a method call wearing assignment syntax, and value is the implicit parameter holding the right-hand side. Fahrenheit has only a getter and stores nothing at all — a computed field, which C can only express as a function call. The habit to build: declare properties from the start (public int Celsius { get; set; } generates the trivial pair), because turning a public field into a property later changes the binary interface even though the source looks the same.

Declaring any constructor removes the implicit parameterless one, so new Connection() stops compiling and there is no way to reach the half-built state the C column demonstrates. { get; } with no setter means the property can only be assigned in the constructor, which is C#’s const-after-construction — a shape C can only approximate by hiding the struct definition in a .c file.

The generated code is the same idea — an object header pointing at a method table — but the compiler builds and populates the table, and the void * casts that make the C version type-unsafe are gone. That also makes the C# column able to put both shapes in one array and loop over them, which the C version cannot do without a tagged union or a common header struct.

One line of declaration produced the constructor, two read-only properties, Equals, GetHashCode, ==, ToString, and the with expression that copies-and-changes. The struct keyword keeps it a value type; plain record Point(int X, int Y) would be a reference type with the same value semantics for comparison — which is the combination C has no way to express.

The growth strategy is the same doubling, and Capacity exposes it — you can pre-size with new List<int>(1000) exactly as you would pick a first malloc size. What is gone is the realloc hazard: there is no old pointer for anyone to have kept, because callers hold a reference to the list object rather than to its backing array.

The C column is fifty lines that still cannot grow, cannot delete, and leaks the distinction between "absent" and "stored -1". TryGetValue is the C# idiom that avoids that last problem for good: it returns a bool and writes the value through an out parameter, so a missing key is never confused with a stored one. Indexing a dictionary with a key it does not hold throws rather than inserting, which is the opposite of what several scripting languages do.

yield return is the part with no C equivalent short of writing a state machine by hand: the method suspends at each yield and resumes where it left off when the loop asks for the next value, so Squares(1000000) allocates nothing and computes only what is consumed. Modifying a collection while a foreach walks it throws InvalidOperationException — a diagnosed version of the invalidated-iterator bug.

Every one of those operators returns a lazy sequence, so nothing is computed until Count() or Sum() asks — which is also the trap, because the chain above is walked twice, once per aggregate. Add .ToArray() when you intend to consume a result more than once. The loop is not gone, it moved: the cost model is roughly one delegate call per element per operator, which is a real price you would not pay in the C column.

C# offers both styles on purpose: Parse throws because a malformed number is usually a bug, while TryParse returns a bool because parsing user input is not. The rule of thumb the base library follows — throw for the unexpected, return a status for the routine — is worth adopting, because exceptions are expensive to throw (they capture a stack trace) and cheap only when they do not happen.

The C ladder handles failures this function detected. It cannot handle a failure three frames down that longjmps past it, which is why C code that uses setjmp tends not to use the ladder. finally runs during unwinding regardless of where the throw came from, and using is sugar for a try/finally that calls Dispose — so most real C# cleanup is written as using rather than as an explicit finally.

The floating-point halves agree, because both languages defer to IEEE 754 — 1.0 / 0.0 is positive infinity in each, and 0.0 / 0.0 is NaN in each. Only the integer case differs, and it differs in the direction of being specified: a C# program that divides by zero fails the same way on every platform, with a stack trace naming the line.

The catch clause dispatches on type, so adding a third failure mode does not renumber anything and does not require every caller to learn a new constant. Two rules worth carrying over from the base library: derive from Exception (not from SystemException), and catch the narrowest type you can actually handle — a bare catch { } swallows the out-of-memory and stack-overflow cases along with your parse error.

A using directive imports names into scope; it does not read a file, cannot be conditional on anything, and costs nothing at run time. Because there is no textual inclusion there are no include guards, no header/source split, no forward declarations, and no order dependence — a type can be used above the line that declares it, which is why the helper types on this page sit at the bottom of every example.

The columns print different numbers on purpose: the C macro increments counter twice and multiplies two different values, while the C# method takes one argument, evaluated once, before the call. The performance argument for macros is gone too — a small method like this is inlined by the just-in-time compiler, and [MethodImpl(MethodImplOptions.AggressiveInlining)] is there for when you want to insist.

With [Conditional], the compiler removes the call sites when the symbol is not defined — including the evaluation of the arguments, which is how Debug.Assert costs nothing in a release build. The call to Never above compiles to no instructions at all. That is the same effect the C macro achieves, but the method is still a real method with real type checking, and it can be defined in one assembly and called from another. NET is defined by the .NET SDK for every modern target, alongside DEBUG or RELEASE for the configuration.

C11’s _Generic is the closest C gets — #define ABS(x) _Generic((x), int: abs, double: fabs)(x) dispatches on the expression’s type at compile time — but it is a macro, it cannot be extended by a caller, and the resulting error messages name the macro rather than your call. C# overload resolution happens at compile time on the static types too, so it is the same kind of decision, but it works on user types, follows inheritance, and needs no macro. The rule that occasionally surprises: the choice is made from the declared type of the argument, not the runtime type, so passing an object that happens to hold a string picks the object overload.

A named argument also documents the call site — Copy(source, target, overwrite: true) reads better than Copy(source, target, 1) — and it lets you skip past a default without repeating it. The catch worth knowing: the default value is compiled into the caller, so changing a default in a library does not affect already-compiled callers until they are rebuilt.

The lambda captures total by reference, so the void * plumbing disappears — the compiler builds a hidden class to hold the captured variable and the delegate points at a method on it. Action<T> is the built-in name for "takes a T, returns nothing" and Func<T, TResult> for "takes a T, returns a TResult", so most code never declares a delegate type at all. The cost is one small allocation per closure, which is why hot loops sometimes still pass state explicitly.

The array knows its own length, so the leading count is gone, and every element is type-checked at the call site — SumOf(1, "two") does not compile, where sum_of(2, 1, "two") does and then reads a pointer as an int. The one thing to watch is allocation: each call with loose arguments builds an array, which is why string.Format has hand-written overloads for one, two and three arguments before it falls back to params.

The runtime specializes a generic over each value type, so Stack<int> stores raw ints in an int[] — no boxing, no indirection, and the same memory layout you would have written by hand. That is the part that distinguishes it from Java’s erased generics: the type argument survives to run time, so typeof(T) works and there is no hidden pointer per element.

The constraint is also what makes the body legal: without where T : IComparable<T> the compiler would reject left.CompareTo, because it cannot know the type has it. Modern C# adds where T : INumber<T>, which lets a generic method use + and < directly — the last case where a macro was genuinely more capable than a generic.

A span does not copy — the write through writable lands in the original array, exactly as a write through numbers + 0 would. What the runtime adds is the length: slicing past the end throws instead of quietly reading a neighbour, and the compiler will not let a span outlive the stack frame it was created in, which is the lifetime rule C leaves entirely to you. A method taking ReadOnlySpan<char> can be called with a string, an array, or a stackalloc buffer with no conversion at all.

This is how the base library formats numbers without allocating: TryFormat writes into a caller-supplied span, which is the snprintf contract with the buffer size carried by the buffer. The same warning applies as in C — the buffer lives on the frame, so a large stackalloc in a loop overflows the stack, and the usual rule is a few hundred bytes at most with a heap fallback above that.

The extra word is fixed, and it is the piece with no C counterpart: the collector is allowed to move a live object during a collection, so taking its address is meaningless unless you pin it first. Pinning for long stretches fragments the heap, which is why the modern advice is to reach for Span<T> instead — it gets you the same pointer-and-length shape with no pinning, no unsafe, and bounds checks the compiler mostly optimizes away.

Both columns print the same bit pattern on a little-endian machine, because both are reinterpreting the same IEEE 754 double. BitConverter uses the platform’s byte order, exactly as the memcpy does, so a wire format still needs an explicit BinaryPrimitives.WriteInt64BigEndian or the equivalent byte-swapping you would write in C. C# also has [StructLayout(LayoutKind.Explicit)] with [FieldOffset], which is a genuine union.

The two columns print the same offsets, including the same padding — which is the point: without the attribute the runtime may pack the two byte fields together and the layout would silently stop matching. Pack = 1 in the attribute is the equivalent of #pragma pack(1), and LayoutKind.Explicit with [FieldOffset(n)] gives you a union.

Every rule you know applies again inside this block: the memory is not zeroed, the collector will not reclaim it, and forgetting the FreeHGlobal is a genuine leak. That is why it sits inside a try/finally — the exception safety the rest of C# gives you for free has to be written out by hand here. NativeMemory.Alloc and NativeMemory.AlignedAlloc are the newer, span-friendly spellings of the same thing.

Three things must agree and only one of them is checked at compile time: the library name, the symbol name, and the exact signature — a mismatched parameter width corrupts the stack rather than raising an error, and a missing library surfaces as DllNotFoundException at the first call. nuint is the type that exists for this: it is size_t, 64 bits on a 64-bit platform and 32 on a 32-bit one. The [MarshalAs] attribute is what turns the UTF-16 string into the NUL-terminated UTF-8 bytes the C side expects, and it allocates and frees a native copy around the call.

The two columns print the same four bytes, and the C# column prints a character count of four against a byte count of five — the é is one UTF-16 code unit and two UTF-8 bytes. That gap is the whole interop hazard in miniature: a length that means characters on one side and bytes on the other. When the native side wants UTF-16, Encoding.Unicode and UnmanagedType.LPWStr are the matching pair.