C# and .NET Interview Questions and Answers

Encapsulation protects state and invariants behind an API. Abstraction exposes the essential behavior while hiding implementation details. Inheritance derives a type from a base type to reuse and specialize behavior. Polymorphism lets code use a common contract while dispatching to different implementations. For an order, keep state transitions inside methods such as Confirm rather than exposing unrestricted setters; use an interface when payment providers need interchangeable behavior.

Polymorphism lets one contract have many implementations. Compile-time polymorphism is method overloading: methods share a name but have different parameter lists, and the compiler chooses one. Run-time polymorphism uses a virtual or abstract member that a derived class overrides, or an interface member that each class implements; the object's actual type decides which implementation runs. The new modifier hides a base member instead of overriding it, so a call through a base-type reference still runs the base implementation.

An abstract class cannot be instantiated; it can hold instance state, constructors, implemented members, and abstract members that derived classes must implement. An interface defines a contract that unrelated types can implement; modern C# also supports default interface implementations. A class can inherit from only one class but implement multiple interfaces. Use an abstract class for a family of types that share state and behavior, and an interface for a capability that different types provide.

A static class cannot be instantiated or inherited and can contain only static members. Use it for stateless helpers and extension methods, such as a set of string utilities. Static members are shared across the application, so mutable static state needs thread-safety and is hard to isolate in tests. When behavior has dependencies or needs substitution in tests, prefer an injected service over a static class.

IEnumerable<T> exposes enumeration; LINQ-to-Objects operators execute .NET delegates as values are enumerated. IQueryable<T> exposes an expression tree that a provider, such as EF Core, can translate into a query. Many operators defer work until enumeration. ToList materializes results; repeated enumeration can repeat work or database queries. Filter and project before materializing when the provider can translate the operation.

Know a few patterns well enough to explain the problem each solves and its trade-offs. Common examples are Singleton, Factory, and Builder for object creation; Adapter, Decorator, and Facade for structure; Strategy, Observer, and State for behavior; and Repository and Unit of Work for data access. Use a pattern from your own code: describe the problem, why the pattern fitted it, and what it cost. Avoid applying patterns where a simpler design would work.

.NET is a development platform with a runtime, libraries, and tooling. C# is one of the languages used to build applications on it. The runtime provides services such as garbage collection and exception handling; ASP.NET Core provides web application and API frameworks. You write C# code, the compiler produces intermediate language, and the .NET runtime executes it.

.NET Framework is the original Windows-only implementation and is maintained for existing applications. .NET Core was the cross-platform, open-source rewrite. From .NET 5 onward, the product dropped "Core" from its name and is simply .NET; it is the recommended choice for new applications. Follow the job description: an employer maintaining legacy Windows applications may use .NET Framework, so know which runtime they use and do not assume the APIs and hosting models are identical.

ASP.NET is the web framework for .NET Framework, which runs on Windows and is typically hosted in IIS. ASP.NET Core is its cross-platform successor for modern .NET: it can be hosted in Kestrel behind a reverse proxy or in IIS, has built-in dependency injection and configuration, and handles requests through a middleware pipeline. Application models such as MVC, Razor Pages, minimal APIs, and Blazor are built on ASP.NET Core.

Model-View-Controller separates responsibilities. Routing maps a request to a controller action. The action uses model binding and validation to read input, calls services that contain the business logic, and returns a result: a view for HTML pages, or data for an API. The view renders the model with Razor. Keep controllers thin, check ModelState or rely on [ApiController] validation, and keep business rules out of views.

Use HTTP semantics consistently: 400 commonly represents invalid input, 401 means the request lacks valid authentication, and 403 means access is refused, typically because an authenticated caller lacks permission. Use 404 when a resource is not found and 409 for a conflict with current resource state. Return a consistent Problem Details response where appropriate, without leaking stack traces or secrets. Validate input and enforce authorization on the server.

EF Core is an object-relational mapper: it maps classes to tables and translates LINQ queries into SQL. When a query is slow, measure it and inspect the generated SQL and the database execution plan. Look for missing or unsuitable indexes, excess rows or columns, N+1 queries, and unnecessary round trips. Project only needed fields, paginate large results, and use no-tracking queries for suitable read-only work. Verify each change against representative data.

System design is the process of defining a system's components, interfaces, data, and infrastructure to meet functional requirements and qualities such as scalability, availability, latency, security, and cost. In an interview, it means turning a vague problem, such as designing a URL shortener, into an architecture and explaining the trade-offs behind each decision.

Learn the building blocks: load balancing, caching, databases and indexing, replication and partitioning, queues, consistency trade-offs, and failure handling. Then practice complete exercises against a timer, such as the ones below. Say your reasoning aloud, state your assumptions, and ask a colleague to change a requirement partway through. Review real architectures you have worked on, because interviewers often ask how your current system works.

Interview formats vary by company, role, and level, and they change over time, so check the company's own interview guidance and ask the recruiter. Large-scale employers commonly assess whether you clarify requirements, estimate scale, propose a working design, find bottlenecks and failure modes, and justify trade-offs. Senior roles usually involve more ambiguity and depth. A clear, reasoned design matters more than naming many technologies.

Study C# and OOP concepts, LINQ, design patterns, ASP.NET Core and MVC, Web API, SQL, and Entity Framework Core. Then practice explaining how your application is deployed and monitored. Use the role description to decide which areas need the most depth.

Basic questions check definitions, such as OOP concepts, abstract classes, interfaces, and static classes. Advanced questions ask you to apply them: choose between IEnumerable and IQueryable for a query, justify a design pattern, or explain why a polymorphic call runs a particular implementation. Prepare a short code example for each answer.

Experienced developers, including those with 5 or 10 years of experience, should be ready to go beyond definitions: diagnose a slow query, explain a production incident, compare architecture options, and defend a release or recovery strategy. Describe the constraints, your personal contribution, the outcome, and what you would improve. Expectations vary by employer and role.