.NET Interview Questions & Answers

Razor Pages is a page-based programming model in ASP.NET Core that makes building web UI simpler and more productive than MVC. Each page has a .cshtml view file and a .cshtml.cs PageModel code-behind file. They're ideal for page-focused scenarios like forms and CRUD operations. Razor Pages use conventions for routing and organization, reducing boilerplate code. They support the same features as MVC (model binding, validation, filters) but with less ceremony.

ASP.NET Core has built-in logging via ILogger interface injected through DI. Configure logging providers (Console, Debug, EventSource, EventLog) in Program.cs using builder.Logging. Use log levels (Trace, Debug, Information, Warning, Error, Critical) to categorize messages. Third-party providers like Serilog, NLog, or Application Insights offer advanced features. Structured logging with message templates enables better querying and filtering of logs.

Routing maps incoming HTTP requests to executable endpoints (actions, Razor Pages, SignalR hubs). Endpoint routing separates route matching from endpoint execution for better performance. Configure routes using conventional routing (MapControllerRoute) or attribute routing ([Route] attributes). Route templates use parameters like {controller}/{action}/{id?}. Endpoint routing enables middleware to inspect the selected endpoint before execution, supporting features like authorization and CORS.

API Controllers ([ApiController] attribute) are optimized for building HTTP APIs, automatically handling model validation and returning appropriate status codes. They infer binding sources ([FromBody], [FromRoute]) automatically and return JSON by default. MVC Controllers are designed for rendering views and returning HTML. API Controllers don't support views and focus on data serialization. API Controllers provide better developer experience with automatic 400 responses for validation errors.

Cross-Origin Resource Sharing (CORS) is a security feature that allows or restricts web applications from making requests to different domains. Enable CORS in ASP.NET Core by adding services.AddCors() with policies defining allowed origins, methods, and headers. Apply middleware with app.UseCors() before routing. Use [EnableCors] attribute on controllers/actions for granular control. CORS prevents unauthorized cross-domain requests while enabling legitimate scenarios like calling APIs from different frontend applications.

Data Annotations are attributes applied to model properties for validation, display, and database schema definition. Common validation attributes include [Required], [StringLength], [Range], [EmailAddress], and [RegularExpression]. Display attributes like [Display] and [DisplayFormat] control UI rendering. EF Core uses annotations like [Key], [MaxLength], and [Column] for database mapping. They provide declarative validation that works on both client and server sides, reducing code duplication.

Kestrel is the cross-platform web server included with ASP.NET Core, suitable for production use. IIS acts as a reverse proxy forwarding requests to Kestrel on Windows servers. To host on IIS, install ASP.NET Core Hosting Bundle, configure web.config with processPath and arguments. Kestrel can run standalone behind a reverse proxy (Nginx, Apache) or directly exposed. Use Kestrel for cross-platform deployments and IIS integration for Windows-specific features like Windows Authentication.

Encapsulation bundles data and methods into classes, hiding internal details and exposing only necessary parts. Inheritance allows classes to inherit properties and methods from parent classes, promoting code reuse. Polymorphism enables objects to take multiple forms through method overriding and interfaces, allowing different implementations of the same interface. Abstraction hides complex implementation details and shows only essential features, using abstract classes and interfaces to define contracts.

Abstract classes can have both abstract (no implementation) and concrete methods, constructors, and fields. Interfaces (pre-C# 8.0) only declare method signatures without implementation and support multiple inheritance. Abstract classes are used when classes share common behavior, while interfaces define contracts for unrelated classes. A class can implement multiple interfaces but inherit from only one abstract class. Modern C# interfaces support default implementations, narrowing the distinction.

Const fields are compile-time constants, must be initialized at declaration, and their value cannot change—they're implicitly static. Readonly fields are runtime constants, can be initialized in declaration or constructor, and their value can differ per instance. Static members belong to the type rather than instances and are shared across all objects. Const is used for values that never change (like Math.PI), readonly for values set during construction, and static for shared data/methods.

Value types (int, struct, enum) store data directly and are allocated on the stack, making them faster but with limited size. Reference types (class, interface, delegate) store a reference to data allocated on the heap. Value types are copied by value, while reference types copy references. Value types cannot be null (unless nullable), while reference types can. Value types inherit from System.ValueType, reference types from System.Object.

Boxing converts a value type to object or interface type, wrapping it in a reference type container on the heap. Unboxing extracts the value type from the object back to its original type. Boxing happens implicitly, while unboxing requires explicit casting. These operations have performance overhead due to heap allocation and type checking. Modern C# with generics minimizes boxing by preserving type information, making collections more efficient.

A delegate is a type-safe function pointer that references methods with a specific signature. Delegates enable passing methods as parameters, implementing callback mechanisms, and event handling. They support multicast (invoking multiple methods), covariance, and contravariance. Common built-in delegates include Action (void return), Func (returns value), and Predicate (returns bool). Delegates are the foundation for events and lambda expressions in C#.

Events are a special type of delegate that implements the publisher-subscriber pattern for notification. While delegates can be invoked and reassigned by anyone, events can only be invoked by the declaring class and subscribers can only add/remove handlers. Events use += and -= operators for subscription, providing encapsulation and preventing external invocation. Events are commonly used for UI interactions, state changes, and message passing. They're declared using the event keyword with a delegate type.

Generics enable writing type-safe, reusable code that works with any data type without casting or boxing. They provide compile-time type checking, better performance than object-based code, and code reusability. Generic classes, methods, interfaces, and delegates use type parameters (T) that are specified at instantiation. Common examples include List, Dictionary, and custom repository patterns. Generics eliminate runtime type errors and reduce code duplication.

LINQ (Language Integrated Query) provides a consistent way to query collections, databases, XML, and other data sources using C# syntax. It offers two syntaxes: query syntax (SQL-like) and method syntax (using extension methods). Example: var adults = people.Where(p => p.Age >= 18).OrderBy(p => p.Name).Select(p => p.Name). LINQ queries are often deferred (lazy evaluation), executing only when enumerated. It supports filtering, projection, aggregation, grouping, and joining operations.

IEnumerable is the base interface for iterating collections in-memory using foreach, with deferred execution. IQueryable extends IEnumerable for queryable data sources (like databases), translating expressions to queries (SQL) that execute on the data source. List is a concrete collection class with immediate execution and methods like Add, Remove, and indexed access. Use IEnumerable for in-memory operations, IQueryable for external data sources, and List when you need collection manipulation methods.

Both ref and out pass parameters by reference, allowing methods to modify the original variable. Ref parameters must be initialized before passing, while out parameters must be assigned within the method before returning. Ref is bidirectional (input and output), while out is primarily for output. Out parameters are useful when returning multiple values from a method. Modern C# offers tuples as a cleaner alternative to out parameters in many scenarios.

Async and await enable asynchronous programming without blocking threads, improving scalability and responsiveness. The async keyword marks methods that contain await operations, while await suspends method execution until the awaited task completes. This frees up threads to handle other work while waiting for I/O operations. Async methods return Task or Task and use asynchronous APIs (HttpClient, database calls). It's essential for building scalable web applications and responsive UIs.

Synchronous programming executes operations sequentially, blocking until each operation completes before moving to the next. Asynchronous programming allows operations to run concurrently without blocking, improving application responsiveness and throughput. Synchronous code is simpler but wastes resources during I/O operations. Asynchronous code uses callbacks, promises, or async/await to handle completion. In web applications, async operations allow servers to handle more concurrent requests with fewer threads.

Task represents an asynchronous operation that can be awaited and provides result access, cancellation, and continuation support. ValueTask is a value type alternative to Task designed for high-performance scenarios where the result is often synchronously available. ValueTask reduces heap allocations but has limitations (cannot await multiple times, more restrictive). Use Task for most scenarios and ValueTask only when profiling shows significant allocation overhead. Both support generic (Task, ValueTask) and non-generic versions.

Var uses implicit typing where the compiler infers the type at compile-time from the initializer, providing strong typing. Dynamic defers type checking to runtime, allowing operations that may not exist, useful for COM interop or dynamic languages. Object is the base type for all types but requires explicit casting. Var is compile-time sugar, dynamic disables compile-time checking, and object is explicit type boxing. Var is preferred for readability, dynamic for flexible scenarios, object for generic type handling.

Encapsulation bundles data and methods into a class while hiding internal implementation details, exposing only necessary interfaces. Achieve it using access modifiers (private, protected, public, internal) to control member visibility. Properties provide controlled access to private fields with get/set accessors. Encapsulation protects object integrity by preventing external code from directly modifying internal state. It promotes maintainability by allowing internal changes without affecting external code that uses the class.

Method overloading provides multiple methods with the same name but different parameters (number, types, or order) in the same class, determined at compile-time. Method overriding allows a derived class to provide a specific implementation of a method defined in the base class using virtual/override keywords, determined at runtime (polymorphism). Overloading is about different method signatures, while overriding is about changing inherited method behavior. Overloading is static binding, overriding is dynamic binding.

The == operator checks reference equality for reference types (whether two references point to the same object) unless overloaded. Equals() is a virtual method that checks value equality by comparing object contents, and can be overridden for custom comparison logic. For value types, both compare values by default. For strings, both compare content because string overloads ==. Best practice: override Equals() and GetHashCode() together for custom types, and use == for reference comparison or types that override it.

Extension methods allow adding new methods to existing types without modifying the original type or creating a derived type. They're static methods in static classes, with the first parameter using the this keyword to specify the extended type. Extension methods enable fluent APIs and extending sealed classes or types you don't control. LINQ methods (Where, Select, OrderBy) are implemented as extension methods on IEnumerable. They're resolved at compile-time and don't have access to private members.

A sealed class cannot be inherited, preventing other classes from extending it. It's used to prevent further derivation when the class is fully implemented and inheritance would compromise design or security. Sealed classes offer performance benefits because the runtime doesn't need to search for overridden methods. Methods in sealed classes can also be sealed to prevent overriding in derived classes. Common examples include System.String and value types, which are implicitly sealed.

Stored procedures are precompiled SQL code stored in the database, executed with a single command. They improve performance through query plan caching, reduce network traffic by sending only procedure names, and enhance security by limiting direct table access. They enable encapsulating complex business logic in the database and provide a consistent interface for data operations. Stored procedures support parameters, variables, control flow, and error handling, making them ideal for complex data operations.

Triggers are special stored procedures that automatically execute in response to specific database events (INSERT, UPDATE, DELETE). They're used for enforcing business rules, maintaining audit trails, enforcing referential integrity, or performing cascading operations. Triggers have access to OLD and NEW row versions, enabling validation and logging changes. Use triggers cautiously as they add overhead and can cause unexpected side effects. They're hidden from application code, which can make debugging challenging.

INNER JOIN returns only rows where there's a match in both tables based on the join condition. LEFT JOIN returns all rows from the left table plus matched rows from the right table, with NULLs for unmatched right rows. RIGHT JOIN returns all rows from the right table plus matched rows from the left table, with NULLs for unmatched left rows. Use INNER JOIN for required relationships, LEFT JOIN when the left table is primary, and RIGHT JOIN when the right table is primary.

Indexes are database structures that improve query performance by creating ordered pointers to data, similar to a book's index. They speed up data retrieval but slow down INSERT, UPDATE, and DELETE operations because indexes must be maintained. Clustered indexes determine the physical order of data in a table (one per table), while non-clustered indexes create separate structures with pointers. Create indexes on columns frequently used in WHERE, JOIN, and ORDER BY clauses, balancing query performance against write overhead.

Start by analyzing the execution plan to identify table scans, missing indexes, or inefficient joins. Add appropriate indexes on columns used in WHERE, JOIN, and ORDER BY clauses. Avoid SELECT *, use WHERE instead of HAVING where possible, and limit result sets. Replace subqueries with JOINs when appropriate and avoid functions on indexed columns in WHERE clauses. Consider partitioning large tables, updating statistics, and using query hints. Profile both query execution and database server performance metrics.

Transactions are units of work that execute as a single atomic operation, ensuring data integrity through ACID properties (Atomicity, Consistency, Isolation, Durability). They guarantee all operations complete successfully or none do, preventing partial updates. Transactions use BEGIN TRANSACTION, COMMIT (permanent changes), and ROLLBACK (undo changes) commands. They're crucial for maintaining data consistency in multi-step operations like fund transfers. Proper transaction management prevents data corruption and ensures business logic integrity.

Normalization organizes data to reduce redundancy and improve integrity by dividing large tables into smaller related tables (1NF, 2NF, 3NF). It eliminates data anomalies and ensures data consistency but can impact read performance due to joins. Denormalization intentionally introduces redundancy to improve read performance by reducing joins, at the cost of storage and update complexity. Use normalization for transactional systems (OLTP) requiring data integrity and denormalization for reporting systems (OLAP) prioritizing read speed.

Views are virtual tables based on SQL queries that don't store data themselves but present data from underlying tables. They simplify complex queries, provide security by restricting access to specific columns/rows, and present data in different formats without affecting base tables. Views can be used in queries like regular tables and support most SELECT operations. Use them for frequently used complex joins, enforcing row-level security, or providing backward compatibility when table structures change.

EF Core migrations track and apply database schema changes using code-first approach. Create migrations with "dotnet ef migrations add MigrationName" which generates migration files with Up/Down methods. Apply migrations using "dotnet ef database update" or programmatically using context.Database.Migrate(). Migrations support version control, enabling schema evolution across environments. Use migration bundles for production deployments, seed data in OnModelCreating, and test migrations on development databases before production. Maintain migration history for rollback capability.

Entity Framework is an ORM (Object-Relational Mapper) that abstracts database operations using C# objects and LINQ, providing automatic SQL generation and change tracking. ADO.NET is a low-level data access technology requiring manual SQL commands, data readers, and connection management. EF Core offers productivity with less boilerplate code but has some performance overhead. ADO.NET provides fine