Senior C# Interview Questions

Class-level variables belong to the object and persist for its lifetime. They maintain state across method calls and can be accessed by all methods inside the class.

Method-level variables exist only within the method scope and are destroyed once the method finishes. They do not retain state across calls and are suited for temporary data.

Interfaces define a contract that implementing types must follow. They enable polymorphism, abstraction, dependency injection, and loose coupling.

They also make unit testing easier by allowing mock implementations.

A sealed class cannot be inherited. It prevents further extension and allows the compiler to optimize method calls.

It is commonly used to avoid misuse or unintended inheritance.

const: Compile-time constant; must be assigned at declaration and is implicitly static.

readonly: Runtime constant; can be assigned at declaration or inside the constructor and allows flexibility when values depend on runtime state.

Boxing converts a value type into an object by allocating memory on the heap.

Frequent boxing/unboxing causes extra allocations, garbage collection pressure, and type-check overhead, which degrade performance.

Extension methods add functionality to existing types without modifying them.

You should avoid them when they reduce readability, create ambiguity, or introduce responsibilities that do not logically belong to the type.

The new keyword hides an inherited member intentionally, preventing compiler warnings and signaling deliberate shadowing behavior.

Nullable value types allow value types to store an additional null state, useful for representing missing or undefined data such as database fields.

Shallow copy copies only top-level values; reference fields still point to shared objects.

Deep copy duplicates the full object graph, ensuring complete independence at the cost of extra memory and performance.

The base keyword accesses parent class members from derived classes.

It is used to call parent constructors or access overridden members.

Static constructors initialize static fields and execute once before the type is first used.

They provide thread-safe, automatic initialization without explicit synchronization.

Implicit conversions occur automatically when safe.

Explicit conversions require manual casting due to potential data loss.

Partial classes split a class across multiple files, useful for separating generated code from custom logic.

Pass-by-value: Copies the value; modifications do not affect the original.

Pass-by-reference: Passes the memory reference; modifications affect the original variable.

Overloading resolution is the compiler’s process for selecting the appropriate method among overloaded options based on parameters, type conversions, and context.

Optional parameters reduce method overloads, simplify API usage, and maintain backward compatibility by allowing default values.

The Dispose pattern ensures deterministic cleanup of unmanaged resources such as file handles and database connections.

Destructors execute when the garbage collector decides to free an object.

They cannot be called manually and should be used only as a final safety mechanism.

Strong typing ensures variables are used only in compatible ways, preventing runtime type errors and enabling better compiler optimization.