# Top 20 Advanced .NET Core Interview Questions and Answers **F**or seasoned developers looking to showcase their advanced skills in .NET Core, this article compiles 20 in-depth interview questions and answers. Covering topics like custom middleware, gRPC, async streams, and performance optimization, this guide is tailored to help you demonstrate your expertise and tackle challenging technical interviews with confidence. 1. **What is the purpose of the** `IHostedService` interface in .NET Core, and how do you implement a background service using it? **Answer:** The `IHostedService` interface is used to create long-running background services in .NET Core applications. **Explanation:** Implementing `IHostedService` allows you to run background tasks within a hosted environment. You need to implement the `StartAsync` and `StopAsync` methods. To register the service, you add it in `ConfigureServices` using `services.AddHostedService()`. This is useful for tasks like polling, consuming messages, or scheduled jobs without blocking the main thread. 2. **Explain the difference between** `app.Use`, `app.UseMiddleware`, and [`app.Run`](http://app.Run) methods in the [ASP.NET](http://ASP.NET) Core middleware pipeline. **Answer:** * `app.Use`: Adds middleware that can process requests and pass them to the next component. * `app.UseMiddleware`: Injects custom middleware into the pipeline via a middleware class. * [`app.Run`](http://app.Run): Adds terminal middleware that processes requests without calling the next component. **Explanation:** * `app.Use` is for middleware that needs to perform actions both before and after the next middleware. * `app.UseMiddleware` is a generic method to add custom middleware classes. * [`app.Run`](http://app.Run) is used when no further middleware should handle the request, effectively ending the pipeline. 3. **What are Async Streams in C#, and how do they differ from regular asynchronous methods?** **Answer:** Async Streams allow asynchronous iteration over a collection using `IAsyncEnumerable` and `await foreach`. **Explanation:** Async Streams enable methods to produce a stream of data asynchronously. Unlike regular async methods that return a single `Task`, async streams can yield multiple values over time, improving responsiveness and resource utilization when working with data sequences. 4. **How do you implement custom middleware in** [**ASP.NET**](http://ASP.NET) **Core?** **Answer:** By creating a class with an `Invoke` or `InvokeAsync` method that accepts an `HttpContext`, and registering it with `app.UseMiddleware()`. **Explanation:** Custom middleware handles HTTP requests and responses. It should accept a `RequestDelegate` in its constructor and use `HttpContext` to access request and response data. Register the middleware in the `Configure` method to integrate it into the pipeline. 5. **What is gRPC, and how is it implemented in .NET Core?** **Answer:** gRPC is a high-performance, open-source RPC framework using Protocol Buffers, implemented in .NET Core with the `Grpc.AspNetCore` package. **Explanation:** gRPC enables efficient communication between services. In .NET Core, you define services and messages in `.proto` files. The tooling generates server and client code. You configure gRPC services in `Startup.cs` and use them for inter-service communication in microservices architectures. 6. **Explain the use of** `Span` and `Memory` in .NET Core. **Answer:** `Span` and `Memory` are types for representing contiguous regions of memory, allowing high-performance, zero-allocation code. **Explanation:** * `Span`: A stack-only type for accessing memory, including arrays and unmanaged memory, without copying. * `Memory`: Similar to `Span`, but can be stored on the heap and used asynchronously. They help in reducing memory allocations and improving performance, especially in applications processing large amounts of data. 7. **What are the differences between** `Task`, `ValueTask`, and `IAsyncEnumerable` in .NET Core? **Answer:** * `Task`: Represents an asynchronous operation returning a single value. * `ValueTask`: A lightweight alternative to `Task` that can avoid heap allocations. * `IAsyncEnumerable`: Represents an asynchronous stream of values. **Explanation:** `ValueTask` improves performance when the result is already available or cached. `IAsyncEnumerable` is used for asynchronous iteration over collections, allowing data to be processed as it's received. 8. **What is the difference between** `ConfigureServices` and `ConfigureContainer` in [ASP.NET](http://ASP.NET) Core? **Answer:** `ConfigureServices` is used to register services with the built-in DI container, while `ConfigureContainer` allows you to integrate a third-party DI container. **Explanation:** If you need features beyond the built-in container, such as property injection or advanced scoping, you can use `ConfigureContainer` to set up an external container like Autofac, providing more control over dependency resolution. 9. **How do you implement Health Checks in** [**ASP.NET**](http://ASP.NET) **Core applications?** **Answer:** By adding health check services with `services.AddHealthChecks()` and mapping health check endpoints using `app.UseEndpoints`. **Explanation:** Health checks monitor the health of application components (e.g., database, external services). They can be exposed via endpoints and integrated with monitoring systems to ensure application reliability. 10. **Explain the concept of dependency injection scopes and how they can affect** [**ASP.NET**](http://ASP.NET) **Core applications.** **Answer:** Dependency injection scopes determine the lifecycle of service instances: Singleton, Scoped, and Transient. **Explanation:** * **Singleton**: One instance for the application's lifetime. * **Scoped**: One instance per request. * **Transient**: A new instance each time it's requested. Misconfigured scopes can lead to issues like unintended shared state or resource leaks, especially when injecting scoped services into singletons. 11. **What is the** `IHttpClientFactory`, and why should you use it in .NET Core? **Answer:** `IHttpClientFactory` manages the creation and configuration of `HttpClient` instances, promoting reuse and avoiding common pitfalls. **Explanation:** It prevents socket exhaustion by managing handler lifetimes, allows named clients with specific configurations, and centralizes HTTP client settings, improving reliability and testability. 12. **How do you implement global exception handling in** [**ASP.NET**](http://ASP.NET) **Core?** **Answer:** By using the `UseExceptionHandler` middleware or writing custom middleware to catch and handle exceptions application-wide. **Explanation:** Global exception handling ensures that unhandled exceptions are caught, logged, and appropriate responses are returned to clients, enhancing security and user experience. 13. **What is SignalR in** [**ASP.NET**](http://ASP.NET) **Core, and how does it facilitate real-time communication?** **Answer:** SignalR is a library for adding real-time web functionality, allowing server-side code to push content to connected clients instantly. **Explanation:** It abstracts underlying transport mechanisms like WebSockets, enabling features like live chat, notifications, and real-time updates with minimal code changes. 14. **Explain how C# 8.0 nullable reference types help prevent null reference exceptions.** **Answer:** Nullable reference types enable the compiler to recognize variables that may be null, enforcing null checks at compile time. **Explanation:** By annotating reference types with `?`, the compiler warns when nullable variables are dereferenced without null checks, reducing runtime exceptions and improving code safety. 15. **What is the role of the** `GCSettings.LatencyMode` property, and when would you adjust it? **Answer:** `GCSettings.LatencyMode` adjusts the garbage collector's behavior to optimize for latency or throughput. **Explanation:** In scenarios requiring minimal interruptions (e.g., real-time applications), setting `LatencyMode` to `LowLatency` reduces GC pauses. However, it may increase memory usage, so it's a trade-off. 16. **How does the .NET Core runtime handle assembly loading and resolving dependencies?** **Answer:** The runtime uses `AssemblyLoadContext` to manage assembly loading, allowing for isolation and dynamic loading of assemblies. **Explanation:** Custom `AssemblyLoadContext` instances enable loading assemblies into separate contexts, useful for plugin systems or applications requiring multiple versions of an assembly without conflicts. 17. **What are** `ref` structs, and why would you use them in .NET Core? **Answer:** `ref` structs are stack-only types that cannot be boxed, ensuring high performance and preventing heap allocations. **Explanation:** Used in performance-critical code, `ref` structs like `Span` avoid the overhead of heap allocation and garbage collection, improving efficiency in scenarios like parsing or buffer manipulation. 18. **Explain how to create a custom** `JsonConverter` with `System.Text.Json` in .NET Core. **Answer:** By deriving from `JsonConverter` and overriding the `Read` and `Write` methods to control serialization behavior. **Explanation:** Custom converters handle complex serialization scenarios, such as polymorphic types or custom formats. They are registered with `JsonSerializerOptions` and enable fine-grained control over JSON processing. 19. **How do you handle versioning in** [**ASP.NET**](http://ASP.NET) **Core Web APIs?** **Answer:** By using API versioning techniques like URL segmenting, query parameters, or headers, often facilitated by the `Microsoft.AspNetCore.Mvc.Versioning` package. **Explanation:** API versioning allows you to introduce changes without breaking existing clients. It supports multiple API versions side by side, ensuring backward compatibility. 20. **What is the** `IOptionsMonitor` interface, and how does it differ from `IOptions`? **Answer:** `IOptionsMonitor` provides access to configuration options and supports change notifications, whereas `IOptions` provides a snapshot of options. **Explanation:** `IOptionsMonitor` is useful when options can change at runtime, as it automatically updates bound objects and allows you to react to changes via callbacks, enhancing application flexibility. --- These advanced .NET Core interview questions and answers offer concise explanations of complex topics, facilitating efficient preparation and a deeper understanding of the framework's capabilities