.NET Interview Questions

Compare copying a value with copying a reference. Explain that storage location depends on context; a value type is not always stored on the stack.

Discuss contracts, shared implementation and substitutability. Describe how composition can avoid a rigid inheritance hierarchy.

Compare value equality, identity and copying. Explain why a record containing a mutable collection is not automatically deeply immutable.

Explain compile-time flow analysis and annotations. Show why validation of external input is still required at runtime.

Compare a generic collection with an object-based collection, including constraints and boxing. Use variance only where the type relationship is valid.

Discuss reachability and generations. Explain that retaining references can keep unnecessary objects alive even in a managed runtime.

Describe deterministic cleanup of owned resources, including exception paths. Do not rely on garbage collection to close a file or connection promptly.

Show a value converted to object or an interface and discuss allocation and copying. Measure before optimizing away clear code.

Trace the reference chain from a long-lived publisher or cache to a subscriber. Explain unsubscribe, eviction and ownership policies.

Compare allocations, live objects and working set over time. Use a reproducible workload and inspect heap roots before choosing a fix.

Compare ordered traversal, key lookup and membership tests. Include equality comparers and the memory cost of hashing.

Show how enumeration can observe changed data or repeat expensive work. Explain when materializing with ToList is useful.

Distinguish in-process enumeration from provider-translated expressions. Discuss where filtering occurs and how unsupported operations are handled.

Identify a query enumerated for Count and then for results. Choose streaming, materialization or a different query based on cost and memory.

Explain the equality contract and consistent hash codes. Discuss mutable keys and why a changed hash can break lookup expectations.

Explain continuations and a task representing completion. An async method does not imply a new dedicated thread.

Discuss CPU-bound work and why wrapping naturally asynchronous I/O can waste thread-pool capacity on a server.

Pass CancellationToken through call boundaries. Explain cooperative cancellation, cleanup and how cancellation differs from a failure.

Discuss blocking, thread starvation and synchronization-context deadlocks where applicable. Prefer awaiting through the call chain.

Compare a semaphore, a bounded channel and a worker pool. Include backpressure, cancellation and error handling rather than launching unlimited tasks.

Describe short-circuiting and the request/response sequence. Explain exception handling, authentication and authorization placement.

Explain ownership and scope boundaries. Discuss why a singleton must not capture a request-scoped dependency.

Separate establishing identity from permission checks. Cover policies and why hiding a UI control does not secure an endpoint.

Validate request boundaries, return appropriate status codes and avoid leaking internal exception details. Keep the response format consistent.

Separate environment configuration from credentials. Describe typed options, startup validation and a secret store or managed identity.

Explain repeated related-data queries. Compare projections, eager loading and split queries with their transfer and consistency tradeoffs.

Use it for read-only entity queries when change tracking is unnecessary. Explain the implications for updates and identity resolution.

Describe an optimistic concurrency token, detecting a conflict and choosing a retry or user-resolution policy.

Define the invariant across writes and explain isolation and locking. Do not assume a database transaction makes external network effects atomic.

Prefer backward-compatible expansion, data migration and later cleanup. Consider old application instances, rollback limits and migration ownership.

Compare latency, shared consistency, process lifetime and eviction. Avoid caching private responses under keys shared by different users.

Discuss coalescing concurrent loads, bounded stale data and jittered expiry. Explain how refresh failures affect availability.

Distinguish transient failure from permanent rejection. Combine bounded retries and backoff with idempotency for operations that may already have succeeded.

Explain CSRF defenses, cookie attributes and authorization checks. Discuss CORS separately from authentication and CSRF protection.

Measure request timings, database work, external calls and allocations. Use traces to find the bottleneck before increasing infrastructure.

Define durable state, deduplication and the boundary of each transaction. Explain cancellation, crash recovery and a dead-letter policy.

Choose a stable sort, validate limits and compare offset with cursor pagination. Include indexes and access control.

Use a narrow interface, constructor injection and explicit failure handling. Describe meaningful tests at the boundary.

Look for blocking calls, queue growth and latency under load. Distinguish starvation from CPU saturation or a slow database.

Cover readiness checks, compatible schema changes, staged traffic and rollback. Define the observations that would trigger a rollback.