Top 30 .NET Core Interview Questions and Answers for 2027

• By Devraj

• 28th September 2026

Interviewers most often ask about the .NET runtime and garbage collector, async/await, dependency injection lifetimes, middleware order, Entity Framework Core performance, API security, caching, background services, and production debugging. This guide covers 30 of them, each with a short answer, a red flag, and a likely follow-up.

Most interview guides hand you definitions to memorize. Interviewers, however, are rarely impressed by definitions. They want to hear how something works, what goes wrong when it’s misused, and what you would do in production. That is why every question below comes with a level (Junior, Mid or Senior), a red flag answer that costs candidates the job, and a follow-up you should be ready for.

This matters more as the future of IT jobs shifts toward developers who understand systems end to end, not just syntax. Whether you’re a fresher preparing for a first role or a developer moving to a senior position, these questions show what companies actually test in 2027.

If you’re still building your foundation, Skill Hives runs practical IT training course programs, including web development training, for learners in Mohali and Chandigarh. We’ll point to it where it’s relevant, but first, the questions.

Preparing for a .NET or web development role?

Talk to Skill Hives about structured, project-based training and interview preparation.

Q1. What’s the difference between .NET Framework, .NET Core, and modern .NET? Which do you pick in 2027?

.NET Framework is Windows-only and in maintenance mode. .NET Core was the cross-platform rewrite. Since .NET 5, the two lines were unified under the name “.NET.” New projects use current .NET, and .NET 10 is the LTS release (3 years of support). Even-numbered releases are LTS, and odd-numbered ones are STS. Existing projects should be on a supported version, because .NET 8 support ends in November 2026.

Q2. How does a C# program go from source code to running machine code?

The compiler produces IL (intermediate language) and metadata inside an assembly. At runtime the CLR’s JIT compiles IL to machine code per method. Tiered compilation first emits fast, less-optimized code, then recompiles hot methods with heavier optimization. Dynamic PGO (default since .NET 8) uses runtime profiling to optimize further.

Q3. How does the garbage collector work, and how can a managed app still leak memory?

The GC is generational (Gen 0, 1, 2), and objects of 85,000 bytes or more go to the Large Object Heap. Most objects die young, so Gen 0 collections are cheap. Managed apps leak through references that stay reachable:

• Static collections that only grow
• Event handlers that are never unsubscribed
• Captured closures
• Undisposed HttpClients or streams
• Unbounded caches

Server GC vs Workstation GC and container memory limits are also fair game.

Q4. Value types vs reference types: what does “structs live on the stack” get wrong?

Value types are copied on assignment. Reference types share a reference. But a struct field inside a class lives on the heap, and boxing a struct copies it to the heap. The real distinction is copy semantics, not storage location. Use small, immutable structs for data that is short-lived and allocated frequently.
object boxed = 42; // boxing: heap allocation
int n = (int)boxed; // unboxing: type check + copy

Q5. What is Native AOT, and when would you not use it?

Native AOT compiles the app to a native binary at publish time. It gives fast startup, low memory use and no JIT, which suits serverless, CLI tools and containers. The costs are restricted reflection, no runtime code generation, trimming warnings, and the need for source-generated JSON (JsonSerializerContext). ASP.NET Core supports it through Minimal APIs and CreateSlimBuilder, but not full MVC controllers.

Q6. What does async/await actually do? Does it create a thread?

The compiler rewrites the method into a state machine. At an await on incomplete work, the method returns to its caller, and the rest of the method runs later as a continuation. No thread is created, and none is blocked while waiting for I/O. ASP.NET Core has no SynchronizationContext, so ConfigureAwait(false) is not needed in app code (it still matters in libraries used by UI apps).

Q7. Task vs ValueTask, and how do you handle cancellation and parallel calls?

Use ValueTask only when a result is often available synchronously (cache hits). Never await it twice. For concurrent calls, start the tasks and await Task.WhenAll(…), and flow a CancellationToken through every layer. In ASP.NET Core, HttpContext.RequestAborted is bound automatically when you accept a CancellationToken parameter.
app.MapGet(“/report”, async (IReportService s, CancellationToken ct) =>
await s.BuildAsync(ct));

Q8. IEnumerable vs IQueryable, and what is deferred execution?

IEnumerable runs LINQ in memory. IQueryable builds an expression tree that a provider (EF Core) translates to SQL. LINQ queries run only when enumerated (ToList, foreach, First). Calling AsEnumerable() or ToList() too early pulls the whole table into memory, and enumerating the same query twice runs it twice.

Q9. How do IDisposable, IAsyncDisposable, and finalizers fit together?

Dispose releases resources deterministically, and using guarantees the call. IAsyncDisposable covers resources that need async cleanup (await using). Finalizers are a GC-run safety net for unmanaged resources, are costly, and are rarely needed today (prefer SafeHandle). The DI container disposes services it creates, but not instances you create yourself and register.

Q10. Name modern C# features you use regularly and where they help.

• Records and with: immutable DTOs.
• required and init: safer object initialization.
• Primary constructors: less DI boilerplate.
• Collection expressions: [1, 2, 3].
• Nullable reference types: catch nulls at compile time.
• C# 14: the field keyword in properties and extension members.

public class OrderService(IOrderRepo repo, ILogger log) { }

Q11. What happens between CreateBuilder and app.Run()?

Before Build() you register services and configuration on the builder. Build() freezes the DI container. After it you compose the middleware pipeline, and Run() starts Kestrel. Services can’t be registered after Build().

Q12. Why does middleware order matter? Give the correct order.

Each middleware wraps the next. The usual order is: exception handling → HTTPS/HSTS → static files → routing → CORS → authentication → authorization → endpoints. Authentication must precede authorization, and CORS must come before auth so preflight requests succeed. A misordered pipeline gives symptoms like “missing CORS headers” that are really ordering bugs.

Q13. Explain DI lifetimes and the captive dependency problem.

• Transient: new instance per resolve.
• Scoped: one instance per request.
• Singleton: one instance per app.

A singleton that holds a scoped service (like a DbContext) keeps it forever, which causes stale data and thread-safety bugs. Scope validation catches this at startup, but it is on by default only in Development. The fix is IServiceScopeFactory or a factory.

Q14. What are keyed services, and how does multiple-registration resolution work?

Resolving IFoo returns the last registration, and IEnumerable returns all of them. Keyed services (since .NET 8) let you resolve one by key.
services.AddKeyedScoped<IPayment, Stripe>(“stripe”);
public class Checkout([FromKeyedServices(“stripe”)] IPayment p) { }

Q15. IOptions vs IOptionsSnapshot vs IOptionsMonitor, and how do you fail fast on bad config?

• IOptions is a singleton that never reloads.
• IOptionsSnapshot is scoped and reloads per request.
• IOptionsMonitor is a singleton with change notifications, and is the right choice for background services.

Use ValidateDataAnnotations().ValidateOnStart() so the app refuses to boot with invalid config.

Q16. Minimal APIs vs controllers: how do you choose in 2027?

Minimal APIs give less ceremony, faster startup, Native AOT support, endpoint filters and (since .NET 10) built-in validation via AddValidation(). Controllers give conventions, mature filters, and model-binding features that suit large teams and existing codebases. Both share the same middleware, DI and auth.

Q17. Middleware or filter?

Middleware sees the raw HttpContext for every request (logging, CORS, exception handling, compression). Filters run inside the MVC or endpoint layer, after model binding, so they can see arguments, ModelState and results (validation, per-action policies, response shaping).

Q18. How do you implement global error handling with consistent responses?

Use AddProblemDetails() plus UseExceptionHandler and one or more IExceptionHandler implementations that map exception types to RFC 9457 ProblemDetails responses. Register it first in the pipeline. Avoid try/catch in every action.
public class NotFoundHandler : IExceptionHandler
{
public async ValueTask TryHandleAsync(HttpContext ctx, Exception ex, CancellationToken ct)
{
if (ex is not NotFoundException) return false;
ctx.Response.StatusCode = 404;
await ctx.Response.WriteAsJsonAsync(new ProblemDetails { Title = ex.Message }, ct);
return true;
}
}

Want to build these skills through real projects?

Skill Hives offers practical web development training with hands-on project work for beginners and career switchers.

Q19. Authentication vs authorization: how do JWT, policies and 401 vs 403 fit together?

Authentication establishes identity, for example by validating a JWT’s signature, issuer, audience and expiry. Authorization decides access with roles, claims or policies (AddAuthorization + RequireAuthorization). 401 means “not authenticated,” and 403 means “authenticated but not allowed.” Keep access tokens short-lived and use refresh tokens.

Q20. How do you protect an API from abuse using built-in features?

Use the built-in rate-limiting middleware (AddRateLimiter) with fixed window, sliding window, token bucket or concurrency limiters. Partition by user, API key or IP. Return 429 with Retry-After. Behind a proxy, configure forwarded headers first, otherwise every client looks like one IP.

Q21. What caching options exist, and what problem does HybridCache solve?

• In-memory: fast, but per-instance.
• Distributed (Redis): shared across instances, but slower.
• Output caching: caches whole responses.
• HybridCache: a two-level (L1 + L2) API with built-in stampede protection, so 1,000 concurrent misses trigger one factory call.

Also mention invalidation (tags) and expiration strategy.

Q22. How do you handle API documentation and versioning in .NET 10?

Use the built-in Microsoft.AspNetCore.OpenApi (AddOpenApi() / MapOpenApi(), with OpenAPI 3.1 support in .NET 10) instead of relying on Swashbuckle. Version through the URL path, a header or a query string with Asp.Versioning. Never break existing clients silently: deprecate, announce, then remove.

Q23. What’s wrong with new HttpClient() per request, and how do you make outbound calls resilient?

Creating one per request causes socket exhaustion, while a single static one can miss DNS changes. IHttpClientFactory pools and rotates handlers. Add resilience with AddStandardResilienceHandler() (retry, circuit breaker, timeouts, based on Polly) and retry only idempotent calls.

Q24. How do you find and fix slow EF Core queries?

• Use AsNoTracking() for read-only queries.
• Project with Select instead of loading whole entities.
• Fix N+1 with Include or projections.
• Use AsSplitQuery() to avoid cartesian explosion.
• Check the generated SQL (ToQueryString(), logging).
• Add indexes.
• Use ExecuteUpdateAsync / ExecuteDeleteAsync for bulk changes.

Q25. What is the correct lifetime for a DbContext, and how do you handle concurrency conflicts?

Use scoped (one per request/unit of work). A DbContext isn’t thread-safe, so don’t run parallel operations on one instance. AddDbContextPool reduces allocation overhead. For lost updates, use a row-version concurrency token and catch DbUpdateConcurrencyException.

Q26. How do you run migrations safely in production?

Don’t call Database.Migrate() on startup across many instances, which risks race conditions and long locks. Generate an idempotent SQL script or a migration bundle, run it in the deployment pipeline, and use backward-compatible (expand/contract) schema changes so old and new code can coexist.

Q27. How do global query filters work, for example soft delete or multi-tenancy?

HasQueryFilter applies a predicate to every query for an entity, which is useful for IsDeleted and TenantId. Bypass it with IgnoreQueryFilters(). In EF Core 10, named query filters let you disable a specific filter without disabling all of them. Watch out for the tenant value being captured per DbContext instance.

Q28. How do you run background work correctly in ASP.NET Core?

Use BackgroundService, which is a singleton. Create a scope per unit of work with IServiceScopeFactory, honor the stoppingToken, and catch exceptions inside the loop (an unhandled exception can stop the host). For producer/consumer flows, use System.Threading.Channels. For durable, retryable jobs, use a queue or a job system (Hangfire, Quartz, a message broker) rather than in-process fire-and-forget.

Q29. How do you make a .NET service observable?

Combine three signals:

• Structured logging: ILogger with templates (not string interpolation), plus correlation IDs.
• Metrics and tracing: OpenTelemetry, exported via OTLP.
• Health checks: separate liveness from readiness (MapHealthChecks).

.NET Aspire (the dashboard and service defaults) wires much of this up locally.

Q30. Production CPU is at 100% (or memory keeps growing). Walk me through your diagnosis.

1. Check dashboards and recent deployments.
2. Use dotnet-counters for live GC, thread-pool and request metrics.
3. Take a trace (dotnet-trace) for CPU hotspots or a dump/gcdump (dotnet-dump, dotnet-gcdump) for memory.
4. Look for thread-pool starvation (sync-over-async), GC pressure from allocations, or unbounded caches.
5. Reproduce, fix, and add a metric or alert so it’s caught earlier next time.

5 Mistakes That Get Candidates Rejected

1. Ignoring middleware order. Placing CORS after authentication, or exception handling last, signals you’ve never debugged a real pipeline.
2. Getting DI lifetimes wrong. Captive dependencies and singleton DbContexts are among the most common red flags.
3. Sync-over-async. Using .Result or .Wait() causes thread-pool starvation, and interviewers know it.
4. Running old .NET versions. With .NET 8 support ending in November 2026, defaulting to outdated versions suggests your knowledge has gone stale.
5. Reciting definitions without mechanisms. Saying what a thing is isn’t enough. Explain how it works, when it breaks and what you’d do about it.

How to Prepare for a .NET Interview (A Simple Plan)

Reading questions isn’t enough. A better approach is to build a small project (an API with authentication, EF Core, caching and a background job), break it deliberately, and then fix it. That is how you gain the “mechanism” answers interviewers want.

Skill Hives, an IT training company in Mohali and Chandigarh, structures its training around practical projects and mentor guidance rather than theory alone. For students comparing options, a 6 month training in Chandigarh and Mohali format gives enough time to move from fundamentals to a portfolio project. If you are choosing the best training after 12th, look for programs that combine core programming, a web development training course component, and interview preparation, so you finish with real skills rather than just a certificate.

Skill Hives does not guarantee jobs or placement outcomes. What structured training can do is give you a clearer path, working projects and the confidence to explain your own code. For the current curriculum, batch timings and fees, contact the team directly.

Ready to turn interview prep into real skills?

Join a practical IT training course in Mohali and Chandigarh, with hands-on projects and mentor guidance.

Key Takeaways

• Interviewers test mechanisms and trade-offs, not memorized definitions.
• .NET 10 is the LTS release, and .NET 8 support ends in November 2026.
• Get DI lifetimes, middleware order and async/await right, since they cause the most rejections.
• Know your EF Core performance basics: AsNoTracking, projections, N+1 fixes and safe migrations.
• Prepare a production debugging story: dotnet-counters, dotnet-trace and dotnet-dump.
• Build and break a real project. It’s the fastest way to earn credible answers.

Frequently Asked Questions

Is .NET Core still relevant in 2027?

Yes. “.NET Core” is now simply called “.NET,” and it remains widely used for web APIs, cloud services and enterprise applications. Since .NET 5 the platform has been unified, with .NET 10 as the current LTS release, so learning modern .NET is a solid choice.

Which .NET version should I learn?

Learn the current .NET, meaning .NET 10 (LTS). Even-numbered releases are LTS with 3 years of support, while odd-numbered releases are STS. Avoid starting new work on .NET Framework, which is in maintenance mode, and note that .NET 8 support ends in November 2026.

What are the most asked .NET Core interview questions?

Common topics include the garbage collector, async/await, dependency injection lifetimes, middleware order, Entity Framework Core performance, authentication and authorization, caching, background services, and production debugging.

Are .NET Core interviews different for freshers and experienced developers?

Yes. Freshers are usually asked about C# basics, compilation, value vs reference types and simple ASP.NET Core concepts. Mid and senior candidates face questions on DI pitfalls, EF Core performance, resilience, observability and production diagnosis.

Can I learn .NET after 12th or without a computer science degree?

Yes. Many learners start after 12th with programming basics and progress through C#, databases and web development. Practical projects matter more than the exact degree, so choose training that emphasizes hands-on work.

How long does it take to prepare for a .NET developer role?

It depends on your starting point. Beginners typically need several months of structured learning plus projects, which is why longer formats such as a 6-month training program are popular. Experienced developers may only need focused revision.

Does Skill Hives offer web development training?

Skill Hives offers Web Development Training with a focus on practical, project-based learning. For details on the current curriculum, technologies covered, schedule and fees, please contact the team directly.

Conclusion

Cracking a .NET Core interview in 2027 comes down to understanding how things work, not just what they’re called. Know your runtime, master async and DI, keep your middleware order straight, write efficient EF Core queries, and be ready to walk through a real production problem. Avoid the five common mistakes, and back your answers with a project you’ve built yourself.

As the future of IT jobs rewards developers who can build and debug complete systems, the strongest preparation is structured learning combined with practice. If you want guidance, Skill Hives can help you build practical skills through its IT training programs in Mohali and Chandigarh.