C# and .NET Core Interview Questions (2026 Master Guide)

Q1. What is .NET Core and how does it differ from traditional .NET Framework?

Foundation • 0-2 Yrs

.NET Framework was Windows-only, tightly coupled to IIS and the Windows OS. .NET Core (and modern unified .NET 6/7/8/9) is cross-platform (runs natively on Linux, macOS, Windows, Docker), modular, open-source, features high performance (Kestrel web server), and supports side-by-side version deployments.

Q2. What is the Common Language Runtime (CLR) and Common Type System (CTS)?

Foundation • 0-2 Yrs

The CLR is the virtual machine execution engine of .NET that compiles Intermediate Language (IL) code into native machine code using Just-In-Time (JIT) compilation, managing memory, thread execution, and security. CTS defines the standard data types and rules supported across all .NET languages.

Q3. Explain the difference between Value Types and Reference Types in C#.

Foundation • 0-2 Yrs

Value Types (structs, primitives: int, float, bool, char, enum) store their data directly in memory (typically allocated on the Stack) and are copied by value. Reference Types (classes, strings, arrays, delegates, interfaces) store a memory address pointer pointing to heap-allocated objects.

Q4. What is Boxing and Unboxing in C# and what is its performance impact?

Foundation • 0-2 Yrs

Boxing: Converting a value type to a reference type (object or interface) by allocating an object on the heap and copying the value into it. Unboxing: Explicitly extracting the value type from the object reference back to the stack. Excessive boxing causes high heap allocations and GC overhead.

Q5. What is the difference between string and StringBuilder in C#?

Foundation • 0-2 Yrs

string is immutable; any modification (concatenation) allocates a new string object on the heap. StringBuilder (in System.Text) is mutable, maintaining an internal character buffer that expands dynamically, delivering superior performance for high-volume string concatenation.

Q6. Explain the difference between 'ref', 'out', and 'in' parameter modifiers.

Foundation • 0-2 Yrs

'ref': Variable must be initialized before passing; allows method to read and modify original value. 'out': Variable does not need prior initialization; method MUST assign a value before returning. 'in' (introduced in C# 7.2): Passes variable by reference for performance but enforces read-only immutability.

Q7. What are Generics in C# and why are they preferred over ArrayList?

Foundation • 0-2 Yrs

Generics (List, Dictionary) allow defining type-safe classes, interfaces, and methods with deferred type parameters. They eliminate the high performance penalty of boxing/unboxing and catch type mismatches at compile-time rather than runtime.

Q8. What is the difference between an Abstract Class and an Interface in C#?

Foundation • 0-2 Yrs

Abstract Class: Can contain instance fields, constructors, and concrete method implementations, and supports single inheritance. Interface: Pure contract defining method signatures without instance state (supports default implementations in C# 8+), and a class can implement multiple interfaces.

Q9. What is LINQ (Language Integrated Query) and what are its two syntaxes?

Foundation • 0-2 Yrs

LINQ provides native, type-safe data querying capabilities inside C# across collections, databases (EF Core), and XML. Syntaxes: Query Syntax (SQL-like: from x in list where x > 5 select x) and Method/Fluent Syntax (lambda expressions: list.Where(x => x > 5).Select(x => x)).

Q10. What is the difference between IEnumerable and IQueryable in LINQ?

Foundation • 0-2 Yrs

IEnumerable (in System.Collections): Executes in-memory (client-side evaluation); pulling data from DB brings all records into memory before filtering. IQueryable (in System.Linq): Builds an Expression Tree translated into native SQL queries executed on the database server, returning only filtered rows.

Q11. Explain Dependency Injection lifetimes in ASP.NET Core (Transient vs Scoped vs Singleton).

Foundation • 0-2 Yrs

Transient (AddTransient): New instance created every time requested. Scoped (AddScoped): New instance created once per client HTTP request cycle (standard for DbContext). Singleton (AddSingleton): Exactly one instance created on initial request and shared across all requests for the application lifetime.

Q12. What is Middleware in ASP.NET Core and how does the pipeline work?

Foundation • 0-2 Yrs

Middleware consists of software components assembled into an application pipeline to handle HTTP requests and responses. Each component can inspect the request, invoke the next middleware via next(), and execute logic on the return response path (e.g., Exception Handling, Routing, Authentication, Static Files).

Q13. What is the 'async' and 'await' pattern in C# and how does it prevent thread blocking?

Foundation • 0-2 Yrs

async/await enables non-blocking asynchronous programming. When execution hits 'await' on an I/O-bound task, the current thread is immediately released back to the thread pool to serve other requests; when the async operation finishes, a thread pool worker resumes execution from the continuation point.

Q14. What is the purpose of the 'using' statement and the IDisposable interface?

Foundation • 0-2 Yrs

The 'using' statement guarantees deterministic disposal of unmanaged resources (database connections, file handles). It ensures that the object's Dispose() method is invoked immediately upon exiting the scope, even if an unhandled exception occurs (syntactic sugar for try-finally).

Q15. What are Nullable Value Types and the Null-Coalescing operator (??)?

Foundation • 0-2 Yrs

Value types cannot normally hold null. Appending '?' (e.g., int?) allows value types to store null. The null-coalescing operator 'a ?? b' evaluates to 'a' if 'a' is not null; otherwise, it returns fallback value 'b'. The '??=' operator assigns only if the left-hand variable is null.

Q16. Explain how the .NET Garbage Collector manages generations (Gen 0, Gen 1, Gen 2, LOH).

Experienced • 3-5+ Yrs

The GC optimizes memory using 3 generations: Gen 0 (holds newly allocated short-lived objects, collected frequently in milliseconds); Gen 1 (serves as a buffer for surviving objects); Gen 2 (holds long-lived objects). Large Object Heap (LOH) holds objects > 85,000 bytes (allocated directly to Gen 2, not compacted by default).

Q17. What is Entity Framework Core and how does AsNoTracking() improve query performance?

Experienced • 3-5+ Yrs

EF Core is an ORM that maps database tables to C# entities. By default, the DbContext change tracker tracks all queried entities in memory to detect updates. Adding .AsNoTracking() instructs EF Core to skip tracking overhead, significantly accelerating read-only query performance and reducing memory usage.

Q18. How do you resolve the N+1 Query problem in Entity Framework Core?

Experienced • 3-5+ Yrs

The N+1 problem occurs when a query fetches parent records, and subsequent access to a related child collection triggers N separate SQL queries inside a loop. Resolve via Eager Loading using .Include() and .ThenInclude(), which generates a single SQL JOIN query.

Q19. Explain C# Records, 'with' expressions, and Value Equality.

Experienced • 3-5+ Yrs

Records (C# 9+) are reference types designed for immutable data models. Unlike standard classes that use reference identity equality, Records implement value-based equality automatically (two records with identical properties are equal). The 'with' expression enables non-destructive mutation by copying a record with specified modifications.

Q20. What is Span<T> and Memory<T> in modern high-performance .NET?

Experienced • 3-5+ Yrs

Span is a stack-allocated ref struct representing a contiguous region of arbitrary memory (managed heap, stack, or native unmanaged memory). It enables zero-allocation memory slicing without creating duplicate substring or sub-array copies, drastically reducing GC pressure.

Q21. Explain the difference between Task.Run and async/await for CPU-bound vs I/O-bound operations.

Experienced • 3-5+ Yrs

I/O-bound work (HTTP calls, DB queries) should use true async/await without Task.Run, freeing OS threads without consuming thread pool resources. CPU-bound work (heavy mathematical calculations, image processing) uses Task.Run to offload computation to a background thread pool worker.

Q22. What are Filters in ASP.NET Core and what are their execution phases?

Experienced • 3-5+ Yrs

Filters run within the ASP.NET Core action invocation pipeline. Execution order: 1. Authorization Filters (verifies permissions) -> 2. Resource Filters -> 3. Action Filters (runs before/after action execution) -> 4. Exception Filters (handles unhandled exceptions) -> 5. Result Filters (runs before/after action result).

Q23. How does Configuration and Options Pattern work in ASP.NET Core?

Experienced • 3-5+ Yrs

The Options Pattern uses strongly typed classes to represent groups of related configuration settings from appsettings.json. Registered via services.Configure(Configuration.GetSection('MySettings')), injected into classes via IOptions, IOptionsSnapshot (reloaded per request), or IOptionsMonitor (real-time updates).

Q24. Explain Deadlocks in async C# when calling .Result or .Wait().

Experienced • 3-5+ Yrs

Calling .Result or .Wait() synchronously blocks the calling thread while waiting for an asynchronous task to complete. In single-threaded synchronization contexts (legacy ASP.NET / WPF), this causes a Deadlock: the continuation task cannot execute because the main thread is blocked waiting for it. Avoid by using await all the way up.

Q25. What is Minimal APIs in ASP.NET Core and how does it compare to Controllers?

Experienced • 3-5+ Yrs

Minimal APIs (introduced in .NET 6) allow building lightweight HTTP microservices with minimal dependencies and zero controller boilerplate: app.MapGet('/users', () => ...). They deliver higher throughput and faster startup times, ideal for microservices and serverless functions.

Q26. How do you implement Structured Logging in .NET Core using Serilog?

Experienced • 3-5+ Yrs

Serilog captures logs as structured JSON objects containing message templates with named properties (e.g., Log.Information('Processed order {OrderId} for customer {CustomerId}', orderId, customerId)), enabling rich querying and filtering in Elasticsearch or Seq.

Q27. What is the difference between AddDbContext and AddDbContextPool in EF Core?

Experienced • 3-5+ Yrs

AddDbContext instantiates a new DbContext instance for every HTTP request. AddDbContextPool maintains an internal pool of pre-allocated DbContext instances, recycling them across requests to eliminate the initialization overhead of service providers, improving throughput by up to 20%.

Q28. Explain Pattern Matching enhancements in modern C# (switch expressions, property patterns).

Experienced • 3-5+ Yrs

C# 8+ switch expressions provide concise functional syntax: expr switch { Pattern1 => result1, Pattern2 => result2, _ => default }. Supports Property Patterns ({ Status: 'Active', Age: >= 18 }), Positional Patterns, and Relational Patterns (<, >=).

Q29. How do you manage Secrets in .NET Core across Development and Production?

Experienced • 3-5+ Yrs

Development: Use Secret Manager tool (dotnet user-secrets) storing keys outside the project directory. Production: Inject secrets via Environment Variables, Azure Key Vault, or AWS Secrets Manager, never committing plain credentials to Git.

Q30. What is Native AOT (Ahead-of-Time) compilation in .NET 8/9?

Experienced • 3-5+ Yrs

Native AOT compiles .NET code directly into an architecture-specific native machine code binary at publish time, bypassing JIT compilation. It delivers instant startup times (milliseconds), minimal memory footprints, and smaller container sizes, ideal for serverless cloud containers.

Q31. Write an ASP.NET Core Minimal API endpoint with dependency injection and DTO validation.

Live Coding Challenge

Map a POST endpoint using MapPost with injected service.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<IOrderService, OrderService>();
var app = builder.Build();

app.MapPost("/api/orders", async (OrderDto dto, IOrderService service) => {
    if (string.IsNullOrEmpty(dto.CustomerEmail)) return Results.BadRequest("Email required");
    var orderId = await service.CreateOrderAsync(dto);
    return Results.Created($"/api/orders/{orderId}", new { Id = orderId });
});

app.Run();

Q32. Write a C# method demonstrating async/await with CancellationToken and timeout.

Live Coding Challenge

Pass CancellationToken to HttpClient.GetAsync.

public async Task<string> FetchDataAsync(string url, CancellationToken ct)
{
    using var client = new HttpClient();
    using var response = await client.GetAsync(url, ct);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync(ct);
}

Q33. Write an EF Core query using AsNoTracking and Include to prevent N+1 queries.

Live Coding Challenge

Query orders including items with no tracking.

public async Task<List<Order>> GetOrdersWithItemsAsync(AppDbContext context, int customerId)
{
    return await context.Orders
        .AsNoTracking()
        .Where(o => o.CustomerId == customerId)
        .Include(o => o.OrderItems)
        .ToListAsync();
}

Q34. Implement a thread-safe Singleton in C# using Lazy<T>.

Live Coding Challenge

Using System.Lazy provides thread-safe, lazy initialization with zero locking overhead.

public sealed class Singleton
{
    private static readonly Lazy<Singleton> _instance = 
        new Lazy<Singleton>(() => new Singleton());

    private Singleton() { }
    public static Singleton Instance => _instance.Value;
}

Q35. Write a C# custom Middleware class to log HTTP request execution time.

Live Coding Challenge

Using Stopwatch inside InvokeAsync.

public class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    public RequestTimingMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        await _next(context);
        sw.Stop();
        Console.WriteLine($"Request {context.Request.Path} executed in {sw.ElapsedMilliseconds}ms");
    }
}

Q36. Write a LINQ query to group employees by department and select highest salary in each.

Live Coding Challenge

Group by department and find max salary.

var topSalaries = employees
    .GroupBy(e => e.Department)
    .Select(g => new {
        Department = g.Key,
        TopSalary = g.Max(e => e.Salary)
    })
    .ToList();

Q37. Write an IDisposable implementation in C# following the standard Dispose pattern.

Live Coding Challenge

Implement Dispose(bool) with GC.SuppressFinalize.

public class ResourceManager : IDisposable
{
    private bool _disposed = false;
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing) { /* Clean managed resources */ }
            _disposed = true;
        }
    }
}

Q38. Write a C# record with positional parameters demonstrating non-destructive mutation ('with').

Live Coding Challenge

Define record Person and create updated clone.

public record Person(string FirstName, string LastName, int Age);

// Usage
var p1 = new Person("Arjun", "Sharma", 28);
var p2 = p1 with { Age = 29 };

Q39. Write a switch expression in C# calculating discount percentage based on customer tier.

Live Coding Challenge

Using modern switch expression with pattern matching.

public decimal GetDiscount(string tier, decimal orderTotal) => (tier, orderTotal) switch
{
    ("Platinum", _) => 0.20m,
    ("Gold", > 1000) => 0.15m,
    ("Gold", _) => 0.10m,
    ("Silver", _) => 0.05m,
    _ => 0.0m
};

Q40. Write an Entity Framework Core DbContext class configuring a one-to-many relationship.

Live Coding Challenge

Using Fluent API in OnModelCreating.

public class AppDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder mb)
    {
        mb.Entity<Blog>()
            .HasMany(b => b.Posts)
            .WithOne(p => p.Blog)
            .HasForeignKey(p => p.BlogId)
            .OnDelete(DeleteBehavior.Cascade);
    }
}