C#.CodeCompared.To/Go

Go's fmt.Println adds a newline, just like Console.WriteLine. The fmt package is automatically imported by the runner; in a real program you write import "fmt".

Go uses C-style fmt.Printf with format verbs: %s for strings, %d for integers, %f for floats, %v for any value in its default format, %T for the type. There is no string interpolation syntax.

fmt.Sprintf returns a formatted string without printing it — the equivalent of C#'s string.Format or an interpolated string assigned to a variable.

fmt.Println formats slices as [1 2 3] with space-separated elements. Use %v in Printf for the same default format, %+v to include struct field names, or %#v for Go-syntax representation.

The := short variable declaration infers the type from the right-hand side. It can only be used inside functions. For package-level variables, use var name = value or var name Type = value.

Go types come after variable names. Zero values are automatic: int → 0, string → "", bool → false, pointers/slices/maps → nil. Declaring var counter int alone is valid and yields 0.

Go constants can be untyped — const Pi = 3.14159 has enough precision to be used as any numeric type. The iota enumerator generates incrementing integer constants inside a const block, replacing C#'s enum for simple integer sets.

Multiple return values are a first-class language feature in Go — not a tuple struct. The idiomatic pattern is to return (result, error), and callers check err != nil before using the result. Use _ to discard a return value you don't need.

Every Go type has a zero value: int → 0, bool → false, string → "", structs → all fields zeroed. Pointers, slices, maps, channels, and function values have zero value nil. There is no uninitialized memory.

len(s) returns the byte count, not the Unicode character (rune) count. greeting[0] returns a byte (uint8), not a char. For Unicode-aware iteration use for _, rune := range greeting or utf8.RuneCountInString(greeting).

The + operator concatenates strings in Go just like in C#. For building strings from many pieces, use strings.Builder — the equivalent of C#'s StringBuilder — to avoid allocating a new string on every concatenation.

String methods in C# are on the object itself; in Go they are standalone functions in the strings package. All functions return new strings — Go strings are immutable, just like C# strings.

Go backtick raw string literals correspond to C#'s @"..." verbatim strings and """...""" raw string literals. Backtick strings can span multiple lines and treat backslashes literally.

strconv.Atoi returns (int, error) — the Go equivalent of int.TryParse. strconv.Itoa converts int to string. fmt.Sprintf("%d", n) also works for formatting numbers as strings.

Integer arithmetic works identically. Go has explicit integer types: int (platform-sized, 64-bit on modern systems), int8, int16, int32, int64, and unsigned variants uint, uint8, uint32, uint64. There is no implicit conversion between numeric types.

Go's default floating-point type is float64 (equivalent to C#'s double). float32 is available but rarely needed. Use fmt.Printf("%.2f", v) for fixed-precision formatting instead of Math.Round.

Go's math package functions take and return float64 only — there is no overloaded math.Abs(int). To find the absolute value of an integer, use a conditional. The lack of function overloading is intentional: Go favors explicit naming.

Go requires explicit conversion between all numeric types — there are no implicit widening conversions as in C#. int(3.7) truncates toward zero, matching C#'s cast (int)3.7. All conversions use function-call syntax: float64(n), int32(n).

Go slices are the primary sequence type — dynamically sized, backed by an array. They correspond to C#'s List<T> for most purposes. A fixed-size Go array is declared [5]int{1,2,3,4,5} but is rarely used; slices are idiomatic.

append returns a new slice (possibly with a new backing array) — you must reassign the result. Unlike C#'s list.Add(), append never mutates in place. You can append multiple elements at once, or spread another slice: append(slice1, slice2...).

Go slice expressions numbers[1:4] give elements at indices 1, 2, 3 (exclusive end), matching C#'s [1..4] range. The sub-slice shares the same backing array — modifying it modifies the original. Use copy() to make an independent copy.

Go's for _, value := range slice corresponds to C#'s foreach. The range clause yields (index, value); use _ to discard whichever you don't need. To iterate with the index: for i, fruit := range fruits.

make([]T, length, capacity) creates a slice with a given length and optional capacity. make([]int, 10) creates a slice of 10 zeros. Go slices expose both len() (current elements) and cap() (backing array size) — C#'s List<T>.Capacity is analogous.

Go maps are unordered key-value stores equivalent to C#'s Dictionary<K,V>. The type syntax is map[KeyType]ValueType. Maps must be initialized before use — a nil map (var m map[string]int) panics on write.

Map lookup returns (value, ok). If the key is absent, value is the zero value for its type and ok is false — there is no KeyNotFoundException. Check ok to distinguish a missing key from a key with a zero value.

Use make(map[K]V) for an empty map (preferred over map[K]V{} to signal "no initial entries"). Assignment adds or updates. delete(map, key) removes a key — no error is returned if the key is absent.

Map iteration order in Go is deliberately randomized on every run. If order matters, collect the keys into a slice, sort it with sort.Strings(keys), then iterate the sorted keys. This differs from C#'s SortedDictionary, which maintains insertion/sorted order.

Go omits parentheses around conditions, but braces are mandatory even for single-line bodies. There is no ternary operator — use a full if/else.

Go's if init; condition form is idiomatic for operations that return (value, error). The variable declared in the initialization statement is scoped to the entire if/else if/else block — not visible outside.

Go's switch does not fall through by default — no break needed. Cases can list multiple values separated by commas. A switch with no expression is equivalent to if/else if. Use fallthrough to explicitly continue to the next case.

defer schedules a function call to run when the surrounding function returns — after both normal returns and panics. Multiple defers execute in LIFO order. The idiomatic use is defer file.Close() immediately after opening, so the close cannot be forgotten.

Go has one loop keyword: for. The three-clause form mirrors C#'s for loop exactly, minus the parentheses and with mandatory braces.

Go has no while keyword. The single-condition for condition form is Go's while loop. A bare for { } (no condition) is an infinite loop — equivalent to C#'s while (true).

range over a slice yields (index, value) on each iteration. Use _ to ignore the index. range also works on strings (iterating runes), maps (key/value), and channels (values until closed).

break and continue work as in C#. Go also supports labeled breaks to exit nested loops: outer: for { for { break outer } } — useful when breaking from an inner loop needs to exit the outer loop as well.

In Go, the return type follows the parameter list. When consecutive parameters share a type, they can be grouped: func add(first, second int). Functions whose names start with a lowercase letter are package-private (unexported); uppercase names are exported.

Go returns errors as values — there are no exceptions. The convention is (result, error) as the last two return values. Callers check err != nil immediately. Ignoring an error is a deliberate choice that is visible in the code.

Go's ...T variadic parameter corresponds to C#'s params T[]. To pass an existing slice, use the spread syntax slice.... The variadic parameter is received as a slice of type []T inside the function.

Functions are first-class values in Go — they can be assigned to variables, passed as arguments, and returned from other functions. The function type is written func(int) int, matching C#'s Func<int, int>.

Named return values declare variables that the function's bare return statement returns. They are mostly used with defer to modify return values on error — for example, closing a resource and setting an error at the same time.

Go closures capture variables by reference, not by value — the same behavior as C# lambda expressions. A closure sees the current value of a captured variable, not the value at the time the closure was created.

Each call to makeCounter() creates an independent count variable. The returned closure keeps the variable alive — Go's garbage collector holds it as long as the closure is reachable. This is Go's idiomatic way to produce factory functions.

Go accepts function values as parameters using concrete function types like func(int) bool. The standard library's slices package (added in Go 1.21) provides slices.Collect, slices.All, and helper iterators that resemble LINQ.

Go has no exceptions. Functions that can fail return an error as their last return value. Check err != nil immediately after every call that can fail. Forgetting to check is a silent bug — it compiles, but the program continues with a zero value.

errors.New creates a simple error string. fmt.Errorf formats a message and optionally wraps another error with %w. There is no exception class hierarchy — any value implementing Error() string satisfies the error interface.

fmt.Errorf with %w wraps an error, preserving the original for inspection. errors.Is(err, target) traverses the whole chain — analogous to checking C#'s InnerException chain. Sentinel errors (var ErrX = errors.New(...)) are the idiomatic way to make error conditions testable.

panic is the Go equivalent of an uncaught exception — it unwinds the stack. recover() in a deferred function catches it, like a top-level catch. Go convention: never use panic for normal error paths. Panics are for programming errors (nil pointer dereference, index out of bounds) or truly unrecoverable situations.

Go structs are value types — assignment copies all fields. Exported fields start with uppercase. Field names in struct literals are required for clarity. Go has no inheritance, no abstract, no virtual. Composition via embedding is Go's alternative.

Methods have a receiver parameter instead of living inside a class body. The receiver name is conventionally the first letter of the type — not this. Implementing String() string is Go's equivalent of ToString(); fmt.Println calls it automatically.

Go interfaces are satisfied implicitly — Circle implements Shape simply by having an Area() float64 method. No implements keyword. This lets you define an interface for a type from another package without modifying it — a pattern called "duck typing with compile-time safety."

Go uses embedding for code reuse — Dog embeds Animal, promoting all its fields and methods. dog.Name works directly. There is no base, no virtual, no override. Overriding means defining a method with the same name on the outer type.

Go structs are value types — methods with value receivers receive a copy. Use a pointer receiver (*T) when the method must modify the struct, or when the struct is large (to avoid copying). Be consistent: if any method on a type uses a pointer receiver, all methods should.

go f() launches f as a goroutine — a lightweight coroutine managed by the Go runtime. Goroutines start at ~2KB (vs ~1MB for OS threads) and are multiplexed across OS threads automatically. sync.WaitGroup waits for goroutines to finish, replacing Task.WhenAll.

Channels are typed conduits between goroutines. A buffered channel (make(chan int, 3)) accepts values without blocking until full. Closing a channel signals "no more values"; range over a channel drains it until closed — the idiomatic producer/consumer pattern.

select waits on multiple channel operations and runs the first one that is ready. If multiple are ready simultaneously, one is chosen at random. A default case makes it non-blocking. This is Go's equivalent of Task.WhenAny.

The worker pool distributes tasks over goroutines via an input channel and collects results via an output channel. Go's motto for concurrency is "do not communicate by sharing memory; instead, share memory by communicating" — channels make that concrete.

:= declares and assigns; = assigns to an already-declared variable. Inside a block, := can redeclare a variable if at least one name on the left is new to that scope — this is a common source of subtle shadowing bugs when a new err is created instead of reusing an outer one.

A nil slice is safe: append, len, and range all work on it. The distinction matters mainly for JSON encoding (nil → null, empty → []). Most Go code treats nil and empty slices identically and does not check which it has.

Go has no function or method overloading. Use distinct names (displayInt, displayString) or accept any (the empty interface, formerly interface{}) and type-switch inside the function. This is a deliberate simplicity trade-off: every call site unambiguously names what it calls.

Go added generics in 1.18 with type parameters. The constraint any means "any type" (comparable means equality-testable). Go generics are less powerful than C#'s — no operator overloading on type parameters, no where T : new(). The slices and maps packages (Go 1.21) cover most common generic operations.