Mid C# Interview Questions

The volatile keyword tells the compiler that a variable may be modified by multiple threads.

It prevents certain optimizations and ensures every read returns the most recent value.

Abstract class: Can contain both implementation and abstraction.

Interface: Defines only the contract with no implementation (in traditional C#).

A class can inherit one abstract class but implement multiple interfaces.

A virtual method allows derived classes to override behavior and provide their own implementation.

Finalize: Called by the garbage collector.

Dispose: Invoked manually to release unmanaged resources deterministically.

Shallow copy: Copies only references of reference-type fields.

Deep copy: Creates a fully independent copy of the entire object graph.

Reflection allows inspecting metadata and interacting with types, methods, and properties at runtime.

The dynamic type skips compile-time checking and resolves member access at runtime.

Public API: Accessible from any assembly.

Internal API: Accessible only within the same assembly.

An assembly is a deployable unit containing compiled code, metadata, and resources.

It is typically a DLL or EXE file.

The params keyword allows passing a variable number of arguments to a method without explicitly creating an array.

Explicit interface implementation allows a class to implement multiple interface methods with the same name without conflict.

The implemented method is accessible only through an interface reference.

Readonly field: Assigned only during declaration or constructor.

Property: Encapsulates logic and allows controlled read/write through getters and setters.

Unsafe context enables pointer operations and direct memory access for performance-critical scenarios.

Custom exceptions are user-defined exception classes representing application-specific errors.

The nameof operator returns the string name of variables, properties, or methods.

It eliminates magic strings and improves refactoring safety.

Method shadowing occurs when a derived class hides a method from the base class using the new keyword.

Synchronous: Blocks the calling thread until the operation completes.

Asynchronous: Continues execution without blocking, offering better scalability and responsiveness.

A memory leak occurs when unused objects remain referenced, preventing garbage collection and increasing memory usage.

StringBuilder efficiently manages dynamic string modifications without creating multiple intermediate immutable strings.

Equality operator: Checks logical equality when overridden.

Reference equality: Checks if two references point to the same object instance.

Value types store their actual data directly on the stack (or inline within other objects). Assigning one value type to another copies all data.

Reference types store references to objects on the heap. Assigning one reference variable to another makes both point to the same object.

This difference impacts memory layout, performance, assignment behavior, parameter passing, and garbage collection.

Boxing converts a value type into an object by wrapping it inside a heap-allocated reference type.

Unboxing extracts the value type back from the object.

Boxing and unboxing are slow due to heap allocation, GC pressure, and runtime type-checking.

IDisposable defines a contract for releasing unmanaged resources such as file handles, sockets, and database connections.

Implement IDisposable when your class owns unmanaged resources that the garbage collector cannot free automatically.

Generics enable type-safe classes and methods that work with any data type.

They eliminate casting, reduce runtime errors, prevent boxing, and improve performance.

const: Compile-time constant; must be assigned at declaration.

readonly: Runtime constant; can be assigned at declaration or inside a constructor.

Readonly avoids versioning issues because its value is not embedded into IL.

Overloading: Same method name, different parameters; resolved at compile time.

Overriding: Derived class redefines base class virtual methods; resolved at runtime.

The Garbage Collector (GC) frees unused heap objects automatically.

It uses generations (Gen0, Gen1, Gen2) to optimize collection of short-lived and long-lived objects.

The GC pauses execution, removes unreachable objects, and compacts memory.

Synchronous: Blocks the calling thread until completion.

Asynchronous: Frees the thread and allows other operations to run concurrently.

Async-await uses Tasks and compiler-generated state machines.

Thread-safe operations ensure consistent behavior when accessed concurrently by multiple threads.

They prevent race conditions, deadlocks, inconsistent states, and crashes.

Immutability means an object's state cannot change after creation.

It avoids the need for locks and prevents corruption in multi-threaded environments.

Static constructor: Initializes static members once per type.

Instance constructor: Initializes object instances and runs per object.

A delegate chain is a list of methods attached to a single delegate.

Invoking the delegate executes all attached methods in sequence.

An event handler is a delegate following the .NET event pattern.

Events encapsulate delegates and restrict invocation to the declaring class.

Reflection Emit enables runtime creation of types, methods, and IL.

Used in ORMs, serializers, proxies, and dynamic frameworks.

Strong naming uses a cryptographic key pair to sign assemblies.

It ensures authenticity, prevents tampering, and enables GAC deployment.

Method binding connects method calls to implementations.

Early binding = compile time; late binding = runtime.

Attributes add metadata to program elements.

Frameworks read attributes to enforce policies, control behavior, or generate code.

Struct: Value type, stack-allocated, lightweight.

Class: Reference type, heap-allocated, supports inheritance and advanced OOP.

Tail recursion occurs when the final operation of a method is a recursive call.

Allows optimization of stack usage and prevents stack overflow.

Anonymous methods allow defining inline method bodies.

They support closures and are often used in event handling.