C# quiz — 75 questions with answers and explanations

Answer: D

Prints 3 then 3.5. In 7 / 2 both operands are int, so C# does integer division and truncates the remainder → 3. In 7.0 / 2, 7.0 is a double, so the whole division is promoted to double → 3.5. The operand types decide the kind of division, not the type of the variable receiving the result.

Answer: A

Prints guest then dev. The null-coalescing operator ?? returns the right operand when the left is null, and returns the left operand itself when it isn't null. name is null so it yields "guest"; other is "dev" (not null) so it stays "dev". This is a concise way to supply a default instead of null.

Answer: C

It prints 0 then False. default(int) is 0 because the default for a numeric value type is zero. default(bool) is false, and when printed, Boolean.ToString() returns "False" with a capital F. Note: only reference types (and nullables like int?) default to null; value types always have a concrete "zero-bit" default.

Answer: D

struct is a value type: the variable holds the data directly, and assigning it or passing it to a method copies the whole value. class is a reference type: the variable holds only a reference to an object on the heap, so multiple variables can point to the same object and all see the same changes. This is what determines copy and comparison behavior.

Answer: C

In C#, string is immutable: every + creates a new string and copies the entire old content. Concatenating in a loop of n iterations therefore creates many intermediate objects, with complexity approaching O(n²). StringBuilder keeps a mutable buffer and Append writes directly into it, growing the buffer only when needed, so it is far faster and allocates much less for a large number of concatenations.

Answer: C

const is a compile-time constant: it must be assigned at declaration with a constant expression, is implicitly static, and its value is inlined directly at each use site at compile time. readonly is a runtime constant: it can be assigned only once — at declaration or in the constructor — so its value can be computed at runtime and differ per instance. Use const for truly immutable constants; readonly for values fixed-after-initialization.

Answer: C

A field is a member variable that stores data directly; a property is a pair of get/set accessors wrapping the read/write. A property allows validation, computed values, or changing the internal implementation without breaking calling code. .NET convention: expose state to the outside through properties (usually auto-properties { get; set; }), and keep fields private.

Answer: C

No. string in C# is immutable — its contents never change after creation. ToUpper(), Replace(), Trim()... all return a new string; to keep the result you must reassign: s = s.ToUpper(). Immutability makes strings safe to share between threads and enables interning. For repeated concatenation in a loop, use StringBuilder.

Answer: B

var declares a local variable with a type inferred by the compiler from the initializer expression, at compile time: with var count = 10; count is a fixed int, and assigning a string to it is a compile error. It is not a dynamic type (dynamic is the dynamic one) and has no runtime cost — the IL is identical to an explicit declaration. An initializer is required; var x; is not valid.

Answer: A

There is no behavioral difference: string is a C# keyword alias for the .NET type System.String — the compiler produces the same type and the same IL. Likewise: int = System.Int32, bool = System.Boolean, object = System.Object. The common convention (used by the .NET runtime codebase): write string for the data type, and use String only when calling static members while the file has using System; — and even then string.Format(...) is still valid.

Answer: C

It is an extension method (C# 3): a static method inside a static class, whose first parameter carries the this modifier indicating the type being "extended". The compiler allows instance-style call syntax but actually compiles it into a static call — the original type is not modified. To use it you must using the correct namespace containing the static class. LINQ (Where, Select...) is exactly a set of extension methods for IEnumerable<T>.

Answer: C

using guarantees that Dispose() is called when the scope exits, even if an exception is thrown — the compiler generates code equivalent to try/finally with Dispose() in the finally block. It works with any type implementing IDisposable, not just files. Note: Dispose releases resources (handles, connections) deterministically; the object's memory is still reclaimed later by the GC.

Answer: B

The size is mutable. An array has a fixed length from creation, whereas List<T> wraps an internal array and allocates a larger one (usually double) when full, then copies over. In exchange it costs one extra thin level of indirection on access.

Answer: B

It always runs when control leaves the try block — whether it completes normally, hits return, or throws. That guarantee makes it the right place to close files, release locks, and clean up resources.

Answer: C

The compiler parses it at compile time and emits string concatenation code, or a call to a formatting function, or an optimized StringBuilder. That makes it faster than passing a format string plus arguments, and a wrong argument count is caught immediately.

Answer: A

The class needs a constructor that can be called with no arguments, and the properties being assigned must have a setter (or init). The compiler translates this syntax into: create the object, then assign each property in turn.

Answer: D

It assigns only when the left-hand variable is null, otherwise keeps the existing value. It's shorthand for a null check followed by assignment, added in C# 8.

Answer: D

The second also treats a string containing only whitespace as empty, while the first doesn't because its length is still greater than zero. For user input, the second is almost always the right choice.

Answer: C

The compiler generates a class and an entry point method wrapping those statements. Since C# 9, a file in a project is allowed to contain top-level statements, and the compiler builds the rest of the scaffolding.

Answer: C

It is a key-value pair, accessed through two corresponding properties. To iterate only the keys or only the values, iterate the dictionary's key collection or value collection instead.

Answer: C

It prints -2147483648. By default C# compiles in an unchecked context, so int arithmetic on overflow wraps around in two's complement instead of throwing. int.MaxValue is 2147483647; adding 1 overflows and wraps to int.MinValue. To catch overflow, compile in a checked context so it throws OverflowException.

Answer: D

It prints False then True. double is binary floating point, so 0.1 + 0.2 gives 0.30000000000000004, not exactly 0.3, so the comparison is False. decimal is decimal floating point, so 0.1m + 0.2m equals 0.3m exactly, so it's True. Never compare floating-point values with ==; compare within a tolerance instead.

Answer: B

It prints False then -1. With nullable value types (int?), arithmetic operators are "lifted": if either operand is null, the result is null. So null + 5 is null, making sum.HasValue False. Then sum ?? -1 sees null and takes the right branch, giving -1. null in nullable arithmetic is NOT treated as 0.

Answer: A

When await is applied to an incomplete Task, the method doesn't block the thread; it returns control to the caller immediately, and the compiler turns the rest of the method into a continuation that runs when the Task completes. This frees up a thread (e.g. a UI or request thread) to do other work instead of waiting on I/O.

Answer: D

var is just static type inference: the compiler looks at the initializer expression and assigns a fixed concrete type, and type checking stays strict at compile time. dynamic defers type checking to runtime — every member access is resolved via the DLR/reflection at runtime, and a mistake throws RuntimeBinderException. var is syntactic convenience; dynamic actually relaxes type checking.

Answer: D

var is just static type inference: the compiler looks at the initializer expression and assigns a fixed concrete type, and type checking stays strict at compile time. dynamic defers type checking to runtime — every member access is resolved via the DLR/reflection at runtime, and a mistake throws RuntimeBinderException. var is syntactic convenience; dynamic actually relaxes type checking.

Answer: C

The fundamental difference: a class can inherit from only one abstract class (single inheritance) but can implement many interfaces. An abstract class can carry state — fields, constructors, implemented methods — modelling an "is-a" relationship and sharing base code. An interface describes a contract/capability ("can-do") and has no instance fields; since C# 8 it can have default methods but still cannot store state.

Answer: A, C, D

All three pass the parameter by reference (no copy), differing in data direction: ref — in and out, the variable must be assigned before the call; out — out only, the variable need not be assigned beforehand but the method must assign it before returning (the Try... pattern); in — in only, a readonly reference, the method may not reassign it — optimal for large structs where you want to avoid a copy.

Answer: A

It prints True then False. A record is a reference type but the compiler generates value equality: ==/Equals compare the runtime type plus all properties/fields, so two Point(1, 2) are equal. ReferenceEquals is still False because new twice creates two separate instances — there is no instance pooling mechanism. With a regular class, the same code would print False / False (reference comparison).

Answer: A

async void returns no Task, so the caller cannot await it, cannot know when it finishes, and cannot compose it (Task.WhenAll). Most dangerous: an exception in async void belongs to no Task to be observed — it is raised straight to the SynchronizationContext and can crash the process. async void exists only to match the event handler signature (void Button_Click(...)); everywhere else use async Task.

Answer: A

It probes the hash table only once. The form if (d.ContainsKey(k)) v = d[k] computes the hash and scans the bucket twice for the same key. TryGetValue combines the check and the value retrieval into one pass, and returns false instead of throwing when the key is absent.

Answer: C

IReadOnlyList<T>. It allows counting and index access but does not expose Add or Remove, so it expresses the intent accurately. Returning List<T> lets the caller modify internal data; returning IEnumerable<T> loses counting ability and risks repeated enumeration.

Answer: A

First returns the first matching element and throws if there is none. FirstOrDefault returns the default value instead of throwing. Single requires exactly one matching element — it throws both when there is none and when there is more than one, so it must keep enumerating to check.

Answer: B

LINQ queries are deferred-execution: the query itself is just a description, and each enumeration re-runs the whole operator chain. With IQueryable over a database, that's another round-trip query. Call the method to execute once and reuse the result.

Answer: D

A sequence of groups, each group carrying a key and enumerable itself like a sub-collection. So use two nested loops, or call the method that converts to a dictionary if you need repeated lookups by key.

Answer: D

Type T must override both Equals and GetHashCode together. A hash-based set uses the hash to find the bucket first, then compares with Equals inside that bucket. If two objects are equal but hash differently, they land in different buckets and are never compared.

Answer: C

It blocks inheritance: no class is allowed to derive from it. Use it when the class's behavior isn't designed to be extended, or to guarantee internal invariants aren't broken by subclasses. It also lets the compiler optimize method calls.

Answer: B

Exactly once, before the first instance is created or before any static member of the class is referenced. The runtime guarantees it runs exactly once and is thread-safe, with no extra locking needed.

Answer: D

It splits a class's definition across multiple files; the compiler combines them into a single type. Its main use is separating auto-generated code from hand-written code, so re-running the generator doesn't overwrite the parts you wrote.

Answer: C

It compares references. The operator is chosen at compile time based on the variable's declared type, and the base object type has no content-comparison overload. The result therefore depends on whether the two strings are the same instance.

Answer: B

The values of all its properties. The compiler generates Equals, GetHashCode, and comparison operators based on all properties, so two records with the same content are equal — unlike a normal class, which compares references.

Answer: D

A Task is a unit of work carrying a commitment to a future result; a thread is a real execution stream managed by the OS. Tasks are scheduled onto a thread pool, and for I/O-bound work they don't even occupy a thread while waiting.

Answer: D

If the tasks were already started, they run concurrently and total time is roughly that of the slowest task rather than all three added up. Results are returned in argument order, not completion order.

Answer: A

To reduce allocations when the result is usually already available. It's a value type, so the synchronous path — for example data already in cache — allocates no object on the heap. In return it may be awaited only once and has more restrictions.

Answer: B

throw; rethrows the exception currently being caught and preserves the original stack trace. throw ex; counts as a new throw from the current line, losing all information about where the error actually originated — so diagnostics only see the catch block, not the cause.

Answer: B

Classes holding resources the garbage collector doesn't know how to release: file handles, database connections, sockets, unmanaged memory, or another object that itself needs disposal. A class holding only managed data doesn't need it.

Answer: B

When the type is small (guidance usually cites under 16 bytes), immutable, and represents a single value like a coordinate, a money amount, or a time range. Large or mutable types should be a class, because the copy cost on every pass will outweigh the benefit of avoiding allocation.

Answer: D

It is an expression that returns a value, so it can be assigned directly to a variable and no assignment statement is needed in each branch. More importantly, the compiler warns if any case is still uncovered — a missing branch is caught at compile time.

Answer: A

It is a wrapper type — a struct holding the value plus a flag indicating whether there is a value. Value types inherently cannot be null, so the language uses this wrapper to represent the missing-value state. It is still a value type, not moved to the heap.

Answer: D

In the constructor and in an object initializer, i.e. only during the object creation phase. After that the property becomes read-only. It fills the gap between a fully read-only property and a freely assignable one.

Answer: C

Returning multiple values from a method, especially an internal or private method. It avoids having to create a dedicated type for data used in only one place. For a public API you should use a record, because tuple field names do not exist at runtime.

Answer: A

d. The conditional access operator short-circuits the expression chain as soon as it hits a null operand and returns null for the whole chain, then the null-coalescing operator replaces null with the fallback value. No exception is thrown.

Answer: B

It usually does not need to allocate a delegate object, can be called at a position before its declaration line, supports natural recursion, and can use the keyword marking it async or iterator. A lambda assigned to a variable always creates a delegate.

Answer: C

One instance per scope, and in a web app each HTTP request is a scope. Every component handling the same request gets the same instance; a different request gets a different instance. When the request ends, the instance is disposed.

Answer: C

[Fact] is a parameterless test that runs exactly once. [Theory] takes parameters and runs once per supplied data set, with each set showing up as a separate case in the report — so you know exactly which set failed.

Answer: C

Because the test can replace the real dependency with a fake implementation. That means no database or network is needed, tests run fast and give deterministic results, and you can set up hard-to-reproduce situations like connection failures or slow responses.

Answer: B

It combines the type check and the variable assignment into one expression, and the variable is scoped only to the branch that was checked. The old way needs two lines and leaves a possibly-null variable in a wider scope, easy to misuse in the wrong branch.

Answer: A

It releases the thread while waiting: the thread returns to the pool to serve other work, and when the delay ends the rest of the method is scheduled to continue. The other way holds the thread for the whole wait doing nothing.

Answer: B

It automatically includes every source file in the directory in the project, so the project file is dozens of times shorter. Adding or renaming files no longer produces changes in the project file — this removes a familiar source of merge conflicts entirely.

Answer: C

A string containing the name of the variable, property, or method passed in, and the compiler substitutes it at compile time so it costs nothing at runtime. The variable's value is never evaluated.

Answer: D

So the error points straight at the wrong call site. Without the check, the null value travels deeper before causing a reference error, and the stack trace points to a line far from the cause. Checking early gives an exception that names the parameter right at the entry point.

Answer: C

Placed before, the condition is translated into a WHERE clause and the database only returns matching rows. Placed after, the entire table is loaded into the application and filtered in memory — same result, but vastly different cost.

Answer: A

Use an existence check, because it stops at the first element that matches. Counting has to walk the entire collection, and the difference becomes very large for slow or infinite sources.

Answer: D

When the projection function returns a collection, the first operator yields a sequence of collections, while the second flattens them into one sequence. For example, getting all the lines of every order requires the second operator.

Answer: B

It produces elements one at a time as they are requested instead of building the whole list upfront. This handles sources larger than memory, and if the caller stops halfway, the remainder is never computed.

Answer: A

It is wrapping a value type in an object on the heap when it is assigned to a reference type. Each boxing is an allocation, so in a large loop it creates significant GC pressure.

Answer: A

Use the decimal type, because it represents decimal values exactly. Binary floating-point types cannot represent many simple values correctly, so errors accumulate over thousands of additions.

Answer: C

It carries the offset from UTC, so a value always identifies a single unambiguous moment in time. The other type only has a flag telling whether it is local or UTC, and that flag is easily lost as data passes through layers.

Answer: A

Because the decimal separator convention depends on the culture of the running thread. Some regions use a comma as the decimal separator, others use it as a thousands separator — so the same string gives two different results.

Answer: A

Socket exhaustion: a closed connection still holds its port in the TIME_WAIT state for a while, so creating one continuously under heavy load exhausts the available ports and calls start failing.

Answer: D

Outside code can also lock on that same object, because it is public. This creates lock contention the class itself does not control. The correct approach is a private object dedicated solely to locking.

Answer: C

Composing two separate operations — checking existence and then adding. Each operation is safe, but there is a gap between them, so you must use the built-in combined methods like add-if-not-exists or add-and-update.

Answer: C

By default every entity fetched is written into the change tracker, costing both memory and time. For a display-only query that is wasteful, and dropping it makes a many-row query noticeably faster.

Answer: A

Each access to a navigation property fires a separate query because that data was not loaded along with it. For a list of one hundred orders that is one hundred and one queries. The fix is to eager-load the related data in the first query.

Answer: D

Declaration order is execution order, and getting it wrong causes hard-to-spot bugs. For example, putting authorization before authentication means the user info is not ready when permissions are checked, so every request is treated as not logged in.