Interview Questions

Value types (int, struct, record struct) hold their data directly and are copied on assignment. Reference types (class, string, arrays) hold a reference to an object on the heap; assignment copies the reference.

const is a compile-time constant, implicitly static, and must be a primitive or string. readonly is set at runtime — in the declaration or constructor — and can hold any type.

A C# 8+ feature where reference types are non-nullable by default and string? marks values that may be null. The compiler warns when you might dereference null.

Strings are immutable: every concatenation creates a new string. StringBuilder modifies an internal buffer, which is much faster when building strings in loops.

C# is the language. .NET is the platform: runtime, base class libraries, SDK and tooling. The CLR (Common Language Runtime) loads the compiled IL, JIT-compiles it to machine code and manages memory with the garbage collector.

Since C# 9 the entry point can be plain statements in Program.cs without a Main method or class. The compiler generates Main for you. Only one file per project can use them.

Implicit typing: the compiler infers the static type from the right-hand side, and it cannot change later. It is not dynamic. Use it when the type is obvious from the expression.

For strings both compare content. For classes, == compares references unless the operator is overloaded, while Equals can be overridden for value equality. Records generate value equality for both.

for suits index-based loops, foreach iterates any IEnumerable without an index and cannot modify the collection, while repeats until a condition becomes false, and do…while runs at least once.

ref passes a variable by reference and it must be initialised first. out must be assigned by the method — used by TryParse. in passes by reference read-only, mainly to avoid copying large structs.

1if (int.TryParse("42", out var number))
2    Console.WriteLine(number + 1); // 43

An array has a fixed length. List<T> grows dynamically and is the default collection. Dictionary gives fast lookup by key. HashSet<T> stores unique values with fast Contains.

Most LINQ operators build a query that runs only when it is enumerated. Enumerating it twice runs it twice, which with EF Core means two database queries.

A delegate is a type-safe reference to a method (Func<>, Action<>). An event is a restricted delegate that outside code can only subscribe to or unsubscribe from — only the owning class can raise it.

Types designed for immutable data with value-based equality, concise positional syntax, built-in ToString and non-destructive mutation with the with expression.

1public record Point(int X, int Y);
2var a = new Point(1, 2);
3var b = a with { Y = 5 };
4Console.WriteLine(a == new Point(1, 2)); // True

IEnumerable executes LINQ in memory. IQueryable builds an expression tree that a provider such as EF Core translates into SQL, so filtering happens in the database.

try contains risky code, catch handles specific exception types (most specific first), and finally always runs for cleanup. Use throw; to rethrow and preserve the stack trace, and using for IDisposable resources.

Generics (List<T>, Repository<T>) let you write type-safe reusable code. Compared with object they avoid casts, catch errors at compile time and avoid boxing for value types.

An anonymous function written with =>: x => x * 2. Lambdas are converted to delegates (Func, Action, Predicate) or expression trees, which is how EF Core translates LINQ to SQL.

A contract of members a class must implement. It can contain methods, properties, events and indexers, plus default implementations and static members since C# 8/11, but no instance fields.

Boxing wraps a value type in an object on the heap (object o = 42); unboxing casts it back. It allocates and costs performance, so generics are preferred over object-based collections like ArrayList.

With xUnit: [Fact] for one case and [Theory] with [InlineData] for many. Arrange–Act–Assert, test one behaviour per test, and use Moq or NSubstitute to fake interfaces.

They block a thread while waiting. In ASP.NET Core this wastes thread-pool threads and reduces throughput; in UI apps or with certain synchronisation contexts it can deadlock. Use await all the way.

Concise syntax for testing a value’s shape: type patterns, property patterns, relational patterns, list patterns and switch expressions.

1string Describe(object o) => o switch
2{
3    int n when n < 0 => "negative",
4    int => "number",
5    string { Length: 0 } => "empty string",
6    null => "null",
7    _ => "other",
8};

Task is the default for async methods. ValueTask avoids an allocation when results are often available synchronously but has usage restrictions. async void cannot be awaited and its exceptions crash the process — use it only for event handlers.

Objects are allocated on a managed heap. The GC periodically finds unreachable objects and reclaims memory, using generations (0, 1, 2) because most objects die young. Large objects go on the large object heap. Unmanaged resources still need IDisposable.

IDisposable.Dispose releases unmanaged resources (files, sockets, database connections) deterministically. using var and await using call it automatically. Finalizers are only a safety net for unmanaged handles.

Start the tasks without awaiting, then await Task.WhenAll(tasks). For a bounded number of parallel operations use Parallel.ForEachAsync or SemaphoreSlim. Pass CancellationToken through every async call.

Static methods in a static class whose first parameter has this, so they can be called like instance methods: text.Truncate(20). LINQ is built from them. They cannot access private members.