Introduction
.NET Technical Interview Preparation is not only about understanding of the core concepts but also the knowledge of changes that occur in architecture. In view of the fact that the ecosystem has moved toward cross-platforms, microservices, and cloud-based solutions, employers search for candidates able to write elegant and efficient code with high-throughput performance.
This comprehensive guide combines the most necessary .NET interview questions and answers, starting from C# syntax to enterprise architecture patterns. Do you want to speed up the process of your preparation and get production-ready skills? You should download our DOT NET Course Syllabus here.
Dot Net Interview Questions and Answers for Freshers
1. How does .NET work?
.NET is a free and open-source cross-platform developer platform created by Microsoft. The code in languages like C# is compiled into the Intermediate Language (IL). After that, the Just-In-Time (JIT) compiler converts this IL to machine code.
2. Describe the differences between .NET Framework and .NET Core.
.NET Framework is a platform that allows building desktop and web applications and works only on Windows. .NET Core (and .NET 5+ versions) is an open-source cross-platform rewrite of the .NET Framework.
3. Explain the concept of Common Language Runtime (CLR).
Common Language Runtime is a part of .NET, which includes a virtual machine and controls the process of application execution. Some functions include JIT compilation, memory management, exception handling, security, and thread control.
4. Describe the Garbage Collection in .NET.
Garbage Collection is a mechanism of automatic memory management in .NET. The process of garbage collection is executed periodically in the background and tracks all allocations to automatically release the managed memory occupied by objects that are no longer used by the application.
5. How does a Value Type differ from a Reference Type?
Value types (int, bool, struct, etc.) store data elements within themselves and keep them directly on the stack. Reference types (string, class, array, etc.) only store pointers within themselves, but keep data elements on the heap.
6. How does Boxing differ from Unboxing?
Boxing refers to the implicit conversion of value types to the reference type (object). Unboxing refers to the explicit conversion of that reference type to a value type. Boxing comes at a cost of heap memory.
7. Define the difference between an abstract class and an interface.
An abstract class contains both the implementations of methods as well as abstract methods and allows Single Inheritance only. Interface only consists of the contract i.e. signatures of methods, and allows Multiple Implementations in one class.
8. What is the use of using statement in C#?
The using statement defines a scope where an object is utilized. Once execution exits that scope, it automatically calls the object’s Dispose() method, ensuring unmanaged resources like files or database connections are cleared.
9. What are Extension Methods in C#?
Extension methods provide a way of adding methods to a class without creating a subclass or changing the class definition. They are created as static methods within static classes that use the “this” keyword.
10. How does the String differ from StringBuilder?
Strings are immutable; thus, any changes made to the string will create a whole new string object in memory, which consumes lots of memory space. StringBuilder allows you to make changes to the string right where the string exists in the memory.
Begin your learning journey with our dot net tutorial for beginners.
11. What is ASP.NET Core?
ASP.NET Core is an open-source, high-performance, cross-platform framework under modern .NET. It is optimized for building cloud-connected, modern web applications, web APIs, and mobile backends using minimal configuration.
12. What is Dependency Injection (DI) in ASP.NET Core?
Dependency Injection is a built-in design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. It allows dependencies to be registered with the runtime and automatically injected into classes when needed.
13. What is Entity Framework Core (EF Core)?
Entity Framework Core (EF Core) is an open-source, lightweight, cross-platform Object-Relational Mapper (ORM) in .NET. This framework allows developers to interact with databases through C# objects without writing much of data access SQL code.
14. Explain the difference between eager loading and lazy loading in EF Core.
Eager loading involves retrieving related records from the database through Include() during the first query execution. On the other hand, lazy loading is delayed until you request it through accessing the navigation property.
15. What is LINQ in .NET?
Language Integrated Query (LINQ) is a language feature in .NET providing a universal mechanism for querying and manipulating data from different data sources (collections, XML documents, SQL databases, etc.) using C# code.
Dot Net Interview Questions and Answers for Experienced Candidates
1. How does the .NET Garbage Collector manage Large Object Heap (LOH) fragmentation, and what approaches can be used to solve this issue?
Large Object Heap (LOH), that is, objects bigger than 85,000 bytes, is not compacted automatically by the Garbage Collector because of huge CPU consumption during relocation of large memory chunks. This results in memory fragmentation.
There are several ways to deal with this problem, either configuring the Garbage Collector to compact LOH manually or using common architectural solutions:
// Programmatically force LOH compaction during the next full GC
GCSettings.LargeObjectHeapCompactionMode = GCLOHCompactionMode.CompactOnce;
GC.Collect();
Additionally, you may recycle memory pools with the help of ArrayPool<T> or use PinnedObjectHeap allocation in case of long-living native interops.
2. Explain the architectural mechanics of Span<T> and ReadOnlySpan<T>. How do they achieve zero-allocation memory safety?
Span<T> is a stack-allocated ref struct that represents a contiguous region of arbitrary memory (managed heap, stack, or native heap). Because it is restricted to the stack, it prevents managed pointers from escaping to the heap, bypassing GC tracking entirely.
// Slice a string without creating a new string object on the heap
string payload = “HTTP/1.1 200 OK”;
ReadOnlySpan<char> statusSpan = payload.AsSpan(9, 3); // “200”
This data structure holds a managed pointer (ref T) together with its length, providing efficient slicing functionality without any overhead of memory allocation on big strings or byte arrays.
3. What is Native AOT (Ahead-of-Time) compilation, and how does it affect the way assemblies are executed and dependency injection works?
Native AOT directly converts .NET applications into machine code according to a specific architecture. This process eliminates any need for a JIT compiler and a runtime IL interpreter.
- Startup: Instantaneous start-up and minimal memory consumption.
- Architecture: Reflection at runtime and dynamic code generation (Reflection.Emit) are not used anymore.
- Dependency Injection: Classic dependency injection containers built upon runtime reflection must be replaced by source-level DI.
4. Compare the performance characteristics, allocation overhead, and use cases of Task versus ValueTask.
Choosing between async abstractions directly dictates memory pressure on high-throughput services.
| Feature | Task | ValueTask |
| Type | Reference Type (Heap allocated) | Value Type (Stack allocated) |
| Allocation Overhead | Always allocates an object on the heap per asynchronous call. | Zero allocation if the operation completes synchronously. |
| Primary Use Case | Operations guaranteed to be asynchronous (e.g., Network I/O). | Operations that frequently complete synchronously (e.g., Cached I/O). |
5. How do you implement a high-throughput, non-blocking Producer-Consumer pipeline in modern .NET?
For low-allocation, high-performance queues, avoid BlockingCollection<T> as it relies on heavy locking primitives. Instead, use System.Threading.Channels, which provide highly efficient async read/write loops.
// Instantiate a bounded channel to prevent memory blowing up under load
var channel = Channel.CreateBounded<OrderDto>(new BoundedChannelOptions(1000) {
FullMode = BoundedChannelFullMode.Wait,
SingleWriter = true, // Optimizes internal synchronization locks
SingleReader = false
});
// Writing asynchronously
await channel.Writer.WriteAsync(new OrderDto());
Explore the Dot Net Salary for Freshers and Experienced Candidates.
6. Discuss the difference between the behavior of AsyncLocal and ThreadLocal within the highly concurrent Web API.
- ThreadLocal<T> is bound to a particular thread of execution. Asynchronous execution can switch threads from the thread pool boundaries once it hits await; hence, ThreadLocal<T> becomes unusable between those blocks.
- AsyncLocal<T>, on the other hand, retains data through the asynchronous call execution sequence (ExecutionContext). The ambient state propagates down with the async callback chain and is the right type to use for distributed tracing IDs and tenant contexts.
7. Describe how to structure an explicit Clean Architecture project structure, as well as how to address cross-cutting concerns between layers.
In Clean Architecture, there is a very strict boundary of dependency between layers where the core domain has zero dependencies.
├── 1. Domain (Entities, Enums, Domain Exceptions)
├── 2. Application (Use Cases, Interfaces, MediatR Handlers) ──> Depends on Domain
├── 3. Infrastructure (EF Core, Repositories, Identity, API Clients) ──> Depends on Application
└── 4. WebUI / Presentation (Minimal APIs, Controllers) ──> Depends on Infrastructure & Application
Logging and other cross-cutting concerns are implemented using MediatR Pipeline Behaviors in the Application layer, making it possible to completely abstract all infrastructural code from core logic.
8. Discuss possible solutions to perform transactions across different independent microservices in a .NET Enterprise environment.
As two-phase commit protocol (2PC) locks the database and performs badly in distributed systems, microservices use event-driven architecture pattern to handle transactions:
- Saga Pattern (Orchestration): There is a centralized coordination microservice that explicitly orders each downstream microservice to carry out its transaction through a messaging queue (MassTransit, for example).
- Saga Pattern (Choreography): The microservices listen to the events and carry out their transactional step independently.
- Compensation Transaction: In case Step 3 in the multistep workflow fails, the system broadcasts a compensation event backwards to carry out opposite actions (money refund, for example).
9. What are the performance considerations for API controllers vs. minimal APIs in modern ASP.NET Core applications?
Minimal APIs have been built to eliminate the architectural baggage associated with the conventional routing engine.
| Attribute | API Controllers | Minimal APIs |
| Reflection Overhead | High (Scans assembly, binds models via controller descriptors). | Low (Uses source generators to map endpoints at compile time). |
| Startup Latency | Slower due to controller route tree mapping. | Faster; ideal for native cloud architectures. |
| Throughput (RPS) | Slightly lower due to allocation per request. | Higher throughput, optimal for microservices. |
10. What is the procedure used to troubleshoot an N+1 Query Problem or Cartesian Explosion when using a LINQ query in EF Core?
The N+1 problem happens when a query retrieves a parent entity and iteratively queries the database for each individual child entity. The solution is to enforce eager loading by adding “.Include()”.
When a query includes more than one collection navigation in a single step, a Cartesian Explosion happens (data that is a duplicate cross product being sent across the network). In this case, you need to:
// Mitigate Cartesian explosion by separating database queries safely
var orders = await _context.Customers
.Include(c => c.Orders)
.Include(c => c.Invoices)
.AsSplitQuery() // Tells EF Core to execute distinct, optimized SQL calls
.ToListAsync();
11. What are Compiled Queries in Entity Framework Core, and what is their appropriate application?
Executing regular LINQ queries forces EF Core to analyze the expression tree and generate the raw SQL each and every time that it is executed. For fast-executing queries where parameters don’t change, the following approach can be utilized to achieve raw ADO.NET performance:
private static readonly Func<MyDbContext, int, Task<Customer>> GetCustomerQuery =
EF.CompileAsyncQuery((MyDbContext ctx, int id) =>
ctx.Customers.FirstOrDefault(c => c.Id == id));
// Execution invocation
var customer = await GetCustomerQuery(_context, 42);
12. Describe DBContext pooling. What makes it perform optimally in multi-tenancy scenarios?
The process of creating an instance of DbContext involves the creation of the tracking states, configuration blocks, and connection hooks, which results in lots of allocations. AddDbContextPool<T> allows reusing context instances in an internal queue.
Whenever there is a request, the pool will return a pre-warmed instance. In cases of multi-tenant databases, where the connection strings are dynamic, there is a need to reset or replace the tenant identifier parameter while checking out (OnConfiguring).
13. How can you ensure a safe JWT authentication framework that prevents token stealing but remains scalable?
The secure method for ensuring stateless JWTs is by using short-lived access tokens along with sliding window, database-based refresh tokens:
public class RefreshToken {
public string Token { get; set; } = Convert.ToBase64String(RandomNumberGenerator.GetBytes(64));
public DateTime ExpiresAt { get; set; }
public bool IsRevoked { get; set; }
public string ReplacedByToken { get; set; } // Tracks token reuse chains
}
In case of submission of an invalid or expired refresh token, the system recognizes it as a reused token and revokes the whole family tree below that point.
14. Explain how one can troubleshoot and diagnose a slow-running .NET application in a Docker container with CLI diagnostic tools.
In case of debugging an active container, without being able to use Visual Studio, .NET dotnet-tools can be directly attached to the container process:
- dotnet-counters monitor: Examines CPU spikes, GC allocations and ThreadPool starvation.
- dotnet-dump collect: Creates a memory dump of the runtime.
- dotnet-gcdump collect: Creates an object graph to examine the root object leaks without suspending threads.
- dotnet-trace collect: Examines slow methods and sample call stacks in an actively running program.
15. Describe the main optimization changes in C# 14 and .NET runtimes.
Most recent additions concentrate on reducing nanoseconds in commonly used operations by the use of compiler optimizations:
- Fields Backed Properties: Simplifies properties access by making a contextual field available, thus, no need for backing-field boilerplate anymore.
- Object Stack Allocation: JIT is very sophisticated in analyzing escapes; in case an object is not escaped from its method scope, it gets allocated straight to the stack, relieving the GC.
- Struct Passing Optimization: Large structures, when passed into methods, will be optimized for passing like reference types.
Recommended: Dot Net Course in Chennai.
Conclusion
Passing a technical interview for a .NET developer requires you to show proficiency in designing a scalable and contemporary cloud-native architecture with a reduced memory footprint. As enterprises shift quickly towards cross-platform applications, highlighting your knowledge in runtime optimization, memory management with Span<T>, and performance tuning will help you stand out among other applicants.
Are you looking forward to developing your professional skills? SLA Institute, the best IT training institute in Chennai, provides .NET and core C# certification courses along with a 100% job guarantee. Join us now and learn Clean Architecture and microservices through practical projects!