Amazon Interview C# Interview Questions

Protecting data through access modifiers and properties.

private int age;

public int Age { get; set; }

Same method name behaves differently based on object type.
Two types:

• Compile-time (method overloading)
• Runtime (method overriding using override )

Child class provides new implementation for a parent class method.

public virtual void Speak() { }

public override void Speak() { }

A special method executed when an object is created.

public Student() { }

Runs only once per type — initializes static members.

static Student() { }

A nullable type allows a value type to also store a null value. It is useful when a variable may or may not have a valid data value.

First: An array has a fixed size.
Second: A List can grow or shrink dynamically.
Arrays are faster for fixed collections, Lists are flexible and easier to use.

An enum is a special value type that represents a set of named constant values.

It improves readability when working with predefined options, categories, or states.

Properties provide controlled access to internal fields of a class.

They allow getting or setting values while applying validation or logic if needed.

An indexer allows an object to be accessed like an array.

It enables retrieving values using an index without exposing internal data structures.

A delegate is a type that holds a reference to a method.

It enables methods to be treated as objects and passed as parameters.

An event allows an object to notify other objects when something happens.

Events follow the publisher–subscriber pattern and are based on delegates.

break: Immediately exits the loop.

continue: Skips the current iteration and moves to the next one.

ref: The variable must be initialized before passing.

out: Initialization is not required before passing, but must be assigned inside the method.

A sealed class cannot be inherited.

It is used to prevent further extension of a class.

A partial class allows a class definition to be split across multiple files.

Commonly used in large projects and generated code.

The using statement ensures that disposable resources are released automatically when the block ends.

A thread is the smallest unit of execution.

It allows multiple tasks to run concurrently.

Multithreading enables a program to perform multiple operations simultaneously using multiple threads.

The lock keyword prevents multiple threads from accessing a shared resource at the same time.

It ensures thread safety.

JIT compiler converts IL code into machine code at runtime.

It optimizes execution for the system's hardware and OS.

is: Checks whether an object is of a specific type.

as: Attempts conversion and returns null if conversion fails.

The base keyword is used in a derived class to access members of the parent class.

It is useful for calling parent constructors or overridden methods.

A readonly struct ensures that all fields remain immutable.

It improves performance by avoiding unnecessary copies.

Field: Stores data directly inside a class.

Property: Provides controlled access to data using getters and setters.

An anonymous type is an object created without defining a class.

The compiler generates a temporary type with read-only properties.

IEnumerable: Represents a collection that can be iterated.

IEnumerator: Performs step-by-step iteration over the collection.

IEnumerable: Executes queries in memory (LINQ to Objects).

IQueryable: Builds expression trees and allows external systems like databases to execute queries.

Extension methods allow adding new functionality to existing types without modifying their source code or creating derived classes.

A static class cannot be instantiated.

It contains only static members and is commonly used for utility functions.

The root class for all .NET types is System.Object.

It provides behaviors like equality, hashing, and type information.

A destructor is a method called when an object is being cleaned up.

It is rarely used because memory is managed by the garbage collector.

Method hiding occurs when a derived class defines a method with the same name as the parent class but does not override it.

The new method hides the parent method when accessed via the derived type.

Early binding: Type information is known at compile time.

Late binding: Type information is resolved at runtime.

The yield keyword simplifies iterator creation.

It returns values one at a time without creating a separate collection.

A generic type allows a class or method to work with multiple data types while maintaining type safety and performance.

Covariance: Allows using a more derived type than originally specified.

Contravariance: Allows using a more base type than originally specified.

Dependency Injection (DI) provides required objects from outside rather than creating them internally.

It improves modularity, testability, and maintainability.

Thread: A physical execution unit.

Task: A higher-level abstraction optimized for asynchronous operations.

async marks a method as asynchronous.

await pauses execution until the awaited task completes without blocking the thread.

A race condition happens when multiple threads access or modify shared data simultaneously, causing unpredictable behavior.

Deadlock occurs when multiple threads wait for each other's resources and none of them can continue.

Stack: Stores value types and method call information.

Heap: Stores reference types and dynamically allocated objects.

An attribute is metadata applied to program elements like classes, methods, or properties.

It helps frameworks control behavior at compile time or runtime.

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.

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.

The CLR is the execution engine for .NET applications. It manages memory, performs JIT compilation, enforces type safety, handles exceptions, and manages garbage collection.

It abstracts low-level memory management and provides a secure, consistent runtime environment, enabling cross-language interoperability and automatic memory management.

The JIT compiler converts IL to machine code just before execution. It applies hardware-specific optimizations such as inlining, dead-code elimination, and CPU-tuned instruction generation.

It may recompile methods dynamically based on runtime execution patterns, making performance adaptive.

C# enforces strict type-checking, prevents unsafe casts, limits pointer operations, and ensures invalid operations are caught at compile time or enforced by the CLR.

This eliminates memory corruption, improves security, and reduces runtime crashes.

Managed resources are controlled by the CLR (objects, arrays, strings), while unmanaged resources (file handles, sockets, DB connections) must be released manually via IDisposable.

Failure to release unmanaged resources leads to leaks and OS-level exhaustion.

Nullable reference types prevent null reference exceptions by enforcing compiler analysis and warnings for unsafe null operations.

volatile ensures read/write operations always use the most current value and prevents CPU/compiler reordering.

It is essential for correctness in low-level, lock-free synchronization.

Process memory includes stack, heap, DLL modules, native allocations, and OS buffers.

Managed heap is only the CLR-controlled memory region used for .NET objects and garbage collection.

String immutability enables thread safety, prevents accidental mutation, and supports optimizations like interning.

Metadata contains structured information about types, members, attributes, and versioning.

It powers reflection, type loading, serialization, security, and tooling support.

Boxing allocates heap memory, copies value types into objects, and causes GC overhead.

Unboxing additionally requires type checking, making both operations costly.

Weak references allow referencing an object without preventing GC from collecting it.

They are used in caching and memory-sensitive scenarios.

Reflection enables runtime inspection and invocation of types but is slower, bypasses compile-time type checks, exposes internals, and increases security risks.

The .NET GC uses reachability analysis, not reference counting. Circular references pose no issue unless unreachable from GC roots.

Memory barriers prevent reordering and enforce visibility guarantees across threads. They are essential in lock-free algorithms.

Attributes add metadata used by frameworks for configuration, validation, serialization, and behavioral modification.

Stack value types allocate fast with no GC overhead.

Boxed values allocate on the heap, increasing memory usage and GC costs.

Type erasure removes generic type information at compile time (Java). C# retains generic metadata at runtime, improving performance and type safety.

AppDomains provided isolation and sandboxing in .NET Framework. .NET Core replaces them with AssemblyLoadContext.

Exceptions trigger stack unwinding, metadata discovery, and context capturing, making them significantly slower than normal execution.

They should be used only for true exceptional situations—not control flow.

A delegate is a type-safe reference to a method. It defines a method signature and allows methods to be stored and invoked dynamically.

Delegates enable callbacks, event-driven programming, extensibility, and loose coupling by allowing execution of unknown methods at runtime.

Multicast delegates can reference multiple methods. When invoked, they call each method sequentially.

They are used for audit logging, notifications, UI event pipelines, and scenarios requiring multiple actions on a single trigger.

Action represents methods that return void, while Func represents methods that return a value.

They reduce the need for custom delegate declarations and simplify modern C# programming.

Events wrap delegates to enforce encapsulation. Only the declaring class can invoke the event, while external components may subscribe or unsubscribe.

Events implement the publisher–subscriber pattern for decoupled communication.

The publisher–subscriber model allows components to react to changes without tight coupling.

Publishers broadcast notifications without knowing subscribers, improving modularity and scalability.

async/await enables writing asynchronous code in a synchronous style, avoiding callback complexity.

It improves scalability by freeing threads during I/O waits.

The synchronization context determines where continuation runs after an await.

UI apps return to the UI thread; ASP.NET Core uses a context-free model to improve throughput.

Thread pools reuse threads, reducing creation overhead and improving performance.

They optimize concurrency through heuristics and balancing strategies.

Shared data introduces race conditions, stale reads, memory-order issues, and partial updates.

Proper synchronization is required to ensure correctness.

Mutex allows exclusive access to a resource; Semaphore limits concurrent access.

Both prevent race conditions but may cause contention when misused.

Lock-free operations rely on atomic CPU instructions instead of locks.

They improve scalability and reduce latency in high-concurrency environments.

Generics provide compile-time type checking, eliminate unsafe casts, and avoid boxing for value types.

They enhance performance and enable reusable APIs.

Generic constraints restrict the types permitted in generics, enabling safer and more expressive generic code.

They allow accessing members safely based on constraints.

Covariance allows using derived types where base types are expected. Contravariance allows the opposite.

They enable flexible delegate and interface usage.

List uses a dynamically resizing array. When full, it grows and copies elements.

Provides fast indexing but costly mid-list insertions.

Dictionary uses a hash table. The key's hash determines its bucket for near O(1) lookups.

Good hashing minimizes collisions, improving performance.

Collisions occur when two keys map to the same bucket. They are handled via chaining or probing.

Good hash code implementation minimizes collisions.

The load factor measures how full a hash table is. When exceeded, resizing and rehashing occur to maintain performance.

Each data structure is optimized for specific operations. Incorrect choice leads to wasted CPU cycles and memory overhead.

Understanding internal behavior is essential for building high-performance systems.

The CLR pipeline includes:

• C# code parsed by Roslyn into IL + metadata.
• IL stored in assemblies (.dll/.exe).
• CLR loads assemblies via Assembly Loader and verifies IL.
• JIT compiles IL to native machine code using RyuJIT and tiered compilation.
• Execution occurs under GC, exception handling, and type-safety rules.
• Supports JIT, AOT, ReadyToRun, and NativeAOT execution models.

The .NET Memory Model defines visibility and ordering guarantees:

• Reordering may occur unless prevented by barriers.
• volatile ensures visibility but not atomicity.
• lock, Monitor, Interlocked insert full memory fences.
• Handles cache coherency, tearing, and ABA issues.
• More relaxed than Java regarding visibility rules.

Value types are stored inline on the stack or inside objects. Reference types reside on the managed heap.

Boxing allocates new objects with headers and method table pointers. Inline struct fields avoid indirection and improve performance.

A .NET object contains:

• Object Header: Method Table pointer + Sync Block index.
• Aligned fields with padding.
• Method Table with hierarchy, vtable, and GC info.

Generations:

• Gen0: short-lived objects.
• Gen1: buffer generation.
• Gen2: long-lived objects; full GC expensive.
• LOH: >= 85KB, collected only in full GC.
• POH introduced for pinned objects.
• GC modes: Server, Workstation, Concurrent.

Tier 0 emits fast, minimally optimized code. Tier 1 recompiles hot methods with optimizations.

Tiered PGO improves performance for long-running APIs.

Differences:

• lock/Monitor: lightweight, thread-level.
• Mutex: cross-process synchronization.
• Semaphore: limits concurrent entries.
• SpinLock: busy-wait for low contention.
• ReaderWriterLockSlim: optimized for read-heavy workloads.

Compiler rewrites async methods into state machines stored as structs or classes.

Await posts continuations to SynchronizationContext or thread pool.

Avoid capturing context for performance.

Intern pool stores unique string instances for process lifetime.

Benefits: deduplication of literals. Harmful: unbounded memory use if interning user input.

• Reflection: slow metadata inspection.
• Reflection.Emit: runtime IL generation.
• Expression Trees: build code graphs; compile to delegates.
• Source Generators: compile-time code generation.

Uses global + per-thread queues, work-stealing, and hill-climbing algorithm to adjust worker count.

Long-running work should use TaskCreationOptions.LongRunning.

Delegates can be:

• Open/closed static
• Open/closed instance
• Multicast (invocation list)

Captured variables create hidden closure classes.

Roslyn provides AST, syntax trees, semantic models, analyzers, and source generation. It is a compiler-as-a-service.

out = covariance, in = contravariance.

Allows safe substitutability. Includes delegate variance, IEnumerable variance, and array pitfalls.

AppDomains provided isolation but were heavy and difficult to unload.

.NET Core replaced them with AssemblyLoadContext.

IL, CIL, and MSIL are the same thing: platform-independent intermediate language.

Flow:

• Throw triggers stack unwinding.
• Search for handlers.
• First-chance and second-chance exceptions.
• finally, fault blocks executed.
• Managed/unmanaged transitions handled by the runtime.

Strong naming gives a unique identity but not security.

Authenticode signing verifies publisher identity.

Assembly identity affects binding and version resolution.

Metadata includes type, method, field tables, attributes, and generic constraints.

CLR uses it for JIT compilation, verification, reflection, and type loading.

• Excess allocations
• Boxing
• Hidden lambda captures
• LINQ in hot paths
• Unnecessary locks
• Sync-over-async
• Exceptions for flow control