C# interview questions

What a strong answer covers

• Define Encapsulation: bundling data and methods, restricting direct access (e.g., private fields with public properties).
• Define Inheritance: creating new classes from existing ones, reusing code (e.g., `Dog` inherits from `Animal`).
• Define Polymorphism: objects of different classes treated as objects of a common type (e.g., method overriding, interface implementation).
• Define Abstraction: showing essential information, hiding implementation details (e.g., abstract classes, interfaces).

Where people lose the point

• ×Confusing abstraction with encapsulation, or inheritance with polymorphism.
• ×Providing examples that don't clearly demonstrate the specific pillar.
• ×Failing to explain the 'why' behind each pillar's benefit.

What a strong answer covers

• Value types store their data directly; reference types store a reference to their data.
• Value types are typically allocated on the stack; reference types are allocated on the heap.
• Examples of value types: `int`, `bool`, `struct`, `enum`. Explain that assignment creates a copy.
• Examples of reference types: `class`, `string`, `array`, `delegate`. Explain that assignment copies the reference, not the data.

Where people lose the point

• ×Incorrectly stating where `string` is allocated (it's a reference type, heap).
• ×Failing to explain the implications of assignment (copy vs. shared reference).
• ×Confusing `struct` with `class` in terms of memory behavior.

What a strong answer covers

• Interfaces define a contract (what a class can do) and can only contain declarations (methods, properties, events, indexers).
• Abstract classes can provide partial implementation, contain fields, constructors, and non-abstract methods.
• A class can implement multiple interfaces but can inherit from only one abstract class.
• Choose an interface for defining capabilities or contracts across unrelated classes; choose an abstract class for providing a common base implementation for related classes.

Where people lose the point

• ×Stating that interfaces can have implementation (pre-C# 8) or fields.
• ×Not mentioning the single inheritance limitation for abstract classes.
• ×Failing to provide clear use-case scenarios for each.

What a strong answer covers

• Generics allow you to define classes, interfaces, and methods with placeholders for types, resolved at compile time.
• They solve the problems of type safety (avoiding runtime errors from incorrect casts) and code reusability (writing code once for multiple types).
• They eliminate boxing/unboxing overhead when working with value types compared to using `object`.
• Example: `List<T>` or a custom generic `Stack<T>` class, demonstrating how `T` is used.

Where people lose the point

• ×Confusing generics with inheritance or polymorphism.
• ×Not clearly explaining the performance benefits (avoiding boxing/unboxing).
• ×Providing an example that isn't truly generic or doesn't highlight its benefits.

What a strong answer covers

• LINQ provides a uniform way to query data from various sources (collections, databases, XML) directly within C#.
• It offers type safety and compile-time checking for queries.
• Demonstrate a query using method syntax (e.g., `Where`, `Select`, `OrderBy`) on a `List<T>` of custom objects.
• Explain the benefits: readability, reduced boilerplate, strong typing.

Where people lose the point

• ×Only showing query syntax without explaining method syntax, or vice-versa.
• ×Not explaining the 'integrated' aspect of LINQ.
• ×Providing a trivial example that doesn't showcase LINQ's power (e.g., just filtering integers).

What a strong answer covers

• `async` marks a method as asynchronous, allowing `await` within it; `await` pauses execution of the `async` method without blocking the calling thread.
• Explain that `await` returns control to the caller, and the method resumes when the awaited `Task` completes.
• Benefits: improved UI responsiveness, better resource utilization (especially for I/O-bound operations), simplified asynchronous code.
• Pitfalls: `async void` (except for event handlers), deadlocks (e.g., mixing `await` with `.Result` or `.Wait()`), not handling exceptions correctly.

Where people lose the point

• ×Incorrectly stating that `await` blocks the thread.
• ×Failing to mention `Task` or `Task<TResult>` as the core mechanism.
• ×Not discussing the importance of `ConfigureAwait(false)` in library code.

What a strong answer covers

• `IDisposable` is an interface for types that hold unmanaged resources (e.g., file handles, network connections) that need explicit cleanup.
• The `Dispose()` method defined by `IDisposable` is responsible for releasing these resources.
• The `using` statement provides a convenient syntax to ensure `Dispose()` is called automatically, even if exceptions occur.
• Use them to prevent resource leaks and ensure deterministic cleanup of unmanaged resources.

Where people lose the point

• ×Confusing `IDisposable` with garbage collection (GC handles managed memory, `IDisposable` handles unmanaged).
• ×Not explaining that `using` ensures `Dispose()` is called in a `finally` block.
• ×Failing to mention the importance of deterministic cleanup.

What a strong answer covers

• Boxing: converting a value type to the `object` type or an interface type it implements. This involves allocating memory on the heap and copying the value.
• Unboxing: converting an `object` type back to a value type. This involves checking the type and copying the value from the heap to the stack.
• Provide a clear code example demonstrating both boxing and unboxing.
• Performance implications: both operations incur overhead due to memory allocation, copying, and type checking, which can impact performance in tight loops.

Where people lose the point

• ×Incorrectly stating that unboxing doesn't require a type check.
• ×Failing to mention the heap allocation for boxing.
• ×Not emphasizing the performance cost, especially in high-frequency scenarios.

What a strong answer covers

• Delegates are type-safe function pointers; they define a signature (return type and parameters) for methods they can point to.
• They allow methods to be passed as arguments, stored in variables, and invoked later, enabling callback mechanisms.
• Events in C# are built on delegates, providing a safe way for a class to notify other classes when something interesting happens.
• Example: Define a delegate, a method matching its signature, and then assign and invoke the method via the delegate.

Where people lose the point

• ×Confusing delegates with interfaces or abstract classes.
• ×Not explaining that events add a layer of encapsulation around delegates.
• ×Providing an example that doesn't clearly show the delegate's role as a function pointer.

What a strong answer covers

• Static members belong to the class itself, not to any specific instance of the class. They are accessed directly via the class name.
• Static fields are shared across all instances; static methods can only access static members.
• Static classes can only contain static members and cannot be instantiated or inherited.
• Use cases: utility classes (e.g., `Math`), shared configuration, factory methods. Limitations: no instance state, cannot be overridden, can lead to tight coupling.

Where people lose the point

• ×Incorrectly stating that static members are thread-safe by default.
• ×Failing to mention that static classes cannot be instantiated or inherited.
• ×Not discussing the implications of shared state in static fields.

What a strong answer covers

• Explain the scenario: a UI thread calls an `async` method using `.Result` or `.Wait()`, blocking itself.
• The `async` method then `awaits` a task. If the `SynchronizationContext` captures the UI thread, it tries to resume the `async` method on that same blocked UI thread.
• This creates a deadlock: the UI thread is waiting for the `async` method to complete, and the `async` method is waiting for the UI thread to become available to resume.
• Avoidance: Use `await` all the way down (async-all-the-way), or use `ConfigureAwait(false)` in library code to prevent context capture.

Where people lose the point

• ×Not clearly explaining the role of `SynchronizationContext` in the deadlock.
• ×Suggesting `Task.Run` as a universal fix without explaining its limitations.
• ×Failing to emphasize that `await` should be used consistently.

What a strong answer covers

• Reflection is the ability of a program to examine and modify its own structure and behavior at runtime.
• It allows inspecting metadata (types, members, attributes) and invoking members dynamically.
• Use case 1: Plugin architectures or extensibility frameworks, where types are loaded and instantiated dynamically based on configuration.
• Use case 2: Object-Relational Mappers (ORMs) or serialization libraries that map object properties to database columns or JSON fields at runtime.

Where people lose the point

• ×Confusing reflection with code generation or dynamic compilation.
• ×Not mentioning the performance overhead associated with reflection.
• ×Providing trivial or non-practical use cases.

What a strong answer covers

• The .NET Garbage Collector (GC) automatically manages memory for managed objects on the heap, reclaiming memory occupied by objects no longer referenced.
• It's a generational collector: objects are grouped into generations (Gen 0, Gen 1, Gen 2) based on their lifetime.
• Gen 0 is for short-lived objects, Gen 1 for objects surviving Gen 0 collections, Gen 2 for long-lived objects.
• Generational collection optimizes by frequently collecting Gen 0 (which is fast) and less frequently collecting older generations, based on the 'infant mortality' hypothesis.

Where people lose the point

• ×Confusing GC with `IDisposable` or manual memory management.
• ×Incorrectly describing the flow between generations or the purpose of each.
• ×Failing to mention that GC is non-deterministic.

What a strong answer covers

• Extension methods allow you to add new methods to existing types without modifying the original type or creating a derived type.
• They are static methods defined in a static class, with their first parameter prefixed by `this` keyword.
• Purpose: enhance existing types (e.g., `string`, `IEnumerable<T>`) with new functionality, improve readability, and promote a fluent API style.
• Design considerations: use sparingly, avoid name collisions, ensure they add value and don't break encapsulation, consider if a utility class or inheritance is more appropriate.

Where people lose the point

• ×Incorrectly stating that extension methods modify the original type.
• ×Forgetting the `this` keyword or that they must be in a static class.
• ×Not discussing the potential for misuse or over-extension.

What a strong answer covers

• Choose `struct` for small, simple data types that primarily hold values and do not require inheritance (e.g., `Point`, `Color`).
• Structs are value types, allocated on the stack (or inline in arrays/objects), leading to fewer heap allocations and potentially better performance for small types.
• Trade-offs: Structs are copied by value, which can be inefficient for large structs. They cannot be null, cannot inherit from other structs/classes (only implement interfaces), and have no default constructor.
• General guideline: Use `struct` if it's small (under 16 bytes), immutable, and doesn't need reference semantics.

Where people lose the point

• ×Suggesting structs for large, complex objects.
• ×Failing to mention the immutability aspect or the inability to be null.
• ×Not clearly articulating the performance trade-offs (copying vs. heap allocation).