C# and .NET are widely used for enterprise applications, web APIs and cloud services. These C# and .NET interview questions cover types, OOP and the CLR for freshers, then LINQ, async/await, dependency injection, ASP.NET Core, Entity Framework Core and performance for experienced .NET developers.
30 questions · Updated
Fundamentals, definitions and simple scenarios. Good for freshers and warm-ups.
.NET Framework is the original Windows-only platform, now only maintained. .NET Core was the cross-platform, open-source rewrite that runs on Windows, Linux and macOS.
From version 5 it is simply called .NET (such as .NET 8 and .NET 9), unifying the platform.
New projects should use the current long-term support version of .NET.
Value types, such as int, double, bool, struct and enum, hold their data directly and are copied on assignment.
Reference types, such as class, string, arrays and delegates, hold a reference to an object on the managed heap, so two variables can point to the same object.
Boxing converts a value type into an object, which costs performance.
An abstract class can have fields, constructors, implemented methods and abstract members, and a class can inherit only one.
An interface defines a contract that a class can implement many of; since C# 8 interfaces can have default implementations but still no instance fields.
I use interfaces for capabilities and dependency injection, and abstract classes for shared base behaviour.
C# code is compiled into Intermediate Language (IL) stored in assemblies (DLLs).
The Common Language Runtime (CLR) loads them and the just-in-time compiler converts IL into native machine code when methods are first called.
The CLR also provides garbage collection, type safety and exception handling.
Native AOT can compile apps ahead of time for faster start-up.
A struct is a value type, copied on assignment and usually stored inline, which suits small, immutable data such as a point or a money amount.
A class is a reference type allocated on the heap and shared by reference, supporting inheritance.
Large or frequently copied structs hurt performance, and readonly struct helps make them immutable.
Strings in .NET are immutable, so each concatenation in a loop creates a new string and copies the old content, which is slow and creates garbage.
StringBuilder keeps a mutable buffer and appends efficiently, which suits building large strings.
For a few values, interpolation ($"Hello {name}") is clearer and the compiler optimises it.
const values are compile-time constants, must be primitive types or strings, are implicitly static and are copied into every assembly that uses them. readonly fields are set at declaration or in a constructor, can be any type and can differ per instance. Use readonly, or static readonly, for values that might change between versions.
Properties expose data with get and set accessors while keeping the field private, so you can add validation or computed logic later without changing callers. Auto-properties, such as public string Name { get; set; }, generate the backing field. init accessors allow setting only during object creation, and required forces callers to set a property.
A nullable value type, int?, can hold a number or null.
Nullable reference types, enabled by default in new projects, make the compiler warn when a reference that might be null is used without checking; string means "never null" and string? means "may be null".
Operators such as ?., ?? and ??= handle nulls concisely.
Code that may fail goes in try, specific exceptions are caught in catch blocks from most to least specific, and finally runs cleanup regardless of the outcome. throw; rethrows while keeping the stack trace.
The using statement disposes resources automatically.
Exception filters (catch (HttpRequestException e) when (...)) catch only matching cases.
public (accessible everywhere), private (only within the type, the default for members), protected (the type and derived types), internal (within the same assembly, the default for types), protected internal (same assembly or derived types) and private protected (derived types in the same assembly). file limits a type to one source file.
Applied problems, trade-offs and questions about your own projects.
Language Integrated Query lets you query collections, databases and XML with C# syntax, such as orders.Where(o => o.Total > 1000).OrderBy(o => o.Date).Select(o => o.Id).
LINQ to Objects works on IEnumerable in memory; LINQ with Entity Framework uses IQueryable and is translated into SQL.
Queries use deferred execution, running only when enumerated.
An async method returns Task or Task<T>, and await pauses the method without blocking the thread until the awaited operation completes, then continues.
This frees threads to handle other requests while waiting on I/O, which improves scalability in web apps.
Pitfalls are blocking with .Result or .Wait(), which can deadlock, and using async void except for event handlers.
Transient creates a new instance every time it is requested, Scoped creates one instance per HTTP request, and Singleton creates one instance for the whole application.
DbContext is typically scoped.
A singleton must not depend on a scoped service, because it would keep that instance alive beyond its request.
Middleware are components in the request pipeline, configured in Program.cs, that each handle a request and either pass it to the next component or end it.
Examples are exception handling, HTTPS redirection, static files, routing, CORS, authentication and authorisation.
Order matters, for example authentication must run before authorisation.
A delegate is a type-safe reference to a method.
Func<T, TResult> represents a method that returns a value and Action<T> one that returns nothing; they are used with lambdas, as in LINQ.
Events are built on delegates and let a class notify subscribers, such as button.Click += OnClick, while preventing outside code from raising the event or clearing subscribers.
Generics let you write type-safe classes and methods that work with any type, such as List<T> or Repository<T>, without boxing or casting. Constraints restrict which types can be used: where T : class, where T : struct, where T : new() for types with a parameterless constructor, where T : IComparable<T> for an interface, or where T : notnull.
Extension methods add methods to existing types without changing or inheriting from them.
They are static methods in a static class whose first parameter has the this modifier, such as public static bool IsValidEmail(this string s).
LINQ is built from extension methods on IEnumerable<T>.
They should be used carefully so they do not hide important behaviour.
Records are reference types (or value types with record struct) designed for immutable data.
They provide value-based equality, a readable ToString, and with expressions to create modified copies, such as var updated = order with { Status = "Shipped" }.
A positional record, record Point(int X, int Y), declares the constructor and properties in one line.
They suit DTOs and domain values.
Pattern matching tests a value's shape and extracts data: type patterns (if (shape is Circle c)), property patterns ({ Status: "Paid", Amount: > 1000 }), relational patterns (< 0), logical patterns (and, or, not) and list patterns. Switch expressions combine them concisely, for example calculating a shipping fee from an order's country and weight.
Task represents an asynchronous operation and is the default return type.
ValueTask avoids allocating when a result is often available synchronously, such as from a cache, but can only be awaited once, so it is used for hot paths.
To run independent async operations at the same time, start them and await Task.WhenAll; Parallel.ForEachAsync limits concurrency for many items.
Configuration is combined from sources in order: appsettings.json, appsettings.{Environment}.json, user secrets in development, environment variables and command-line arguments, with later sources overriding earlier ones.
The options pattern binds sections to strongly typed classes with services.Configure<T>() and injects IOptions<T>, IOptionsSnapshot or IOptionsMonitor.
Secrets in production come from Key Vault or similar.
System design, deep internals, leadership and tough follow-ups.
EF Core is .NET's ORM, mapping classes to tables with DbContext and DbSet and generating SQL from LINQ.
To keep it fast I use AsNoTracking for read-only queries, project to DTOs with Select to fetch only needed columns, avoid N+1 queries with Include or split queries, paginate, add indexes, and check generated SQL with logging.
Compiled queries and raw SQL help hot paths.
IEnumerable works on in-memory collections, so filters run in C# after data is loaded.
IQueryable builds an expression tree that a provider such as EF Core translates into SQL, so filters, sorting and paging run in the database.
Calling ToList() or switching to IEnumerable too early can load an entire table into memory.
The CLR's garbage collector frees unreachable objects automatically.
The heap has three generations: Gen 0 for new short-lived objects, collected often; Gen 1 as a buffer; and Gen 2 for long-lived objects.
Objects over 85 KB go to the Large Object Heap.
IDisposable with using statements releases unmanaged resources like file handles and connections promptly, since the GC does not manage those.
Controllers group endpoints into classes with attribute routing, model binding, filters and conventions, which suits large APIs and teams used to MVC.
Minimal APIs map endpoints directly with app.MapGet and similar using lambdas, with less ceremony and slightly better performance, and they now support filters, validation, route groups and OpenAPI.
Both run on the same pipeline.
Authentication identifies the user through schemes such as cookies, JWT bearer tokens or OpenID Connect with an identity provider such as Microsoft Entra ID; ASP.NET Core Identity manages users and passwords. Authorisation decides what they can do, with [Authorize], roles, and policy-based rules built from requirements and handlers, including resource-based checks.
Migrations track model changes: dotnet ef migrations add creates one and the database is updated with dotnet ef database update or, better in production, a generated SQL script or migration bundle. Optimistic concurrency uses a concurrency token, such as a rowversion column; if two users edit the same row, the second save throws DbUpdateConcurrencyException, which the app resolves.
Use Span<T> and Memory<T> to work with slices of arrays and strings without copying, ArrayPool<T> and object pooling to reuse buffers, struct types and stackalloc for small temporary data, StringBuilder and string.Create for strings, and System.Text.Json source generators for serialisation. BenchmarkDotNet measures improvements, and dotnet-counters and dotnet-trace find allocation hot spots.
Unit tests use xUnit, NUnit or MSTest with Moq or NSubstitute for mocks and FluentAssertions for readable checks.
Integration tests use WebApplicationFactory to host the API in memory and call it with HttpClient, with Testcontainers providing real databases.
EF Core's in-memory provider behaves differently from a real database, so it is not recommended for integration tests.
See all Backend Developer interview questions, covering Node.js, Express.js, NestJS, Python, Django and more.