Best .NET Interview Questions 2025

.NET Framework is the original Windows-only implementation, while .NET Core (now .NET 5+) is a cross-platform, open-source framework supporting Windows, macOS, and Linux.

CLR is the virtual machine component of .NET that manages memory allocation, security, type safety, exception handling, and provides garbage collection.

GAC is a machine-wide cache for .NET assemblies that allows multiple versions of the same assembly to be installed and used by different applications.

Managed code runs under the CLR's management with automatic memory management, while unmanaged code runs directly on the operating system without runtime services.

The main components are the Common Language Runtime (CLR), Base Class Library (BCL), Common Type System (CTS), and Common Language Specification (CLS).

Assemblies are deployment and versioning units in .NET that contain compiled code, metadata, and resources, and can be executed by the CLR.

.NET Framework is Windows-only, .NET Core was cross-platform, and .NET 5+ is the unified platform merging .NET Framework and .NET Core functionalities.

MSIL is a low-level, object-oriented programming language used by .NET compilers to generate platform-independent code that can be converted to native machine code.

JIT compilation converts MSIL code to native machine code at runtime, optimizing performance by compiling only the code that is actually executed.

Key advantages include language independence, cross-platform support, robust security, extensive class libraries, automatic memory management, and strong developer tooling.

Value types (structs, int, float) store data directly, while reference types (classes, objects) store a reference to the memory location of the data.

The 'var' keyword enables implicit typing, allowing the compiler to determine the variable's type based on the assigned value at compile-time.

Nullable types allow value types to have a null value, providing a way to represent the absence of a value for types that normally cannot be null.

'ref' requires the variable to be initialized before passing, while 'out' does not require initialization and must be assigned a value inside the method.

Extension methods allow adding methods to existing types without modifying the original type, created by defining a static method with the 'this' keyword.

Abstract classes can have implementation and state, while interfaces only define contracts. A class can implement multiple interfaces but inherit from only one abstract class.

A delegate is a type-safe function pointer that references a method with a specific signature, enabling method passing and callback implementations.

Events are a way for classes to notify other classes or objects when something of interest happens, using delegates to manage and trigger notifications.

LINQ is a set of features that adds native data querying capabilities to .NET languages, allowing querying of in-memory collections, databases, XML, and more.

'Virtual' methods can be overridden in derived classes, while 'override' is used in the derived class to provide a new implementation of a virtual method.

Encapsulation (data hiding), Inheritance (deriving properties), Polymorphism (multiple forms), and Abstraction (simplifying complex systems).

Polymorphism allows objects of different types to be treated uniformly, achieved through method overriding and method overloading.

Method hiding occurs when a derived class defines a method with the same name as a method in its base class, using the 'new' keyword to prevent polymorphic behavior.

The 'sealed' keyword prevents inheritance of a class or overriding of a method, providing a way to restrict further derivation or modification.

Inheritance creates an 'is-a' relationship, while composition creates a 'has-a' relationship, often considered more flexible and less tightly coupled.

Constructor chaining allows one constructor to call another constructor in the same or base class using 'this' or 'base' keywords, reducing code duplication.

Partial classes allow splitting a class definition across multiple files, useful for separating generated code and manually written code.

Method overloading allows creating multiple methods with the same name but different parameter types or numbers, resolved at compile-time.

'is' checks type compatibility, returning a boolean, while 'as' attempts to cast an object and returns null if the cast is not possible.

Generics allow creating classes and methods that can work with different data types while maintaining type safety, reducing code duplication.

Web Forms use event-driven programming with server controls, while MVC follows the Model-View-Controller pattern, offering better separation of concerns and testability.

The request pipeline in ASP.NET Core is a series of middleware components that process HTTP requests and responses in a sequential manner.

Razor Pages is a page-based programming model that makes building web UI simpler by combining the page's markup and server-side logic in a single file.

Model binding maps HTTP request data to action method parameters, automatically converting incoming data to .NET types based on parameter names and types.

Routing is responsible for mapping request URIs to endpoint selectors, allowing developers to define URL patterns for web applications.

Action filters are attributes that can run before or after controller actions, used for cross-cutting concerns like logging, caching, or authorization.

Kestrel is a cross-platform, lightweight web server for ASP.NET Core, designed to be fast, lightweight, and easily configurable.

ViewModels are classes specifically designed to carry data for a view, providing a clean separation between domain models and presentation logic.

Tag helpers enable server-side code to participate in creating and rendering HTML elements in Razor files, making views more readable and maintainable.

These are short-lived storage mechanisms in ASP.NET MVC for passing data between actions and views, with slight differences in type safety and persistence.

Improvements include cross-platform support, modular architecture, better performance, side-by-side versioning, and open-source development.

Microservices are small, independently deployable services that communicate via APIs, promoting scalability, flexibility, and easier maintenance.

gRPC is a high-performance, open-source RPC (Remote Procedure Call) framework that uses Protocol Buffers for efficient, language-agnostic communication.

The built-in DI container promotes loose coupling, supports lifecycle management, improves testability, and simplifies configuration of service dependencies.

Worker services are background services that run continuously, useful for long-running tasks, background jobs, and queue processing.

Configuration providers enable loading configuration from various sources like JSON files, environment variables, command-line arguments, and in-memory collections.

IHost is a more generic host for all types of .NET applications, while WebHost is specifically designed for web applications with HTTP pipeline support.

Minimal APIs provide a lightweight way to create HTTP APIs with minimal overhead, reducing boilerplate code compared to traditional controller-based approaches.

Advantages include containerization support, cross-platform capabilities, built-in dependency injection, performance, and native cloud service integrations.

Record types are immutable reference types that provide built-in value-based equality, simplified initialization, and support for non-destructive mutation.

Dependency Injection is a design pattern that removes hard-coded dependencies, making code more modular, testable, and loosely coupled.

Service lifetimes include Transient (new instance per request), Scoped (one instance per scope), and Singleton (single instance for entire application).

Middleware components are used to handle HTTP requests and responses, performing tasks like authentication, logging, routing, and error handling.

Custom middleware is created by implementing the RequestDelegate and configuring the Use, Run, or Map extension methods in the Startup class.

Middleware is executed in the order it is added to the request pipeline, which is crucial for determining the sequence of request processing.

These methods define service lifetimes: Transient creates a new instance each time, Scoped creates one per scope, and Singleton creates a single instance for the entire application.

Constructor injection involves passing dependencies through a class constructor, allowing the DI container to automatically resolve and inject required services.

IServiceCollection is used to register services and configurations for dependency injection, allowing developers to build a service provider.

Services can be manually resolved using IServiceProvider's GetService() or GetRequiredService() methods, though constructor injection is generally preferred.

Benefits include reduced coupling, improved testability, centralized configuration, lifecycle management, and easier maintenance of complex applications.

Entity Framework Core is an object-relational mapping (ORM) framework that enables .NET developers to work with databases using .NET objects.

Database First generates models from an existing database, while Code First allows creating the database schema from C# classes and configurations.

LINQ provides two syntaxes: query syntax (SQL-like) and method syntax (extension methods), both allowing powerful data querying and manipulation.

Lazy loading loads related entities on-demand, eager loading loads related entities immediately, and explicit loading allows manual loading of related entities.

Migrations are a way to incrementally update the database schema to keep it in sync with the application's data model, enabling version control of database changes.

The repository pattern provides an abstraction layer between the data access logic and the business logic, improving maintainability and testability.

AsNoTracking() improves query performance by telling EF Core not to track changes for entities, useful for read-only scenarios.

Deferred execution means query execution is postponed until the results are actually enumerated, allowing for efficient and dynamic query composition.

Complex types are non-entity types that can be used to structure data within entities, providing a way to model complex properties without creating separate tables.

Include() loads related entities for the main query, while ThenInclude() allows loading nested related entities in a single query.

ASP.NET Core Identity is a membership system that adds login functionality, user management, and authentication to ASP.NET Core applications.

JWTs are compact, URL-safe means of representing claims between two parties, commonly used for stateless authentication in web applications.

Main authentication methods include Cookie Authentication, Bearer Token Authentication, OAuth 2.0, OpenID Connect, and JWT Authentication.

Claims-based authentication uses claims (statements about a user) to provide a more flexible and granular approach to authorization.

Authorization policies define a set of requirements that a user must meet to access a resource, providing fine-grained access control.

XSS prevention includes input validation, output encoding, using Content Security Policy (CSP), and leveraging built-in ASP.NET Core protections.

CORS is a security mechanism that allows controlled access to resources from a different domain, configurable in ASP.NET Core middleware.

ASP.NET Core Identity uses PBKDF2 with HMAC-SHA256, a one-way hash function that includes salt to securely store passwords.

Best practices include using HTTPS, implementing proper authentication, input validation, protecting against CSRF, managing secrets, and keeping dependencies updated.

Two-factor authentication adds an extra layer of security by requiring a second form of verification, often using time-based one-time passwords (TOTP).

Techniques include using async/await, minimizing allocations, leveraging caching, using value types, and employing lazy loading and eager loading strategically.

.NET's garbage collector automatically manages memory allocation and deallocation, using generational collection and various optimization strategies.

The 'readonly' keyword ensures a field can only be assigned during declaration or in the constructor, preventing modification after initialization.

Structs are value types stored on the stack, offering better performance for small objects, while classes are reference types stored on the heap.

Best practices include using structured logging, configuring log levels, centralizing log management, and avoiding logging sensitive information.

Tools like dotMemory, Visual Studio Profiler, and Application Insights help analyze memory usage, performance bottlenecks, and application health.

StringBuilder is used for efficient string manipulation, avoiding the performance overhead of creating multiple string instances during concatenation.

Compiled regular expressions cache the parsing and compilation results, improving performance for repeated regex operations.

Performance considerations include understanding deferred execution, avoiding unnecessary iterations, and using appropriate query methods.

The 'in' keyword allows passing value types by reference without copying, improving performance for large structs and reducing memory allocations.