.NET Full Stack Developer Interview Questions (2025 Ultimate Guide)

1. What is the difference between `async/await` and traditional multithreading? When would you use each?

Answer: "Traditional multithreading is about parallelism—using multiple CPU cores to perform multiple tasks simultaneously. It's CPU-bound. `async/await`, on the other hand, is about concurrency—freeing up the main thread during I/O-bound operations like calling a database or an external API. I would use multithreading for heavy, parallel computations, and `async/await` for any operation involving network latency or file I/O to keep the application responsive without blocking threads."

2. Explain Dependency Injection (DI) in .NET Core. What are the different service lifetimes (`Singleton`, `Scoped`, `Transient`)?

Answer: "Dependency Injection is a design pattern that implements Inversion of Control (IoC), allowing us to decouple our classes. Instead of a class creating its own dependencies, they are 'injected' from an external source, typically a DI container.
• Singleton: One instance is created for the entire application life.
• Scoped: A new instance is created once per client request (e.g., an HTTP request). It's shared within that single request.
• Transient: A new instance is created every time it is requested from the service container."

3. What is Middleware in ASP.NET Core? Can you give an example of the request pipeline?

Answer: "Middleware components are software components that are assembled into an application pipeline to handle requests and responses. Each component can pass the request to the next component or short-circuit the pipeline. A typical request pipeline in `Program.cs` would look like: `app.UseRouting()` to match the request to an endpoint, followed by `app.UseAuthentication()` and `app.UseAuthorization()` to handle security, and finally `app.UseEndpoints()` to execute the endpoint."

4. How do you implement security in a .NET Web API? Mention a few concepts.

Answer: "For security, I'd implement token-based authentication using JWT (JSON Web Tokens). The process involves:
1. A user authenticates with credentials.
2. The server generates a signed JWT containing user claims and sends it back.
3. The client stores this token and includes it in the Authorization header for subsequent requests.
I'd use the `[Authorize]` attribute on controllers or action methods to protect endpoints and configure JWT bearer authentication in the DI container."

5. What is the difference between `IQueryable` and `IEnumerable` in the context of Entity Framework Core?

Answer: "This is about when the query is executed. `IEnumerable` loads the entire collection from the database into memory first, and then applies any filters (like a `Where` clause) in the .NET application. This can be very inefficient. `IQueryable`, on the other hand, builds up an expression tree. It doesn't execute the query until it's enumerated (e.g., with `.ToList()` or in a `foreach` loop). This allows the LINQ provider to translate the entire query into efficient SQL, so the filtering happens on the database server itself, which is much more performant."

6. In Angular, what is the difference between a Component and a Service?

Answer: "A Component is responsible for controlling a patch of the screen—the view. It's a class with a template and is part of the UI. A Service, on the other hand, is a class designed for a specific purpose that is not tied to any particular view, like fetching data from an API or logging. Services are injected into components using Dependency Injection to share logic and data across the application without duplicating code."

7. How would you design a scalable architecture for a high-traffic e-commerce application on Azure?

Answer: "I would design a microservices-based architecture. The front-end would be a Single Page Application (SPA) hosted on Azure Static Web Apps. The back-end would be a set of .NET Web APIs, each representing a microservice (e.g., Product, Order, User service), containerized using Docker and hosted on Azure Kubernetes Service (AKS) for scalability and resilience. For the database, I'd use Azure SQL for relational data and Azure Cosmos DB for cart or catalog data. I'd use an Azure API Management gateway to manage the APIs and Azure Service Bus for asynchronous communication between microservices."