C# and .NET Interview Questions

What should I focus on for a C# and .NET interview?

Which topics should I start with?

Start with async and threading, which appeared in 31 of 95 interviews. Dependency injection, design patterns, and testing appeared in 30 of 95 interviews. These were the most common topic groups in these interviews.

The service lifetime question was the most asked individual question, appearing in 13 of 95 interviews. Check whether you can answer it and the other common questions:

• How do transient, scoped, and singleton lifetimes differ? When would you use each?
• What is dependency injection in .NET, and why is it used?
• How do async and await work, and when should you use them?

What should I know beyond definitions?

The async questions go beyond async and await. Can you explain cancellation and exception handling? Can you describe synchronization, deadlocks, and how to limit concurrent work?

For language and runtime questions, check whether you can explain these differences and responsibilities:

• How do value types and reference types differ?
• What does the CLR manage when .NET code runs?
• How does modern .NET differ from .NET Framework?
• What does ConfigureAwait do, and when should you use ConfigureAwait(false)?

Memory questions cover stack and heap storage, boxing, garbage collection, disposal, and finalizers. Can you explain what garbage collection does and how disposal differs from it?

What should I check for web and data questions?

Start with the request pipeline. Can you walk through an HTTP request as it passes through ASP.NET Core? Explain what middleware does, then check how routing, model binding, validation, and error handling fit into request handling.

For data access, can you compare IEnumerable with IQueryable? Can you explain deferred execution in LINQ? The data questions also cover Entity Framework behavior, database access, and serialization formats.

For security, can you explain the difference between authentication and authorization? Can you describe what JWT validation involves? These are concrete checks before moving to questions on claims, cookies, and secure configuration.

Should I be ready to write code?

Code-writing tasks appeared in 8 of 95 interviews. Try these tasks from the interviews without looking up the syntax:

• Write an interface and a class that implements it.
• Write the line that registers a transient service in ASP.NET Core.
• Use LINQ to find users whose names start with uppercase N. Explain why some expressions might not translate to SQL.
• Create and start a thread in C#.
• Write route attributes for a controller action that updates a user by ID.

Who gets asked C# and .NET

The 20 most asked C# and .NET questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. How do transient, scoped, and singleton service lifetimes differ, and when would you use each?

   Asked in 13 of 95 interviews · last asked Sep 29 · Concept · Mid-level

   Show answer

   Transient creates a new instance each time it is requested; use it for a small, stateless formatter. Scoped creates one instance per scope, usually one HTTP request; use it for an EF Core DbContext. Singleton shares one instance across the application; use it for a thread-safe in-memory cache. Singletons must not capture scoped services.

   • Scoped services are shared within a scope, but separate scopes get separate instances.
   • Singleton services must handle concurrent access safely.
   • Injecting DbContext into a singleton can fail scope validation or cause unsafe sharing between requests.
   • Background services must create an explicit scope when they need scoped services.

   What the interviewer checks: The interviewer checks whether you can choose lifetimes based on shared state, thread safety, and dependency lifetimes.

   Other ways it was asked

   • “Can you explain the differences between transient, scoped, and singleton service lifetimes in ASP.NET Core, and give a concrete example of when you would use each?”
   • “In ASP.NET Core, what's the difference between transient, scoped, and singleton lifetimes?”
   • “Explain transient, scoped, and singleton lifetimes in ASP.NET Core.”

2. How do async and await work in C#, and when should you use them?

   Asked in 11 of 95 interviews · last asked Oct 5 · Concept · Mid-level

   Show answer

   async lets a method use await; the compiler turns its body into a state machine. When an awaited operation is incomplete, await pauses the method without blocking the thread and resumes it later. Use this for I/O, such as HTTP or database calls, to keep apps responsive and avoid blocking server threads.

   • The method runs synchronously until it reaches an await whose operation is incomplete.
   • Async methods usually return Task or Task<T>. Avoid async void except for event handlers.
   • async does not create a thread. For CPU-heavy work, Task.Run can keep a UI responsive.
   • await rethrows task exceptions. Blocking with .Result or .Wait() can cause deadlocks.

   What the interviewer checks: The interviewer checks whether you understand nonblocking execution, task handling, and when asynchronous code is useful.

   Other ways it was asked

   • “What are async and await in C#, and how do they support asynchronous programming?”
   • “What are async and await in C#, and why are they important?”
   • “How do async and await work in C#, and when would you use them?”

3. What is dependency injection in .NET, and why is it used?

   Asked in 9 of 95 interviews · last asked Oct 15 · Concept · Junior

   Show answer

   Dependency injection means a class receives the objects it needs instead of creating them itself. In .NET, you register services with a DI container, which creates objects and supplies their dependencies, usually through constructors. This reduces tight coupling and makes code easier to test and change.

   • Modern .NET includes a built-in DI container; Autofac is another option.
   • Code can depend on interfaces, making implementations easier to replace.
   • Service lifetimes control reuse: transient per resolution, scoped per scope, and singleton per container.
   • In ASP.NET Core, a scope normally lasts for one web request.

   What the interviewer checks: The interviewer checks whether you understand how DI separates object creation from use and supports testing and maintenance.

   Other ways it was asked

   • “What is dependency injection, and what are some DI containers used in .NET?”
   • “How does dependency injection work in .NET?”
   • “In your own words, what is dependency injection in .NET?”

4. What is middleware in ASP.NET Core?

   Asked in 8 of 95 interviews · last asked Oct 1 · Concept · Junior

   Show answer

   Middleware is a component in the ASP.NET Core HTTP request pipeline. It can process a request, call the next component, and process the response as control returns. It can also stop the pipeline and return a response itself. Common uses include logging, authentication, and error handling.

   • Middleware runs in registration order for requests and reverse order as control returns.
   • Calling the next component continues the pipeline; not calling it stops further processing.
   • Order matters: authentication should run before authorization.
   • Error-handling middleware can catch exceptions from components registered after it.

   What the interviewer checks: The interviewer checks whether you understand pipeline flow, middleware order, and common uses.

   Other ways it was asked

   • “What is .NET Core middleware?”
   • “What is middleware in ASP.NET?”
   • “Can you explain what middleware is in ASP.NET Core and how it contributes to processing an incoming HTTP request?”

5. What is .NET, and how does modern .NET differ from .NET Framework?

   Asked in 6 of 95 interviews · last asked Sep 19 · Concept · Junior

   Show answer

   .NET is a development platform with a runtime, libraries, and tools for building and running applications in languages such as C#. Modern .NET grew from .NET Core and supports Windows, Linux, and macOS. .NET Framework is the older, Windows-only implementation, mainly maintained for existing applications.

   • The runtime executes managed code and handles tasks such as memory management through garbage collection.
   • Modern .NET receives new features; .NET Framework continues to receive support and security fixes.
   • Modern .NET is cross-platform, but some application types, such as WPF and Windows Forms, remain Windows-only.
   • Moving from .NET Framework may require code changes because not all APIs and libraries are compatible.

   What the interviewer checks: The interviewer wants to know whether you understand the platform and can distinguish its modern and older implementations.

   Other ways it was asked

   • “What is .NET?”
   • “What is Microsoft .NET?”
   • “Can you explain what .NET is?”

6. What is the difference between IEnumerable and IQueryable in .NET?

   Asked in 6 of 95 interviews · last asked Oct 2 · Concept · Mid-level

   Show answer

   IEnumerable<T> supports iteration, and its LINQ operators run .NET code on the items. IQueryable<T> also supports iteration, but builds expression trees that a query provider interprets. In Entity Framework, this lets supported operations run as SQL in the database. Use IQueryable<T> to build database queries and IEnumerable<T> to work with items in .NET.

   • IQueryable<T> inherits from IEnumerable<T>; the provider decides how the query runs.
   • Both can use deferred execution; IEnumerable<T> does not mean the data is already loaded.
   • AsEnumerable() makes later LINQ operators run in .NET; it does not immediately load the results.
   • Filtering in the database can reduce transferred data, but not every .NET operation can become SQL.

   What the interviewer checks: The interviewer checks whether you understand where queries run, when they execute, and how that affects performance.

   Other ways it was asked

   • “What is the difference between IQueryable and IEnumerable?”
   • “In the .NET framework, what’s the difference between IEnumerable and IQueryable, and when would you choose one over the other?”
   • “What's the difference between IEnumerable and IQueryable?”

7. What is the difference between value types and reference types in C#?

   Asked in 4 of 95 interviews · last asked Sep 21 · Concept · Junior

   Show answer

   A value-type variable holds the value itself; a reference-type variable holds a reference to an object. Assignment copies the value for value types and the reference for reference types. Two reference-type variables can point to the same object, so changes to that object's data can be seen through both.

   • Structs and enums are value types; classes, arrays, and strings are reference types.
   • Value types are not always on the stack; storage depends on where they are used.
   • Copying a struct copies its fields, but reference-type fields still point to the same objects.
   • Reference types can hold null; value types need Nullable<T> to represent null.

   What the interviewer checks: The interviewer is checking whether you understand copying, shared objects, and why stack versus heap is not the main distinction.

   Other ways it was asked

   • “Do you know the difference between reference types and value types?”
   • “Tell me a bit about the differences between value types and reference types.”
   • “What is the difference between reference types and value types?”

8. What does ConfigureAwait do, and when should you use ConfigureAwait(false)?

   Asked in 4 of 95 interviews · last asked Sep 29 · Concept · Senior

   Show answer

   ConfigureAwait controls whether an await tries to resume on the captured context. ConfigureAwait(false) skips that capture; it does not force a new thread. Use it in library code that does not need the caller’s context. Avoid it when later code needs the UI context or ASP.NET Framework request context.

   • By default, task awaits capture a SynchronizationContext or, without one, a non-default TaskScheduler.
   • ASP.NET Core normally has no custom SynchronizationContext, so ConfigureAwait(false) usually makes no scheduling difference.
   • It affects only that await, not every await in the method.
   • It can prevent some blocking deadlocks, but awaiting instead of using .Result or .Wait() is safer.

   What the interviewer checks: The interviewer checks whether you understand continuation scheduling and when code depends on its original context.

   Other ways it was asked

   • “What does ConfigureAwait do, and when might you use ConfigureAwait(false)?”
   • “What is ConfigureAwait(false) and when would you use it?”
   • “Do you need to use ConfigureAwait(false) in C# async methods, and when?”

9. What happens as an HTTP request passes through the ASP.NET Core request pipeline?

   Asked in 4 of 95 interviews · last asked Sep 18 · Concept · Mid-level

   Show answer

   An HTTP request passes through an ordered chain of middleware in ASP.NET Core. Each middleware can handle the request, call the next component, or stop the chain early. Routing selects an endpoint, such as an MVC action, which runs if the request reaches endpoint execution. Afterward, control returns through earlier middleware in reverse order to finish the response.

   • Middleware runs in registration order for requests; code after calling the next component runs in reverse order.
   • Middleware can stop the chain early, for example by serving a static file or rejecting access.
   • Routing selects an endpoint; authentication identifies the user, and authorization checks access before the endpoint runs.
   • For MVC endpoints, model binding, validation, filters, action execution, and result execution happen within the pipeline.

   What the interviewer checks: The interviewer checks whether you understand middleware order, early responses, and how routing and MVC fit into request handling.

   Other ways it was asked

   • “What is the ASP.NET request pipeline, why is it used, and how does it work?”
   • “What is the ASP.NET Core request pipeline, and how does it work?”
   • “How does the middleware request pipeline work in ASP.NET Core?”

10. What does the CLR manage, and what role does it play when .NET code runs?

    Asked in 3 of 95 interviews · last asked Aug 27 · Concept · Junior

    Show answer

    The Common Language Runtime (CLR) runs managed .NET code and manages memory, garbage collection, type safety, and exception handling. It loads code and usually uses just-in-time (JIT) compilation to turn intermediate language (IL) into machine code. Managed code means code that runs under the runtime's control.

    • Garbage collection reclaims memory from managed objects that are no longer reachable.
    • The CLR loads assemblies and provides runtime services across .NET languages.
    • JIT compilation happens at runtime; ahead-of-time compilation can produce machine code before execution.
    • Garbage collection does not replace disposing resources such as files and database connections.

    What the interviewer checks: The interviewer is checking whether you understand how .NET code executes and which services the runtime provides.

    Other ways it was asked

    • “Can you explain what the CLR does and why it is important when a .NET application runs?”
    • “What is the CLR, and what role does it play when a .NET application runs?”
    • “What is the Common Language Runtime (CLR), and what happens when a .NET application runs?”

11. What is .NET Core?

    Asked in 3 of 95 interviews · last asked Oct 15 · Concept · Junior

    Show answer

    .NET Core is a free, open-source platform for building and running applications on Windows, Linux, and macOS. Unlike .NET Framework, which runs only on Windows, it supports cross-platform development. It also supports side-by-side runtime versions. From .NET 5 onward, its successor is called .NET.

    • .NET Core includes a runtime and libraries; its SDK provides tools to build applications.
    • It is commonly used for web apps, APIs, services, and console apps.
    • Windows Forms and WPF remain Windows-only, even on modern .NET.
    • For new development, use a supported modern .NET version rather than the old .NET Core releases.

    What the interviewer checks: The interviewer is checking whether you understand the platform, its Windows-only predecessor, and its modern name.

    Other ways it was asked

    • “What is the difference between .NET Framework and .NET Core?”

12. What does the `virtual` keyword do in C#, and when would you use it?

    Asked in 3 of 95 interviews · last asked Aug 19 · Concept · Junior

    Show answer

    In C#, `virtual` lets a derived class replace an inherited member's implementation using `override`. When you call a virtual method, the object's runtime type determines which implementation runs. Use it when a base class provides default behavior that derived classes may need to change.

    • Methods, properties, indexers, and events can be virtual.
    • Overriding is optional; the inherited implementation runs if no override replaces it.
    • Class methods are non-virtual by default. Use `override`, not `new`, to change virtual behavior.

    What the interviewer checks: The interviewer is checking whether you understand overriding and how virtual calls support polymorphism.

    Other ways it was asked

    • “What is the virtual keyword used for in C#?”
    • “What is the virtual keyword, and why do we use it?”

13. What are boxing and unboxing in C#, and what happens when a value type becomes an object?

    Asked in 3 of 95 interviews · last asked Sep 21 · Concept · Junior

    Show answer

    Boxing wraps a copy of a value type in an object on the managed heap. This happens, for example, when an int is passed to a method that accepts object. Unboxing checks the boxed value’s type and copies its value back into a value type through an explicit cast.

    • Changing the original value does not change the boxed copy.
    • Unboxing requires the matching value type; a boxed int cannot be directly unboxed as long.
    • Boxing adds allocation and garbage collection costs; generic collections can avoid it.

    CodeCopy

    int number = 5;
    object boxed = number;       // Boxing: stores a copy of 5.
    number = 9;                 // The boxed value stays 5.
    int restored = (int)boxed;   // Unboxing: restored is 5.

    What the interviewer checks: The interviewer checks whether you understand copying, heap allocation, casting rules, and boxing costs.

    Other ways it was asked

    • “What are boxing and unboxing in C#?”
    • “What happens when an integer value is passed to a C# method that accepts an object?”
    • “Where is the object allocated when a C# value type is passed as an object?”

14. What is a captive dependency, and what happens when a singleton depends on a scoped service?

    Asked in 3 of 95 interviews · last asked Sep 29 · Concept · Mid-level

    Show answer

    A captive dependency happens when a longer-lived service holds a shorter-lived service beyond its intended lifetime. In .NET’s built-in container, injecting a scoped service into a singleton fails when scope validation is enabled. Without validation, the scoped instance effectively lives as long as the singleton. This can cause shared state, unsafe concurrent access, and delayed disposal.

    • Scoped services normally belong to one scope, such as an HTTP request.
    • Prefer changing service lifetimes so the singleton does not depend on a scoped service.
    • If needed, inject IServiceScopeFactory, create a scope per operation, resolve the service there, and dispose the scope.
    • Do not keep the scoped service after its scope ends.

    What the interviewer checks: The interviewer checks whether you understand service lifetimes, scope validation, and safe scoped-service use from singletons.

    Other ways it was asked

    • “What is a captive dependency in .NET dependency injection, and why can it cause problems?”
    • “What is a captive dependency in dependency injection?”
    • “What happens if a scoped service is injected into a singleton in ASP.NET Core?”

15. How do tasks and threads differ in .NET, and when would you choose each?

    Asked in 3 of 95 interviews · last asked Oct 5 · Concept · Mid-level

    Show answer

    A Task represents an operation and its completion; a Thread is an execution resource. A task does not need its own thread, especially during asynchronous I/O. Choose tasks for most concurrent work because they support await, results, and error handling. Choose a Thread when you need a dedicated thread or control over its priority or apartment state.

    • Task.Run normally runs CPU work on a thread pool thread.
    • Use asynchronous I/O APIs directly; wrapping them in Task.Run is usually unnecessary.
    • A task may complete without ever running on a separate thread.
    • Dedicated threads require more manual management and consume resources even when blocked.

    What the interviewer checks: The interviewer checks whether you distinguish operations from execution resources and choose the right tool for the work.

    Other ways it was asked

    • “What is the difference between a Task and a Thread in .NET?”
    • “What is the difference between a thread and a task in .NET?”
    • “Can you use a thread instead of a task in C#, and why or why not?”

16. What is Task.Run and how is it different from async/await?

    Asked in 3 of 95 interviews · last asked Oct 1 · Concept · Mid-level

    Show answer

    Task.Run queues work on the thread pool and returns a Task. async and await let a method wait for a task without blocking the calling thread; they do not automatically move work to another thread. Use Task.Run for CPU-heavy work to keep a UI responsive. For network calls, await the asynchronous API directly.

    • Synchronous execution keeps the calling thread busy or blocked until the operation finishes.
    • Task.Run moves work to a thread-pool thread; it does not make that work inherently faster.
    • True asynchronous I/O does not need a thread blocked while waiting for the operation.
    • Wrapping synchronous I/O in Task.Run still blocks a thread-pool thread.

    What the interviewer checks: The interviewer checks whether you can separate thread-pool execution from asynchronous waiting and choose correctly for CPU or I/O work.

    Other ways it was asked

    • “When would you use Task.Run, and when would you use async and await directly? What is the key difference, particularly for an I/O-bound operation such as a network call?”
    • “What is the difference between Task.Run and standard synchronous execution in .NET?”

17. What happens behind the scenes when you await an operation in C#?

    Asked in 3 of 95 interviews · last asked Sep 1 · Concept · Senior

    Show answer

    The compiler turns an async method into a state machine. At each await, it checks whether the operation is complete. If not, it saves the method's state, registers a continuation, and returns control to the caller without blocking the thread. When the operation completes, the method resumes and gets the result or throws the exception.

    • An already completed operation continues synchronously, without suspending the method.
    • Await does not create a thread or automatically move work to another thread.
    • Await normally captures a synchronization context when present; ASP.NET Core has none by default.
    • Async I/O frees threads while waiting, helping servers handle more concurrent requests.

    What the interviewer checks: The interviewer checks whether you understand suspension, continuations, and why asynchronous waiting does not require a blocked thread.

    Other ways it was asked

    • “What happens internally when you use `await` in C#, and why is it useful?”
    • “What happens behind the scenes when you use async and await in ASP.NET Core?”
    • “What happens under the hood when you write `await` in C#?”

18. What are action filters in ASP.NET Core, and when would you use them?

    Asked in 3 of 95 interviews · last asked Oct 9 · Concept · Mid-level

    Show answer

    Action filters in ASP.NET Core MVC run code before and after a controller action executes. Use them for shared logic, such as logging action inputs or checking arguments, on selected actions, controllers, or globally. Use an exception filter instead to handle unhandled exceptions from controller creation, model binding, action filters, or actions.

    • Action filters run after model binding, so they can inspect bound action arguments.
    • They can skip the action by setting a result before it runs.
    • Use authorization policies for access control, rather than action filters.
    • Exception filters do not catch exceptions from middleware or MVC result execution.

    What the interviewer checks: The interviewer checks whether you can choose the right filter and explain its scope and execution timing.

    Other ways it was asked

    • “What .NET feature, such as an action filter, can apply request filtering at the method or controller level?”
    • “What is a filter in ASP.NET Core MVC, and can you give a concrete example of when you would use an action filter versus an exception filter?”

19. Can you explain the difference between authentication and authorization in ASP.NET Core, and how JWT tokens fit into this picture?

    Asked in 3 of 95 interviews · last asked Aug 15 · Concept · Mid-level

    Show answer

    Authentication checks who the caller is. Authorization checks what that caller may access. With JWT bearer authentication, the client sends a token in the Authorization header using the Bearer scheme. ASP.NET Core's JWT bearer handler validates the token and creates a claims-based identity; authorization then checks that identity against the endpoint's access rules.

    • Token validation checks the signature, issuer, audience, and expiration against configured requirements.
    • Authorization can require an authenticated user, specific roles, or policies based on claims.
    • Authentication middleware must run before authorization middleware.
    • Protected endpoints normally return 401 for missing or invalid authentication, and 403 when an authenticated caller lacks permission.

    What the interviewer checks: The interviewer checks whether you understand token validation, identity creation, and permission checks as separate steps.

    Other ways it was asked

    • “How does JWT Bearer Token authentication work in ASP.NET Core? What happens when a request arrives with a JWT in the authorization header?”
    • “What is the difference between authentication and authorization in the context of an ASP.NET Core Web API?”

20. How can multiple programming languages run on the same .NET platform despite having different syntax?

    Asked in 2 of 95 interviews · last asked Aug 27 · Concept · Junior

    Show answer

    Each .NET language has a compiler that turns its source code into Common Intermediate Language (CIL) and metadata. The Common Language Runtime (CLR) runs this shared format, usually compiling CIL into machine code with a JIT compiler. Shared type rules let code written in different languages work together.

    • Language compilers handle syntax differences before the code reaches the runtime.
    • The Common Type System (CTS) defines shared types and their rules.
    • The Common Language Specification (CLS) defines rules for APIs that work across .NET languages.

    What the interviewer checks: The interviewer checks whether you understand how compilers, CIL, and the CLR support different .NET languages.

    Other ways it was asked

    • “How can different programming languages run on .NET even though they have different syntax?”

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• Data Engineer interview questions
• DevOps Engineer interview questions
• Machine Learning Engineer interview questions
• Python interview questions
• Java interview questions
• JavaScript interview questions
• TypeScript interview questions
• C++ interview questions
• PHP and Laravel interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every C# and .NET interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

95 interviews, 54 candidates, Jan 2026 to Oct 2026. Updated every month with new interviews.